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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
11,300 |
js_loadScript
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_loadScript(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
uint8_t *buf;
const char *filename;
JSValue ret;
size_t buf_len;
filename = JS_ToCString(ctx, argv[0]);
if (!filename)
return JS_EXCEPTION;
buf = js_load_file(ctx, &buf_len, filename);
if (!buf) {
JS_ThrowReferenceError(ctx, "could not load '%s'", filename);
JS_FreeCString(ctx, filename);
return JS_EXCEPTION;
}
ret = JS_Eval(ctx, (char *)buf, buf_len, filename,
JS_EVAL_TYPE_GLOBAL);
js_free(ctx, buf);
JS_FreeCString(ctx, filename);
return ret;
}
|
O0
|
c
|
js_loadScript:
subq $0x88, %rsp
movq %rsi, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movq %r8, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x147e0
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x14eeb
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0x14fc2
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rdx
leaq 0x28(%rsp), %rsi
callq 0xfed0
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x14f53
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rdx
leaq 0xf4e95(%rip), %rsi # 0x109db2
movb $0x0, %al
callq 0x2d3f0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x29e50
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0x14fc2
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x40(%rsp), %rcx
xorl %r8d, %r8d
callq 0x4ad00
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x21db0
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x29e50
movq 0x30(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rdx
addq $0x88, %rsp
retq
nopw (%rax,%rax)
|
js_loadScript:
sub rsp, 88h
mov [rsp+88h+var_20], rsi
mov [rsp+88h+var_18], rdx
mov [rsp+88h+var_28], rdi
mov [rsp+88h+var_2C], ecx
mov [rsp+88h+var_38], r8
mov rdi, [rsp+88h+var_28]
mov rax, [rsp+88h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToCString
mov [rsp+88h+var_48], rax
cmp [rsp+88h+var_48], 0
jnz short loc_14EEB
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp loc_14FC2
loc_14EEB:
mov rdi, [rsp+88h+var_28]
mov rdx, [rsp+88h+var_48]
lea rsi, [rsp+88h+var_60]
call js_load_file
mov [rsp+88h+var_40], rax
cmp [rsp+88h+var_40], 0
jnz short loc_14F53
mov rdi, [rsp+88h+var_28]
mov rdx, [rsp+88h+var_48]
lea rsi, aCouldNotLoadS_0; "could not load '%s'"
mov al, 0
call JS_ThrowReferenceError
mov [rsp+88h+var_70], rax
mov [rsp+88h+var_68], rdx
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_48]
call JS_FreeCString
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp short loc_14FC2
loc_14F53:
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_40]
mov rdx, [rsp+88h+var_60]
mov rcx, [rsp+88h+var_48]
xor r8d, r8d
call JS_Eval
mov [rsp+88h+var_80], rax
mov [rsp+88h+var_78], rdx
mov rax, [rsp+88h+var_80]
mov [rsp+88h+var_58], rax
mov rax, [rsp+88h+var_78]
mov [rsp+88h+var_50], rax
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_40]
call js_free
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_48]
call JS_FreeCString
mov rax, [rsp+88h+var_58]
mov [rsp+88h+var_10], rax
mov rax, [rsp+88h+var_50]
mov [rsp+88h+var_8], rax
loc_14FC2:
mov rax, [rsp+88h+var_10]
mov rdx, [rsp+88h+var_8]
add rsp, 88h
retn
|
long long js_loadScript(long long a1, long long a2, long long a3, int a4, long long *a5)
{
int v5; // ecx
int v6; // r8d
int v7; // r9d
long long v8; // rdx
long long v10; // [rsp+28h] [rbp-60h] BYREF
long long v11; // [rsp+30h] [rbp-58h]
long long v12; // [rsp+38h] [rbp-50h]
long long v13; // [rsp+40h] [rbp-48h]
long long v14; // [rsp+48h] [rbp-40h]
long long *v15; // [rsp+50h] [rbp-38h]
int v16; // [rsp+5Ch] [rbp-2Ch]
long long v17; // [rsp+60h] [rbp-28h]
long long v18; // [rsp+68h] [rbp-20h]
long long v19; // [rsp+70h] [rbp-18h]
long long v20; // [rsp+78h] [rbp-10h]
long long v21; // [rsp+80h] [rbp-8h]
v18 = a2;
v19 = a3;
v17 = a1;
v16 = a4;
v15 = a5;
v13 = JS_ToCString(a1, *a5, a5[1]);
if ( v13 )
{
v14 = js_load_file(v17, &v10, v13);
if ( v14 )
{
v11 = JS_Eval(v17, v14, v10, v13, 0LL);
v12 = v8;
js_free(v17, v14);
JS_FreeCString(v17, v13);
v20 = v11;
v21 = v12;
}
else
{
JS_ThrowReferenceError(v17, (unsigned int)"could not load '%s'", v13, v5, v6, v7);
JS_FreeCString(v17, v13);
LODWORD(v20) = 0;
v21 = 6LL;
}
}
else
{
LODWORD(v20) = 0;
v21 = 6LL;
}
return v20;
}
|
js_loadScript:
SUB RSP,0x88
MOV qword ptr [RSP + 0x68],RSI
MOV qword ptr [RSP + 0x70],RDX
MOV qword ptr [RSP + 0x60],RDI
MOV dword ptr [RSP + 0x5c],ECX
MOV qword ptr [RSP + 0x50],R8
MOV RDI,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001147e0
MOV qword ptr [RSP + 0x40],RAX
CMP qword ptr [RSP + 0x40],0x0
JNZ 0x00114eeb
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x00114fc2
LAB_00114eeb:
MOV RDI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x40]
LEA RSI,[RSP + 0x28]
CALL 0x0010fed0
MOV qword ptr [RSP + 0x48],RAX
CMP qword ptr [RSP + 0x48],0x0
JNZ 0x00114f53
MOV RDI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x40]
LEA RSI,[0x209db2]
MOV AL,0x0
CALL 0x0012d3f0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x00129e50
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x00114fc2
LAB_00114f53:
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x40]
XOR R8D,R8D
CALL 0x0014ad00
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00121db0
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x00129e50
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x80],RAX
LAB_00114fc2:
MOV RAX,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
ADD RSP,0x88
RET
|
int1 [16]
js_loadScript(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int1 auVar1 [16];
int8 local_60;
int1 local_58 [16];
long local_48;
long local_40;
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_48 = JS_ToCString(param_1,*param_5,param_5[1]);
if (local_48 == 0) {
local_10 = 0;
local_8 = 6;
}
else {
local_40 = js_load_file(local_28,&local_60,local_48);
if (local_40 == 0) {
JS_ThrowReferenceError(local_28,"could not load \'%s\'",local_48);
JS_FreeCString(local_28,local_48);
local_10 = 0;
local_8 = 6;
}
else {
local_58 = JS_Eval(local_28,local_40,local_60,local_48,0);
js_free(local_28,local_40);
JS_FreeCString(local_28,local_48);
local_10 = local_58._0_4_;
uStack_c = local_58._4_4_;
local_8 = local_58._8_8_;
}
}
auVar1._4_4_ = uStack_c;
auVar1._0_4_ = local_10;
auVar1._8_8_ = local_8;
return auVar1;
}
|
|
11,301 |
js_loadScript
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_loadScript(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
uint8_t *buf;
const char *filename;
JSValue ret;
size_t buf_len;
filename = JS_ToCString(ctx, argv[0]);
if (!filename)
return JS_EXCEPTION;
buf = js_load_file(ctx, &buf_len, filename);
if (!buf) {
JS_ThrowReferenceError(ctx, "could not load '%s'", filename);
JS_FreeCString(ctx, filename);
return JS_EXCEPTION;
}
ret = JS_Eval(ctx, (char *)buf, buf_len, filename,
JS_EVAL_TYPE_GLOBAL);
js_free(ctx, buf);
JS_FreeCString(ctx, filename);
return ret;
}
|
O2
|
c
|
js_loadScript:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0x11a6c
pushq $0x6
popq %rbx
testq %rax, %rax
je 0x11e19
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0xf70c
testq %rax, %rax
je 0x11e1e
movq %rax, %r12
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x29a09
movq %rax, %r13
movq %rdx, %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1726e
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b057
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %r13, %rax
movl %r13d, %r12d
jmp 0x11e42
xorl %r12d, %r12d
jmp 0x11e40
leaq 0x70e21(%rip), %rsi # 0x82c46
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1c6df
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b057
xorl %eax, %eax
orq %rax, %r12
movq %r12, %rax
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
js_loadScript:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r14, rdi
mov rsi, [r8]
mov rdx, [r8+8]
call JS_ToCString
push 6
pop rbx
test rax, rax
jz short loc_11E19
mov r15, rax
lea rsi, [rsp+38h+var_30]
mov rdi, r14
mov rdx, rax
call js_load_file
test rax, rax
jz short loc_11E1E
mov r12, rax
mov rdx, [rsp+38h+var_30]
mov rdi, r14
mov rsi, rax
mov rcx, r15
xor r8d, r8d
call JS_Eval
mov r13, rax
mov rbx, rdx
mov rdi, r14
mov rsi, r12
call js_free
mov rdi, r14
mov rsi, r15
call JS_FreeCString
mov rax, 0FFFFFFFF00000000h
and rax, r13
mov r12d, r13d
jmp short loc_11E42
loc_11E19:
xor r12d, r12d
jmp short loc_11E40
loc_11E1E:
lea rsi, aCouldNotLoadS_0; "could not load '%s'"
xor r12d, r12d
mov rdi, r14
mov rdx, r15
xor eax, eax
call JS_ThrowReferenceError
mov rdi, r14
mov rsi, r15
call JS_FreeCString
loc_11E40:
xor eax, eax
loc_11E42:
or r12, rax
mov rax, r12
mov rdx, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
unsigned long long js_loadScript(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
long long v5; // rax
long long v6; // r15
long long file; // rax
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long v11; // r12
long long v12; // r13
unsigned long long v13; // rax
long long v14; // r12
long long v16[6]; // [rsp+8h] [rbp-30h] BYREF
v5 = JS_ToCString(a1, *a5, a5[1]);
if ( !v5 )
{
v14 = 0LL;
LABEL_6:
v13 = 0LL;
return v13 | v14;
}
v6 = v5;
file = js_load_file(a1, v16, v5);
if ( !file )
{
v14 = 0LL;
JS_ThrowReferenceError(a1, (unsigned int)"could not load '%s'", v6, v8, v9, v10);
JS_FreeCString(a1, v6);
goto LABEL_6;
}
v11 = file;
v12 = JS_Eval(a1, file, v16[0], v6, 0LL);
js_free(a1, v11);
JS_FreeCString(a1, v6);
v13 = v12 & 0xFFFFFFFF00000000LL;
v14 = (unsigned int)v12;
return v13 | v14;
}
|
js_loadScript:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x00111a6c
PUSH 0x6
POP RBX
TEST RAX,RAX
JZ 0x00111e19
MOV R15,RAX
LEA RSI,[RSP + 0x8]
MOV RDI,R14
MOV RDX,RAX
CALL 0x0010f70c
TEST RAX,RAX
JZ 0x00111e1e
MOV R12,RAX
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,R14
MOV RSI,RAX
MOV RCX,R15
XOR R8D,R8D
CALL 0x00129a09
MOV R13,RAX
MOV RBX,RDX
MOV RDI,R14
MOV RSI,R12
CALL 0x0011726e
MOV RDI,R14
MOV RSI,R15
CALL 0x0011b057
MOV RAX,-0x100000000
AND RAX,R13
MOV R12D,R13D
JMP 0x00111e42
LAB_00111e19:
XOR R12D,R12D
JMP 0x00111e40
LAB_00111e1e:
LEA RSI,[0x182c46]
XOR R12D,R12D
MOV RDI,R14
MOV RDX,R15
XOR EAX,EAX
CALL 0x0011c6df
MOV RDI,R14
MOV RSI,R15
CALL 0x0011b057
LAB_00111e40:
XOR EAX,EAX
LAB_00111e42:
OR R12,RAX
MOV RAX,R12
MOV RDX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16] js_loadScript(int8 param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
int8 uVar4;
int8 *in_R8;
ulong uVar5;
int1 auVar6 [16];
int8 local_30;
lVar1 = JS_ToCString(param_1,*in_R8,in_R8[1]);
uVar4 = 6;
if (lVar1 != 0) {
lVar2 = js_load_file(param_1,&local_30,lVar1);
if (lVar2 != 0) {
auVar6 = JS_Eval(param_1,lVar2,local_30,lVar1,0);
uVar4 = auVar6._8_8_;
js_free(param_1,lVar2);
JS_FreeCString(param_1,lVar1);
uVar3 = auVar6._0_8_ & 0xffffffff00000000;
uVar5 = auVar6._0_8_ & 0xffffffff;
goto LAB_00111e42;
}
JS_ThrowReferenceError(param_1,"could not load \'%s\'",lVar1);
JS_FreeCString(param_1,lVar1);
}
uVar5 = 0;
uVar3 = 0;
LAB_00111e42:
auVar6._8_8_ = uVar4;
auVar6._0_8_ = uVar5 | uVar3;
return auVar6;
}
|
|
11,302 |
js_loadScript
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_loadScript(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
uint8_t *buf;
const char *filename;
JSValue ret;
size_t buf_len;
filename = JS_ToCString(ctx, argv[0]);
if (!filename)
return JS_EXCEPTION;
buf = js_load_file(ctx, &buf_len, filename);
if (!buf) {
JS_ThrowReferenceError(ctx, "could not load '%s'", filename);
JS_FreeCString(ctx, filename);
return JS_EXCEPTION;
}
ret = JS_Eval(ctx, (char *)buf, buf_len, filename,
JS_EVAL_TYPE_GLOBAL);
js_free(ctx, buf);
JS_FreeCString(ctx, filename);
return ret;
}
|
O3
|
c
|
js_loadScript:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%r8), %rdx
movq 0x8(%r8), %rcx
xorl %r12d, %r12d
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x21353
movl $0x6, %ebx
testq %rax, %rax
je 0x17a48
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x151b0
testq %rax, %rax
je 0x17a26
movq %rax, %r12
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x32612
movq %rax, %r13
movq %rdx, %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1d481
movq %r14, %rdi
movq %r15, %rsi
callq 0x21629
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %r13, %rax
movl %r13d, %r12d
jmp 0x17a4a
leaq 0x87219(%rip), %rsi # 0x9ec46
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x22e21
movq %r14, %rdi
movq %r15, %rsi
callq 0x21629
xorl %eax, %eax
orq %rax, %r12
movq %r12, %rax
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
js_loadScript:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r14, rdi
mov rdx, [r8]
mov rcx, [r8+8]
xor r12d, r12d
xor esi, esi
xor r8d, r8d
call JS_ToCStringLen2
mov ebx, 6
test rax, rax
jz loc_17A48
mov r15, rax
lea rsi, [rsp+38h+var_30]
mov rdi, r14
mov rdx, rax
call js_load_file
test rax, rax
jz short loc_17A26
mov r12, rax
mov rdx, [rsp+38h+var_30]
mov rdi, r14
mov rsi, rax
mov rcx, r15
xor r8d, r8d
call JS_Eval
mov r13, rax
mov rbx, rdx
mov rdi, r14
mov rsi, r12
call js_free
mov rdi, r14
mov rsi, r15
call JS_FreeCString
mov rax, 0FFFFFFFF00000000h
and rax, r13
mov r12d, r13d
jmp short loc_17A4A
loc_17A26:
lea rsi, aCouldNotLoadS_0; "could not load '%s'"
xor r12d, r12d
mov rdi, r14
mov rdx, r15
xor eax, eax
call JS_ThrowReferenceError
mov rdi, r14
mov rsi, r15
call JS_FreeCString
loc_17A48:
xor eax, eax
loc_17A4A:
or r12, rax
mov rax, r12
mov rdx, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
unsigned long long js_loadScript(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v5; // r12
long long v6; // rax
long long v7; // r15
long long file; // rax
int v9; // ecx
int v10; // r8d
int v11; // r9d
long long v12; // r12
long long v13; // r13
unsigned long long v14; // rax
long long v16[6]; // [rsp+8h] [rbp-30h] BYREF
v5 = 0LL;
v6 = JS_ToCStringLen2(a1, 0LL, *a5, a5[1], 0LL);
if ( !v6 )
goto LABEL_5;
v7 = v6;
file = js_load_file(a1, v16, v6);
if ( !file )
{
v5 = 0LL;
JS_ThrowReferenceError(a1, (unsigned int)"could not load '%s'", v7, v9, v10, v11);
JS_FreeCString(a1, v7);
LABEL_5:
v14 = 0LL;
return v14 | v5;
}
v12 = file;
v13 = JS_Eval(a1, file, v16[0], v7, 0LL);
js_free(a1, v12);
JS_FreeCString(a1, v7);
v14 = v13 & 0xFFFFFFFF00000000LL;
v5 = (unsigned int)v13;
return v14 | v5;
}
|
js_loadScript:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
XOR R12D,R12D
XOR ESI,ESI
XOR R8D,R8D
CALL 0x00121353
MOV EBX,0x6
TEST RAX,RAX
JZ 0x00117a48
MOV R15,RAX
LEA RSI,[RSP + 0x8]
MOV RDI,R14
MOV RDX,RAX
CALL 0x001151b0
TEST RAX,RAX
JZ 0x00117a26
MOV R12,RAX
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,R14
MOV RSI,RAX
MOV RCX,R15
XOR R8D,R8D
CALL 0x00132612
MOV R13,RAX
MOV RBX,RDX
MOV RDI,R14
MOV RSI,R12
CALL 0x0011d481
MOV RDI,R14
MOV RSI,R15
CALL 0x00121629
MOV RAX,-0x100000000
AND RAX,R13
MOV R12D,R13D
JMP 0x00117a4a
LAB_00117a26:
LEA RSI,[0x19ec46]
XOR R12D,R12D
MOV RDI,R14
MOV RDX,R15
XOR EAX,EAX
CALL 0x00122e21
MOV RDI,R14
MOV RSI,R15
CALL 0x00121629
LAB_00117a48:
XOR EAX,EAX
LAB_00117a4a:
OR R12,RAX
MOV RAX,R12
MOV RDX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16] js_loadScript(int8 param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
int8 uVar4;
int8 *in_R8;
ulong uVar5;
int1 auVar6 [16];
int8 local_30;
lVar1 = JS_ToCStringLen2(param_1,0,*in_R8,in_R8[1],0);
uVar4 = 6;
if (lVar1 != 0) {
lVar2 = js_load_file(param_1,&local_30,lVar1);
if (lVar2 != 0) {
auVar6 = JS_Eval(param_1,lVar2,local_30,lVar1,0);
uVar4 = auVar6._8_8_;
js_free(param_1,lVar2);
JS_FreeCString(param_1,lVar1);
uVar3 = auVar6._0_8_ & 0xffffffff00000000;
uVar5 = auVar6._0_8_ & 0xffffffff;
goto LAB_00117a4a;
}
JS_ThrowReferenceError(param_1,"could not load \'%s\'",lVar1);
JS_FreeCString(param_1,lVar1);
}
uVar5 = 0;
uVar3 = 0;
LAB_00117a4a:
auVar6._8_8_ = uVar4;
auVar6._0_8_ = uVar5 | uVar3;
return auVar6;
}
|
|
11,303 |
wt_thd_destroy
|
eloqsql/mysys/waiting_threads.c
|
void wt_thd_destroy(WT_THD *thd)
{
DBUG_ENTER("wt_thd_destroy");
DBUG_ASSERT(thd->my_resources.elements == 0);
DBUG_ASSERT(thd->waiting_for == 0);
if (thd->pins != 0)
lf_hash_put_pins(thd->pins);
delete_dynamic(&thd->my_resources);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
wt_thd_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0xffd7e
jmp 0xffd80
jmp 0xffd82
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xffd9a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xfc330
movq -0x8(%rbp), %rdi
callq 0xdae00
jmp 0xffda5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
wt_thd_destroy:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_FFD7E:
jmp short $+2
loc_FFD80:
jmp short $+2
loc_FFD82:
mov rax, [rbp+var_8]
cmp qword ptr [rax+30h], 0
jz short loc_FFD9A
mov rax, [rbp+var_8]
mov rdi, [rax+30h]
call lf_pinbox_put_pins
loc_FFD9A:
mov rdi, [rbp+var_8]
call delete_dynamic
jmp short $+2
loc_FFDA5:
add rsp, 10h
pop rbp
retn
|
long long wt_thd_destroy(long long a1)
{
if ( *(_QWORD *)(a1 + 48) )
lf_pinbox_put_pins(*(_QWORD *)(a1 + 48));
return delete_dynamic(a1);
}
|
wt_thd_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x001ffd7e
LAB_001ffd7e:
JMP 0x001ffd80
LAB_001ffd80:
JMP 0x001ffd82
LAB_001ffd82:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x001ffd9a
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x30]
CALL 0x001fc330
LAB_001ffd9a:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001dae00
JMP 0x001ffda5
LAB_001ffda5:
ADD RSP,0x10
POP RBP
RET
|
void wt_thd_destroy(long param_1)
{
if (*(long *)(param_1 + 0x30) != 0) {
lf_pinbox_put_pins(*(int8 *)(param_1 + 0x30));
}
delete_dynamic(param_1);
return;
}
|
|
11,304 |
key_cache_insert
|
eloqsql/mysys/mf_keycache.c
|
int key_cache_insert(KEY_CACHE *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length)
{
if (keycache->can_be_used)
return keycache->interface_funcs->insert(keycache->keycache_cb,
file, filepos, level,
buff, length);
return 0;
}
|
O0
|
c
|
key_cache_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x49(%rax)
je 0xe5f85
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
movl -0x34(%rbp), %r9d
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0xe5f8c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
key_cache_insert:
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_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
mov rax, [rbp+var_10]
cmp byte ptr [rax+49h], 0
jz short loc_E5F85
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rax, [rax+20h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+8]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_30]
mov r9d, [rbp+var_34]
call rax
mov [rbp+var_4], eax
jmp short loc_E5F8C
loc_E5F85:
mov [rbp+var_4], 0
loc_E5F8C:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long key_cache_insert(
long long a1,
unsigned int a2,
long long a3,
unsigned int a4,
long long a5,
unsigned int a6)
{
if ( *(_BYTE *)(a1 + 73) )
return (unsigned int)(*(long long ( **)(_QWORD, _QWORD, long long, _QWORD, long long, _QWORD))(*(_QWORD *)(a1 + 16) + 32LL))(
*(_QWORD *)(a1 + 8),
a2,
a3,
a4,
a5,
a6);
else
return 0;
}
|
key_cache_insert:
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 dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x49],0x0
JZ 0x001e5f85
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x8]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x30]
MOV R9D,dword ptr [RBP + -0x34]
CALL RAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e5f8c
LAB_001e5f85:
MOV dword ptr [RBP + -0x4],0x0
LAB_001e5f8c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4
key_cache_insert(long param_1,int4 param_2,int8 param_3,int4 param_4,
int8 param_5,int4 param_6)
{
int4 local_c;
if (*(char *)(param_1 + 0x49) == '\0') {
local_c = 0;
}
else {
local_c = (**(code **)(*(long *)(param_1 + 0x10) + 0x20))
(*(int8 *)(param_1 + 8),param_2,param_3,param_4,param_5,param_6);
}
return local_c;
}
|
|
11,305 |
stbi__pnm_test
|
opengl-water/include/stb_image.h
|
static int stbi__pnm_test(stbi__context *s)
{
char p, t;
p = (char) stbi__get8(s);
t = (char) stbi__get8(s);
if (p != 'P' || (t != '5' && t != '6')) {
stbi__rewind( s );
return 0;
}
return 1;
}
|
O3
|
c
|
stbi__pnm_test:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x45860
movl %eax, %r14d
movq %rbx, %rdi
callq 0x45860
cmpb $0x50, %r14b
jne 0x447f8
movl %eax, %ecx
addb $-0x37, %cl
movl $0x1, %eax
cmpb $-0x3, %cl
ja 0x44808
movups 0xd0(%rbx), %xmm0
movups %xmm0, 0xc0(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
stbi__pnm_test:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call stbi__get8
mov r14d, eax
mov rdi, rbx
call stbi__get8
cmp r14b, 50h ; 'P'
jnz short loc_447F8
mov ecx, eax
add cl, 0C9h
mov eax, 1
cmp cl, 0FDh
ja short loc_44808
loc_447F8:
movups xmm0, xmmword ptr [rbx+0D0h]
movups xmmword ptr [rbx+0C0h], xmm0
xor eax, eax
loc_44808:
pop rbx
pop r14
pop rbp
retn
|
long long stbi__pnm_test(long long a1)
{
char v1; // r14
char v2; // al
unsigned __int8 v3; // cl
long long result; // rax
v1 = stbi__get8(a1);
v2 = stbi__get8(a1);
if ( v1 != 80 || (v3 = v2 - 55, result = 1LL, v3 <= 0xFDu) )
{
*(_OWORD *)(a1 + 192) = *(_OWORD *)(a1 + 208);
return 0LL;
}
return result;
}
|
stbi__pnm_test:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x00145860
MOV R14D,EAX
MOV RDI,RBX
CALL 0x00145860
CMP R14B,0x50
JNZ 0x001447f8
MOV ECX,EAX
ADD CL,0xc9
MOV EAX,0x1
CMP CL,0xfd
JA 0x00144808
LAB_001447f8:
MOVUPS XMM0,xmmword ptr [RBX + 0xd0]
MOVUPS xmmword ptr [RBX + 0xc0],XMM0
XOR EAX,EAX
LAB_00144808:
POP RBX
POP R14
POP RBP
RET
|
int8 stbi__pnm_test(long param_1)
{
char cVar1;
char cVar2;
int8 uVar3;
cVar1 = stbi__get8();
cVar2 = stbi__get8(param_1);
if ((cVar1 != 'P') || (uVar3 = 1, (byte)(cVar2 - 0x37U) < 0xfe)) {
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_1 + 0xd0);
*(int8 *)(param_1 + 200) = *(int8 *)(param_1 + 0xd8);
uVar3 = 0;
}
return uVar3;
}
|
|
11,306 |
alloc_root
|
eloqsql/mysys/my_alloc.c
|
void *alloc_root(MEM_ROOT *mem_root, size_t length)
{
#if defined(HAVE_valgrind) && defined(EXTRA_DEBUG)
reg1 USED_MEM *next;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_SET("-d,simulate_out_of_memory");
DBUG_RETURN((void*) 0); /* purecov: inspected */
});
length+=ALIGN_SIZE(sizeof(USED_MEM));
if (!(next = (USED_MEM*) my_malloc(mem_root->m_psi_key, length,
MYF(MY_WME | ME_FATAL |
MALLOC_FLAG(mem_root->block_size)))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((uchar*) 0); /* purecov: inspected */
}
next->next= mem_root->used;
next->left= 0;
next->size= length;
mem_root->used= next;
DBUG_PRINT("exit",("ptr: %p", (((char*)next)+ALIGN_SIZE(sizeof(USED_MEM)))));
DBUG_RETURN((((uchar*) next)+ALIGN_SIZE(sizeof(USED_MEM))));
#else
size_t get_size, block_size;
uchar* point;
reg1 USED_MEM *next= 0;
reg2 USED_MEM **prev;
size_t original_length __attribute__((unused)) = length;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
/* Avoid reusing an already allocated block */
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_SET("-d,simulate_out_of_memory");
DBUG_RETURN((void*) 0); /* purecov: inspected */
});
length= ALIGN_SIZE(length) + REDZONE_SIZE;
if ((*(prev= &mem_root->free)) != NULL)
{
if ((*prev)->left < length &&
mem_root->first_block_usage++ >= ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP &&
(*prev)->left < ALLOC_MAX_BLOCK_TO_DROP)
{
next= *prev;
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
for (next= *prev ; next && next->left < length ; next= next->next)
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
block_size= (mem_root->block_size & ~1) * (mem_root->block_num >> 2);
get_size= length+ALIGN_SIZE(sizeof(USED_MEM));
get_size= MY_MAX(get_size, block_size);
if (!(next = (USED_MEM*) my_malloc(mem_root->m_psi_key, get_size,
MYF(MY_WME | ME_FATAL |
MALLOC_FLAG(mem_root->
block_size)))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((void*) 0); /* purecov: inspected */
}
mem_root->block_num++;
next->next= *prev;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next;
TRASH_MEM(next);
}
point= (uchar*) ((char*) next+ (next->size-next->left));
/*TODO: next part may be unneded due to mem_root->first_block_usage counter*/
if ((next->left-= length) < mem_root->min_malloc)
{ /* Full block */
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
point+= REDZONE_SIZE;
TRASH_ALLOC(point, original_length);
DBUG_PRINT("exit",("ptr: %p", point));
DBUG_RETURN((void*) point);
#endif
}
|
O0
|
c
|
alloc_root:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1319182
jmp 0x1319184
jmp 0x1319186
jmp 0x1319188
jmp 0x131918a
movq -0x18(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq $0x0, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
je 0x1319272
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x1319229
movq -0x10(%rbp), %rcx
movl 0x2c(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x2c(%rcx)
cmpl $0xa, %eax
jb 0x1319229
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpq $0x1000, 0x8(%rax) # imm = 0x1000
jae 0x1319229
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x49(%rbp)
je 0x1319252
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x131925b
jmp 0x1319270
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1319234
jmp 0x1319272
cmpq $0x0, -0x38(%rbp)
jne 0x1319375
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
andq $-0x2, %rax
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x13192bd
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x13192c5
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
andq $0x1, %rdx
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
cmpq $0x0, %rdx
cmovnel %ecx, %eax
orl $0x1010, %eax # imm = 0x1010
movl %eax, %eax
movl %eax, %edx
callq 0x13242b0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x131932b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x131931c
movq -0x10(%rbp), %rax
callq *0x30(%rax)
jmp 0x131931e
movq $0x0, -0x8(%rbp)
jmp 0x13193fd
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
subq $0x18, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
jmp 0x131936f
jmp 0x1319371
jmp 0x1319373
jmp 0x1319375
movq -0x38(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x38(%rbp), %rdx
subq 0x8(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rax
subq %rdx, %rax
movq %rax, 0x8(%rcx)
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x13193e1
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x13193eb
jmp 0x13193ed
jmp 0x13193ef
jmp 0x13193f1
jmp 0x13193f3
jmp 0x13193f5
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
alloc_root:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_38], 0
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
jmp short $+2
loc_1319182:
jmp short $+2
loc_1319184:
jmp short $+2
loc_1319186:
jmp short $+2
loc_1319188:
jmp short $+2
loc_131918A:
mov rax, [rbp+var_18]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, 0
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
cmp qword ptr [rax], 0
jz loc_1319272
mov rax, [rbp+var_40]
mov rax, [rax]
mov rax, [rax+8]
cmp rax, [rbp+var_18]
jnb short loc_1319229
mov rcx, [rbp+var_10]
mov eax, [rcx+2Ch]
mov edx, eax
add edx, 1
mov [rcx+2Ch], edx
cmp eax, 0Ah
jb short loc_1319229
mov rax, [rbp+var_40]
mov rax, [rax]
cmp qword ptr [rax+8], 1000h
jnb short loc_1319229
mov rax, [rbp+var_40]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rcx, [rax]
mov rax, [rbp+var_40]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+2Ch], 0
loc_1319229:
mov rax, [rbp+var_40]
mov rax, [rax]
mov [rbp+var_38], rax
loc_1319234:
xor eax, eax
cmp [rbp+var_38], 0
mov [rbp+var_49], al
jz short loc_1319252
mov rax, [rbp+var_38]
mov rax, [rax+8]
cmp rax, [rbp+var_18]
setb al
mov [rbp+var_49], al
loc_1319252:
mov al, [rbp+var_49]
test al, 1
jnz short loc_131925B
jmp short loc_1319270
loc_131925B:
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_38], rax
jmp short loc_1319234
loc_1319270:
jmp short $+2
loc_1319272:
cmp [rbp+var_38], 0
jnz loc_1319375
mov rax, [rbp+var_10]
mov rax, [rax+20h]
and rax, 0FFFFFFFFFFFFFFFEh
mov rcx, [rbp+var_10]
mov ecx, [rcx+28h]
shr ecx, 2
mov ecx, ecx
imul rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jbe short loc_13192BD
mov rax, [rbp+var_20]
mov [rbp+var_58], rax
jmp short loc_13192C5
loc_13192BD:
mov rax, [rbp+var_28]
mov [rbp+var_58], rax
loc_13192C5:
mov rax, [rbp+var_58]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov edi, [rax+38h]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rdx, [rax+20h]
and rdx, 1
xor eax, eax
mov ecx, 10000h
cmp rdx, 0
cmovnz eax, ecx
or eax, 1010h
mov eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_131932B
mov rax, [rbp+var_10]
cmp qword ptr [rax+30h], 0
jz short loc_131931C
mov rax, [rbp+var_10]
call qword ptr [rax+30h]
loc_131931C:
jmp short $+2
loc_131931E:
mov [rbp+var_8], 0
jmp loc_13193FD
loc_131932B:
mov rax, [rbp+var_10]
mov ecx, [rax+28h]
add ecx, 1
mov [rax+28h], ecx
mov rax, [rbp+var_40]
mov rcx, [rax]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_38]
mov [rax+10h], rcx
mov rcx, [rbp+var_20]
sub rcx, 18h
mov rax, [rbp+var_38]
mov [rax+8], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_40]
mov [rax], rcx
jmp short $+2
loc_131936F:
jmp short $+2
loc_1319371:
jmp short $+2
loc_1319373:
jmp short $+2
loc_1319375:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_38]
mov rcx, [rcx+10h]
mov rdx, [rbp+var_38]
sub rcx, [rdx+8]
add rax, rcx
mov [rbp+var_30], rax
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_38]
mov rax, [rcx+8]
sub rax, rdx
mov [rcx+8], rax
mov rcx, [rbp+var_10]
cmp rax, [rcx+18h]
jnb short loc_13193E1
mov rax, [rbp+var_38]
mov rcx, [rax]
mov rax, [rbp+var_40]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+2Ch], 0
loc_13193E1:
mov rax, [rbp+var_30]
mov [rbp+var_30], rax
jmp short $+2
loc_13193EB:
jmp short $+2
loc_13193ED:
jmp short $+2
loc_13193EF:
jmp short $+2
loc_13193F1:
jmp short $+2
loc_13193F3:
jmp short $+2
loc_13193F5:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_13193FD:
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
|
char * alloc_root(_QWORD **a1, long long a2)
{
unsigned int v2; // eax
long long v3; // rdi
int v4; // eax
unsigned long long v5; // rax
unsigned long long v7; // [rsp+8h] [rbp-58h]
bool v8; // [rsp+17h] [rbp-49h]
_QWORD *v9; // [rsp+20h] [rbp-40h]
_QWORD *i; // [rsp+28h] [rbp-38h]
_QWORD *v11; // [rsp+28h] [rbp-38h]
char *v12; // [rsp+30h] [rbp-30h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
i = 0LL;
v13 = (a2 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v9 = a1;
if ( *a1 )
{
if ( (*a1)[1] < v13 )
{
v2 = *((_DWORD *)a1 + 11);
*((_DWORD *)a1 + 11) = v2 + 1;
if ( v2 >= 0xA && (*a1)[1] < 0x1000uLL )
{
v11 = *a1;
*a1 = (_QWORD *)**a1;
*v11 = a1[1];
a1[1] = v11;
*((_DWORD *)a1 + 11) = 0;
}
}
for ( i = *a1; ; i = (_QWORD *)*i )
{
v8 = 0;
if ( i )
v8 = i[1] < v13;
if ( !v8 )
break;
v9 = i;
}
}
if ( !i )
{
if ( v13 + 24 <= (*((_DWORD *)a1 + 10) >> 2) * ((unsigned long long)a1[4] & 0xFFFFFFFFFFFFFFFELL) )
v7 = (*((_DWORD *)a1 + 10) >> 2) * ((unsigned long long)a1[4] & 0xFFFFFFFFFFFFFFFELL);
else
v7 = v13 + 24;
v3 = *((unsigned int *)a1 + 14);
v4 = 0;
if ( ((unsigned long long)a1[4] & 1) != 0 )
v4 = 0x10000;
i = (_QWORD *)my_malloc(v3, v7, v4 | 0x1010u);
if ( !i )
{
if ( a1[6] )
((void (*)(void))a1[6])();
return 0LL;
}
++*((_DWORD *)a1 + 10);
*i = *v9;
i[2] = v7;
i[1] = v7 - 24;
*v9 = i;
}
v12 = (char *)i + i[2] - i[1];
v5 = i[1] - v13;
i[1] = v5;
if ( v5 < (unsigned long long)a1[3] )
{
*v9 = *i;
*i = a1[1];
a1[1] = i;
*((_DWORD *)a1 + 11) = 0;
}
return v12;
}
|
trx_set_detailed_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0xa78]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0xff
CALL 0x00875310
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xa78]
MOV byte ptr [RAX + 0xff],0x0
ADD RSP,0x10
POP RBP
RET
|
/* trx_set_detailed_error(trx_t*, char const*) */
void trx_set_detailed_error(trx_t *param_1,char *param_2)
{
strncpy(*(char **)(param_1 + 0xa78),param_2,0xff);
*(int1 *)(*(long *)(param_1 + 0xa78) + 0xff) = 0;
return;
}
|
|
11,307 |
ma_keylength
|
eloqsql/storage/maria/ma_search.c
|
uint _ma_keylength(MARIA_KEYDEF *keyinfo, const uchar *key)
{
reg1 HA_KEYSEG *keyseg;
const uchar *start;
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
return (keyinfo->keylength);
start= key;
for (keyseg=keyinfo->seg ; keyseg->type ; keyseg++)
{
if (keyseg->flag & HA_NULL_PART)
if (!*key++)
continue;
if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
{
uint length;
get_key_length(length,key);
key+=length;
}
else
key+= keyseg->length;
}
return((uint) (key-start)+keyseg->length);
}
|
O0
|
c
|
ma_keylength:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0xa2(%rax), %eax
andl $0x28, %eax
cmpl $0x0, %eax
jne 0x6cb12
movq -0x10(%rbp), %rax
movzwl 0xaa(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x6cc17
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, 0x18(%rax)
je 0x6cbff
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x6cb62
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpb $0x0, (%rax)
jne 0x6cb60
jmp 0x6cbee
jmp 0x6cb62
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x29, %eax
cmpl $0x0, %eax
je 0x6cbd6
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0x6cb97
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x6cbc4
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6cbec
movq -0x20(%rbp), %rax
movzwl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6cbee
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x6cb29
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x20(%rbp), %rcx
movzwl 0x14(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
_ma_keylength:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
movzx eax, word ptr [rax+0A2h]
and eax, 28h
cmp eax, 0
jnz short loc_6CB12
mov rax, [rbp+var_10]
movzx eax, word ptr [rax+0AAh]
mov [rbp+var_4], eax
jmp loc_6CC17
loc_6CB12:
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax+0C0h]
mov [rbp+var_20], rax
loc_6CB29:
mov rax, [rbp+var_20]
cmp byte ptr [rax+18h], 0
jz loc_6CBFF
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+12h]
and eax, 10h
cmp eax, 0
jz short loc_6CB62
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
cmp byte ptr [rax], 0
jnz short loc_6CB60
jmp loc_6CBEE
loc_6CB60:
jmp short $+2
loc_6CB62:
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+12h]
and eax, 29h
cmp eax, 0
jz short loc_6CBD6
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_6CB97
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
jmp short loc_6CBC4
loc_6CB97:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
movzx eax, ax
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_2C], eax
mov rax, [rbp+var_18]
add rax, 3
mov [rbp+var_18], rax
loc_6CBC4:
mov ecx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short loc_6CBEC
loc_6CBD6:
mov rax, [rbp+var_20]
movzx ecx, word ptr [rax+14h]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
loc_6CBEC:
jmp short $+2
loc_6CBEE:
mov rax, [rbp+var_20]
add rax, 20h ; ' '
mov [rbp+var_20], rax
jmp loc_6CB29
loc_6CBFF:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_20]
movzx ecx, word ptr [rcx+14h]
add eax, ecx
mov [rbp+var_4], eax
loc_6CC17:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long ma_keylength(long long a1, unsigned __int8 *a2)
{
unsigned __int8 *v2; // rax
unsigned __int8 *v3; // rax
int v5; // [rsp+0h] [rbp-2Ch]
long long i; // [rsp+Ch] [rbp-20h]
unsigned __int8 *v7; // [rsp+14h] [rbp-18h]
unsigned __int8 *v8; // [rsp+14h] [rbp-18h]
v7 = a2;
if ( (*(_WORD *)(a1 + 162) & 0x28) != 0 )
{
for ( i = *(_QWORD *)(a1 + 192); *(_BYTE *)(i + 24); i += 32LL )
{
if ( (*(_WORD *)(i + 18) & 0x10) != 0 )
{
v2 = v7++;
if ( !*v2 )
continue;
}
if ( (*(_WORD *)(i + 18) & 0x29) != 0 )
{
if ( *v7 == 255 )
{
v5 = _byteswap_ushort(*(_WORD *)(v7 + 1));
v8 = v7 + 3;
}
else
{
v3 = v7;
v8 = v7 + 1;
v5 = *v3;
}
v7 = &v8[v5];
}
else
{
v7 += *(unsigned __int16 *)(i + 20);
}
}
return (unsigned int)(*(unsigned __int16 *)(i + 20) + (_DWORD)v7 - (_DWORD)a2);
}
else
{
return *(unsigned __int16 *)(a1 + 170);
}
}
|
_ma_keylength:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0xa2]
AND EAX,0x28
CMP EAX,0x0
JNZ 0x0016cb12
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0xaa]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016cc17
LAB_0016cb12:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xc0]
MOV qword ptr [RBP + -0x20],RAX
LAB_0016cb29:
MOV RAX,qword ptr [RBP + -0x20]
CMP byte ptr [RAX + 0x18],0x0
JZ 0x0016cbff
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x10
CMP EAX,0x0
JZ 0x0016cb62
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
CMP byte ptr [RAX],0x0
JNZ 0x0016cb60
JMP 0x0016cbee
LAB_0016cb60:
JMP 0x0016cb62
LAB_0016cb62:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x29
CMP EAX,0x0
JZ 0x0016cbd6
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x0016cb97
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0016cbc4
LAB_0016cb97:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
MOV qword ptr [RBP + -0x18],RAX
LAB_0016cbc4:
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016cbec
LAB_0016cbd6:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,word ptr [RAX + 0x14]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
LAB_0016cbec:
JMP 0x0016cbee
LAB_0016cbee:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x20
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0016cb29
LAB_0016cbff:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,word ptr [RCX + 0x14]
ADD EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_0016cc17:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
uint _ma_keylength(long param_1,byte *param_2)
{
byte bVar1;
byte *pbVar2;
uint local_34;
long local_28;
byte *local_20;
uint local_c;
if ((*(ushort *)(param_1 + 0xa2) & 0x28) == 0) {
local_c = (uint)*(ushort *)(param_1 + 0xaa);
}
else {
local_20 = param_2;
for (local_28 = *(long *)(param_1 + 0xc0); *(char *)(local_28 + 0x18) != '\0';
local_28 = local_28 + 0x20) {
if (((*(ushort *)(local_28 + 0x12) & 0x10) == 0) ||
(pbVar2 = local_20 + 1, bVar1 = *local_20, local_20 = pbVar2, bVar1 != 0)) {
if ((*(ushort *)(local_28 + 0x12) & 0x29) == 0) {
local_20 = local_20 + (int)(uint)*(ushort *)(local_28 + 0x14);
}
else {
if (*local_20 == 0xff) {
local_34 = (uint)CONCAT11(local_20[1],local_20[2]);
local_20 = local_20 + 3;
}
else {
local_34 = (uint)*local_20;
local_20 = local_20 + 1;
}
local_20 = local_20 + local_34;
}
}
}
local_c = ((int)local_20 - (int)param_2) + (uint)*(ushort *)(local_28 + 0x14);
}
return local_c;
}
|
|
11,308 |
minja::Parser::parseValueExpression()::'lambda'()::operator()() const
|
monkey531[P]llama/common/minja.hpp
|
std::shared_ptr<Expression> parseValueExpression() {
auto parseValue = [&]() -> std::shared_ptr<Expression> {
auto location = get_location();
auto constant = parseConstant();
if (constant) return std::make_shared<LiteralExpr>(location, *constant);
static std::regex null_regex(R"(null\b)");
if (!consumeToken(null_regex).empty()) return std::make_shared<LiteralExpr>(location, Value());
auto identifier = parseIdentifier();
if (identifier) return identifier;
auto braced = parseBracedExpressionOrArray();
if (braced) return braced;
auto array = parseArray();
if (array) return array;
auto dictionary = parseDictionary();
if (dictionary) return dictionary;
throw std::runtime_error("Expected value expression");
};
auto value = parseValue();
while (it != end && consumeSpaces() && peekSymbols({ "[", "." })) {
if (!consumeToken("[").empty()) {
std::shared_ptr<Expression> index;
if (!consumeToken(":").empty()) {
auto slice_end = parseExpression();
index = std::make_shared<SliceExpr>(slice_end->location, nullptr, std::move(slice_end));
} else {
auto slice_start = parseExpression();
if (!consumeToken(":").empty()) {
consumeSpaces();
if (peekSymbols({ "]" })) {
index = std::make_shared<SliceExpr>(slice_start->location, std::move(slice_start), nullptr);
} else {
auto slice_end = parseExpression();
index = std::make_shared<SliceExpr>(slice_start->location, std::move(slice_start), std::move(slice_end));
}
} else {
index = std::move(slice_start);
}
}
if (!index) throw std::runtime_error("Empty index in subscript");
if (consumeToken("]").empty()) throw std::runtime_error("Expected closing bracket in subscript");
value = std::make_shared<SubscriptExpr>(value->location, std::move(value), std::move(index));
} else if (!consumeToken(".").empty()) {
auto identifier = parseIdentifier();
if (!identifier) throw std::runtime_error("Expected identifier in subscript");
consumeSpaces();
if (peekSymbols({ "(" })) {
auto callParams = parseCallArgs();
value = std::make_shared<MethodCallExpr>(identifier->location, std::move(value), std::move(identifier), std::move(callParams));
} else {
auto key = std::make_shared<LiteralExpr>(identifier->location, Value(identifier->get_name()));
value = std::make_shared<SubscriptExpr>(identifier->location, std::move(value), std::move(key));
}
}
consumeSpaces();
}
if (peekSymbols({ "(" })) {
auto location = get_location();
auto callParams = parseCallArgs();
value = std::make_shared<CallExpr>(location, std::move(value), std::move(callParams));
}
return value;
}
|
O2
|
cpp
|
minja::Parser::parseValueExpression()::'lambda'()::operator()() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x5fcc0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x658c4
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
je 0x64ffb
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x65b5c
leaq 0x58(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x4f1f0
jmp 0x65077
leaq 0x98176(%rip), %rax # 0xfd178
movb (%rax), %al
testb %al, %al
je 0x6515c
leaq 0x98145(%rip), %rdx # 0xfd158
leaq 0x50(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x600e4
leaq 0x50(%rsp), %rdi
movq 0x8(%rdi), %r15
callq 0x241d8
testq %r15, %r15
je 0x6509b
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x65b7e
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
movq %r14, %rdx
callq 0x657fe
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x4f1f0
leaq 0x50(%rsp), %rdi
callq 0x62842
leaq 0x30(%rsp), %rdi
callq 0x4f1f0
leaq 0x40(%rsp), %rdi
callq 0x4f1f0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x60858
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x650cf
movq %rax, (%rbx)
movq 0x58(%rsp), %rax
andq $0x0, 0x58(%rsp)
movq %rax, 0x8(%rbx)
andq $0x0, 0x50(%rsp)
jmp 0x65152
movq %rsp, %rdi
movq %r14, %rsi
callq 0x65b9e
movq (%rsp), %rax
testq %rax, %rax
je 0x650fc
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
andq $0x0, 0x8(%rsp)
movq %rax, 0x8(%rbx)
andq $0x0, (%rsp)
jmp 0x65148
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x65f6e
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x6512d
movq %rax, (%rbx)
movq 0x20(%rsp), %rax
andq $0x0, 0x20(%rsp)
movq %rax, 0x8(%rbx)
andq $0x0, 0x18(%rsp)
jmp 0x6513e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6633c
cmpq $0x0, (%rbx)
je 0x651b1
leaq 0x20(%rsp), %rdi
callq 0x4f1f0
leaq 0x8(%rsp), %rdi
callq 0x4f1f0
leaq 0x58(%rsp), %rdi
jmp 0x64ff4
leaq 0x98015(%rip), %rdi # 0xfd178
callq 0x24010
testl %eax, %eax
je 0x6500c
leaq 0x97fe1(%rip), %rdi # 0xfd158
leaq 0x4de38(%rip), %rsi # 0xb2fb6
pushq $0x10
popq %rdx
callq 0x45d42
leaq -0x1f225(%rip), %rdi # 0x45f68
leaq 0x97fc4(%rip), %rsi # 0xfd158
leaq 0x9775d(%rip), %rdx # 0xfc8f8
callq 0x237e0
leaq 0x97fd1(%rip), %rdi # 0xfd178
callq 0x235f0
jmp 0x6500c
pushq $0x10
popq %rdi
callq 0x23460
movq %rax, %r15
leaq 0x4ddfa(%rip), %rsi # 0xb2fbd
movq %rax, %rdi
callq 0x23320
movq 0x96e1e(%rip), %rsi # 0xfbff0
movq 0x96d7f(%rip), %rdx # 0xfbf58
movq %r15, %rdi
callq 0x23f20
movq %rax, %r14
leaq 0x97f8d(%rip), %rdi # 0xfd178
callq 0x235e0
jmp 0x65253
movq %rax, %r14
jmp 0x65202
movq %rax, %r14
movq %r15, %rdi
callq 0x236b0
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4f1f0
jmp 0x65213
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x4f1f0
jmp 0x65222
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4f1f0
jmp 0x65231
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x4f1f0
jmp 0x65253
jmp 0x65250
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x62842
jmp 0x65253
jmp 0x65250
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x4f1f0
jmp 0x65262
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x4f1f0
movq %r14, %rdi
callq 0x23fa0
|
_ZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEv:
push r15
push r14
push rbx
sub rsp, 0A0h
mov rbx, rdi
mov r14, [rsi]
lea rdi, [rsp+0B8h+var_80]; this
mov rsi, r14
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
lea rdi, [rsp+0B8h+var_90]; this
mov rsi, r14
call _ZN5minja6Parser13parseConstantEv; minja::Parser::parseConstant(void)
mov rdx, [rsp+0B8h+var_90]
test rdx, rdx
jz short loc_64FFB
lea rdi, [rsp+0B8h+var_68]
lea rsi, [rsp+0B8h+var_80]
call _ZSt11make_sharedIN5minja11LiteralExprEJRNS0_8LocationERNS0_5ValueEEESt10shared_ptrIT_EDpOT0_; std::make_shared<minja::LiteralExpr,minja::Location &,minja::Value &>(minja::Location &,minja::Value &)
lea rdi, [rsp+0B8h+var_60]
movaps xmm0, xmmword ptr [rdi-8]
and qword ptr [rdi], 0
movups xmmword ptr [rbx], xmm0
and qword ptr [rdi-8], 0
loc_64FF4:
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_65077
loc_64FFB:
lea rax, _ZGVZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; `guard variable for'minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex
mov al, [rax]
test al, al
jz loc_6515C
loc_6500C:
lea rdx, _ZZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex
lea rdi, [rsp+0B8h+var_68]
push 1
pop rcx
mov rsi, r14
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rdi, [rsp+0B8h+var_68]; void *
mov r15, [rdi+8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r15, r15
jz short loc_6509B
lea r14, [rsp+0B8h+var_68]
mov rdi, r14; this
call _ZN5minja5ValueC2Ev; minja::Value::Value(void)
mov rdi, rsp
lea rsi, [rsp+0B8h+var_80]
mov rdx, r14
call _ZSt11make_sharedIN5minja11LiteralExprEJRNS0_8LocationENS0_5ValueEEESt10shared_ptrIT_EDpOT0_; std::make_shared<minja::LiteralExpr,minja::Location &,minja::Value>(minja::Location &,minja::Value &&)
lea rdi, [rsp+0B8h+var_B0]
movaps xmm0, xmmword ptr [rdi-8]
and qword ptr [rdi], 0
movups xmmword ptr [rbx], xmm0
and qword ptr [rdi-8], 0
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+0B8h+var_68]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_65077:
lea rdi, [rsp+0B8h+var_88]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+0B8h+var_78]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 0A0h
pop rbx
pop r14
pop r15
retn
loc_6509B:
lea rdi, [rsp+0B8h+var_68]; this
mov rsi, r14
call _ZN5minja6Parser15parseIdentifierEv; minja::Parser::parseIdentifier(void)
mov rax, [rsp+0B8h+var_68]
test rax, rax
jz short loc_650CF
mov [rbx], rax
mov rax, [rsp+0B8h+var_60]
and [rsp+0B8h+var_60], 0
mov [rbx+8], rax
and [rsp+0B8h+var_68], 0
jmp loc_65152
loc_650CF:
mov rdi, rsp; this
mov rsi, r14
call _ZN5minja6Parser28parseBracedExpressionOrArrayEv; minja::Parser::parseBracedExpressionOrArray(void)
mov rax, [rsp+0B8h+var_B8]
test rax, rax
jz short loc_650FC
mov [rbx], rax
mov rax, [rsp+0B8h+var_B0]
and [rsp+0B8h+var_B0], 0
mov [rbx+8], rax
and [rsp+0B8h+var_B8], 0
jmp short loc_65148
loc_650FC:
lea rdi, [rsp+0B8h+var_A0]; this
mov rsi, r14
call _ZN5minja6Parser10parseArrayEv; minja::Parser::parseArray(void)
mov rax, [rsp+0B8h+var_A0]
test rax, rax
jz short loc_6512D
mov [rbx], rax
mov rax, [rsp+0B8h+var_98]
and [rsp+0B8h+var_98], 0
mov [rbx+8], rax
and [rsp+0B8h+var_A0], 0
jmp short loc_6513E
loc_6512D:
mov rdi, rbx; this
mov rsi, r14
call _ZN5minja6Parser15parseDictionaryEv; minja::Parser::parseDictionary(void)
cmp qword ptr [rbx], 0
jz short loc_651B1
loc_6513E:
lea rdi, [rsp+0B8h+var_98]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_65148:
lea rdi, [rsp+0B8h+var_B0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_65152:
lea rdi, [rsp+0B8h+var_60]
jmp loc_64FF4
loc_6515C:
lea rdi, _ZGVZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_6500C
lea rdi, _ZZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex
lea rsi, aNullB; "null\\b"
push 10h
pop rdx
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_6500C
loc_651B1:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedValueE; "Expected value expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
mov r14, rax
lea rdi, _ZGVZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_65253
mov r14, rax
jmp short loc_65202
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
loc_65202:
add rbx, 8
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_65213
mov r14, rax
loc_65213:
lea rdi, [rsp+0B8h+var_98]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_65222
mov r14, rax
loc_65222:
lea rdi, [rsp+0B8h+var_B0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_65231
mov r14, rax
loc_65231:
lea rdi, [rsp+0B8h+var_60]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_65253
jmp short loc_65250
mov r14, rax
lea rdi, [rsp+0B8h+var_68]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_65253
jmp short $+2
loc_65250:
mov r14, rax
loc_65253:
lea rdi, [rsp+0B8h+var_88]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_65262
mov r14, rax
loc_65262:
lea rdi, [rsp+0B8h+var_78]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator()(
minja::Parser *this,
_QWORD **a2)
{
_QWORD *v2; // r14
__int128 v3; // xmm0
long long v4; // r15
__int128 v5; // xmm0
long long v7; // rax
long long v8; // rax
long long v9; // rax
std::runtime_error *exception; // r15
__int128 v11; // [rsp+0h] [rbp-B8h] BYREF
long long v12; // [rsp+18h] [rbp-A0h] BYREF
long long v13; // [rsp+20h] [rbp-98h] BYREF
long long v14; // [rsp+28h] [rbp-90h] BYREF
long long v15; // [rsp+30h] [rbp-88h] BYREF
_BYTE v16[8]; // [rsp+38h] [rbp-80h] BYREF
long long v17; // [rsp+40h] [rbp-78h] BYREF
_OWORD v18[6]; // [rsp+50h] [rbp-68h] BYREF
v2 = *a2;
minja::Parser::get_location((minja::Parser *)v16, *a2);
minja::Parser::parseConstant((minja::Parser *)&v14);
if ( v14 )
{
std::make_shared<minja::LiteralExpr,minja::Location &,minja::Value &>(v18, v16);
v3 = v18[0];
*((_QWORD *)&v18[0] + 1) = 0LL;
*(_OWORD *)this = v3;
*(_QWORD *)&v18[0] = 0LL;
}
else
{
if ( !(_BYTE)`guard variable for'minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11],
(long long)"null\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11]);
}
minja::Parser::consumeToken(
v18,
(long long)v2,
(long long)&minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11],
1u);
v4 = *((_QWORD *)&v18[0] + 1);
std::string::~string(v18);
if ( v4 )
{
minja::Value::Value((minja::Value *)v18);
std::make_shared<minja::LiteralExpr,minja::Location &,minja::Value>(&v11, v16, v18);
v5 = v11;
*((_QWORD *)&v11 + 1) = 0LL;
*(_OWORD *)this = v5;
*(_QWORD *)&v11 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v11 + 1);
minja::Value::~Value((minja::Value *)v18);
goto LABEL_7;
}
minja::Parser::parseIdentifier((minja::Parser *)v18, v2);
if ( *(_QWORD *)&v18[0] )
{
*(_QWORD *)this = *(_QWORD *)&v18[0];
v7 = *((_QWORD *)&v18[0] + 1);
*((_QWORD *)&v18[0] + 1) = 0LL;
*((_QWORD *)this + 1) = v7;
*(_QWORD *)&v18[0] = 0LL;
}
else
{
minja::Parser::parseBracedExpressionOrArray((minja::Parser *)&v11);
if ( (_QWORD)v11 )
{
*(_QWORD *)this = v11;
v8 = *((_QWORD *)&v11 + 1);
*((_QWORD *)&v11 + 1) = 0LL;
*((_QWORD *)this + 1) = v8;
*(_QWORD *)&v11 = 0LL;
}
else
{
minja::Parser::parseArray((minja::Parser *)&v12);
if ( v12 )
{
*(_QWORD *)this = v12;
v9 = v13;
v13 = 0LL;
*((_QWORD *)this + 1) = v9;
v12 = 0LL;
}
else
{
minja::Parser::parseDictionary(this);
if ( !*(_QWORD *)this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected value expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v13);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v11 + 1);
}
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)v18 + 1);
LABEL_7:
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v15);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v17);
return this;
}
|
operator():
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa0
MOV RBX,RDI
MOV R14,qword ptr [RSI]
LEA RDI,[RSP + 0x38]
MOV RSI,R14
CALL 0x0015fcc0
LAB_00164fb9:
LEA RDI,[RSP + 0x28]
MOV RSI,R14
CALL 0x001658c4
MOV RDX,qword ptr [RSP + 0x28]
TEST RDX,RDX
JZ 0x00164ffb
LAB_00164fd0:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x38]
CALL 0x00165b5c
LEA RDI,[RSP + 0x58]
MOVAPS XMM0,xmmword ptr [RDI + -0x8]
AND qword ptr [RDI],0x0
MOVUPS xmmword ptr [RBX],XMM0
AND qword ptr [RDI + -0x8],0x0
LAB_00164ff4:
CALL 0x0014f1f0
JMP 0x00165077
LAB_00164ffb:
LEA RAX,[0x1fd178]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x0016515c
LAB_0016500c:
LEA RDX,[0x1fd158]
LEA RDI,[RSP + 0x50]
PUSH 0x1
POP RCX
MOV RSI,R14
CALL 0x001600e4
LEA RDI,[RSP + 0x50]
MOV R15,qword ptr [RDI + 0x8]
CALL 0x001241d8
TEST R15,R15
JZ 0x0016509b
LEA R14,[RSP + 0x50]
MOV RDI,R14
CALL 0x00165b7e
LAB_00165043:
MOV RDI,RSP
LEA RSI,[RSP + 0x38]
MOV RDX,R14
CALL 0x001657fe
LEA RDI,[RSP + 0x8]
MOVAPS XMM0,xmmword ptr [RDI + -0x8]
AND qword ptr [RDI],0x0
MOVUPS xmmword ptr [RBX],XMM0
AND qword ptr [RDI + -0x8],0x0
CALL 0x0014f1f0
LEA RDI,[RSP + 0x50]
CALL 0x00162842
LAB_00165077:
LEA RDI,[RSP + 0x30]
CALL 0x0014f1f0
LEA RDI,[RSP + 0x40]
CALL 0x0014f1f0
MOV RAX,RBX
ADD RSP,0xa0
POP RBX
POP R14
POP R15
RET
LAB_0016509b:
LEA RDI,[RSP + 0x50]
MOV RSI,R14
CALL 0x00160858
MOV RAX,qword ptr [RSP + 0x50]
TEST RAX,RAX
JZ 0x001650cf
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x58]
AND qword ptr [RSP + 0x58],0x0
MOV qword ptr [RBX + 0x8],RAX
AND qword ptr [RSP + 0x50],0x0
JMP 0x00165152
LAB_001650cf:
MOV RDI,RSP
MOV RSI,R14
CALL 0x00165b9e
MOV RAX,qword ptr [RSP]
TEST RAX,RAX
JZ 0x001650fc
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x8]
AND qword ptr [RSP + 0x8],0x0
MOV qword ptr [RBX + 0x8],RAX
AND qword ptr [RSP],0x0
JMP 0x00165148
LAB_001650fc:
LEA RDI,[RSP + 0x18]
MOV RSI,R14
CALL 0x00165f6e
MOV RAX,qword ptr [RSP + 0x18]
TEST RAX,RAX
JZ 0x0016512d
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x20]
AND qword ptr [RSP + 0x20],0x0
MOV qword ptr [RBX + 0x8],RAX
AND qword ptr [RSP + 0x18],0x0
JMP 0x0016513e
LAB_0016512d:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016633c
CMP qword ptr [RBX],0x0
JZ 0x001651b1
LAB_0016513e:
LEA RDI,[RSP + 0x20]
CALL 0x0014f1f0
LAB_00165148:
LEA RDI,[RSP + 0x8]
CALL 0x0014f1f0
LAB_00165152:
LEA RDI,[RSP + 0x58]
JMP 0x00164ff4
LAB_0016515c:
LEA RDI,[0x1fd178]
CALL 0x00124010
TEST EAX,EAX
JZ 0x0016500c
LAB_00165170:
LEA RDI,[0x1fd158]
LEA RSI,[0x1b2fb6]
PUSH 0x10
POP RDX
CALL 0x00145d42
LAB_00165186:
LEA RDI,[0x145f68]
LEA RSI,[0x1fd158]
LEA RDX,[0x1fc8f8]
CALL 0x001237e0
LEA RDI,[0x1fd178]
CALL 0x001235f0
JMP 0x0016500c
LAB_001651b1:
PUSH 0x10
POP RDI
CALL 0x00123460
MOV R15,RAX
LAB_001651bc:
LEA RSI,[0x1b2fbd]
MOV RDI,RAX
CALL 0x00123320
LAB_001651cb:
MOV RSI,qword ptr [0x001fbff0]
MOV RDX,qword ptr [0x001fbf58]
MOV RDI,R15
CALL 0x00123f20
|
/* minja::Parser::parseValueExpression()::{lambda()#1}::TEMPNAMEPLACEHOLDERVALUE() const */
_lambda___1_ * __thiscall
minja::Parser::parseValueExpression()::{lambda()#1}::operator()(_lambda___1_ *this)
{
int8 uVar1;
long lVar2;
int iVar3;
runtime_error *this_00;
int8 *in_RSI;
long local_b8;
int8 auStack_b0 [2];
long local_a0;
int8 local_98;
long local_90;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_88 [8];
Value local_80 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_78 [16];
long local_68;
long alStack_60 [9];
uVar1 = *in_RSI;
get_location();
/* try { // try from 00164fb9 to 00164fc5 has its CatchHandler @ 0016525f */
parseConstant();
if (local_90 == 0) {
if ((operator()()::null_regex_abi_cxx11_ == '\0') &&
(iVar3 = __cxa_guard_acquire(&operator()()::null_regex_abi_cxx11_), iVar3 != 0)) {
/* try { // try from 00165170 to 00165185 has its CatchHandler @ 001651e1 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
operator()()::null_regex_abi_cxx11_,"null\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
operator()()::null_regex_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&operator()()::null_regex_abi_cxx11_);
}
/* try { // try from 0016500c to 00165022 has its CatchHandler @ 0016524e */
consumeToken(&local_68,uVar1,operator()()::null_regex_abi_cxx11_,1);
lVar2 = alStack_60[0];
std::__cxx11::string::~string((string *)&local_68);
if (lVar2 != 0) {
Value::Value((Value *)&local_68);
/* try { // try from 00165043 to 00165052 has its CatchHandler @ 0016523f */
std::make_shared<minja::LiteralExpr,minja::Location&,minja::Value>
((Location *)&local_b8,local_80);
uVar1 = auStack_b0[0];
auStack_b0[0] = 0;
*(long *)this = local_b8;
*(int8 *)(this + 8) = uVar1;
local_b8 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)auStack_b0);
Value::~Value((Value *)&local_68);
goto LAB_00165077;
}
/* try { // try from 0016509b to 001650a7 has its CatchHandler @ 0016523d */
parseIdentifier();
lVar2 = alStack_60[0];
if (local_68 == 0) {
/* try { // try from 001650cf to 001650d9 has its CatchHandler @ 0016522e */
parseBracedExpressionOrArray();
uVar1 = auStack_b0[0];
if (local_b8 == 0) {
/* try { // try from 001650fc to 00165108 has its CatchHandler @ 0016521f */
parseArray();
uVar1 = local_98;
if (local_a0 == 0) {
/* try { // try from 0016512d to 00165137 has its CatchHandler @ 00165210 */
parseDictionary();
if (*(long *)this == 0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001651bc to 001651ca has its CatchHandler @ 001651f7 */
std::runtime_error::runtime_error(this_00,"Expected value expression");
/* try { // try from 001651cb to 001651e0 has its CatchHandler @ 001651f2 */
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fbff0,PTR__runtime_error_001fbf58);
}
}
else {
*(long *)this = local_a0;
local_98 = 0;
*(int8 *)(this + 8) = uVar1;
local_a0 = 0;
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_98);
}
else {
*(long *)this = local_b8;
auStack_b0[0] = 0;
*(int8 *)(this + 8) = uVar1;
local_b8 = 0;
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)auStack_b0);
}
else {
*(long *)this = local_68;
alStack_60[0] = 0;
*(long *)(this + 8) = lVar2;
local_68 = 0;
}
}
else {
/* try { // try from 00164fd0 to 00164fde has its CatchHandler @ 00165250 */
std::make_shared<minja::LiteralExpr,minja::Location&,minja::Value&>
((Location *)&local_68,local_80);
lVar2 = alStack_60[0];
alStack_60[0] = 0;
*(long *)this = local_68;
*(long *)(this + 8) = lVar2;
local_68 = 0;
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)alStack_60);
LAB_00165077:
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_88);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_78);
return this;
}
|
|
11,309 |
minja::Parser::parseIfExpression()
|
monkey531[P]llama/common/minja.hpp
|
std::pair<std::shared_ptr<Expression>, std::shared_ptr<Expression>> parseIfExpression() {
auto condition = parseLogicalOr();
if (!condition) throw std::runtime_error("Expected condition expression");
static std::regex else_tok(R"(else\b)");
std::shared_ptr<Expression> else_expr;
if (!consumeToken(else_tok).empty()) {
else_expr = parseExpression();
if (!else_expr) throw std::runtime_error("Expected 'else' expression");
}
return std::pair(std::move(condition), std::move(else_expr));
}
|
O2
|
cpp
|
minja::Parser::parseIfExpression():
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x7dcac
cmpq $0x0, (%r15)
je 0x7dfc7
leaq 0xa4795(%rip), %rax # 0x122670
movb (%rax), %al
testb %al, %al
je 0x7dff7
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0xa475d(%rip), %rdx # 0x122650
leaq 0x20(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x7ca3c
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %r15
callq 0x27998
testq %r15, %r15
je 0x7df7a
leaq 0x20(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x7c856
movq %rsp, %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x8d870
leaq 0x28(%rsp), %rdi
callq 0x4dd26
movq (%r14), %rax
testq %rax, %rax
jne 0x7df7e
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %r14
leaq 0x53eb1(%rip), %rsi # 0xd1e0b
movq %rax, %rdi
callq 0x26420
movq 0xa3087(%rip), %rsi # 0x120ff0
movq 0xa2fe8(%rip), %rdx # 0x120f58
movq %r14, %rdi
callq 0x275b0
jmp 0x7dff7
movq (%rsp), %rax
leaq 0x18(%rsp), %r14
movaps -0x8(%r14), %xmm0
andq $0x0, (%r14)
andq $0x0, -0x8(%r14)
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
andq $0x0, (%rdi)
movq %rax, 0x18(%rbx)
andq $0x0, -0x8(%rdi)
callq 0x4dd26
movq %r14, %rdi
callq 0x4dd26
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %r14
leaq 0x53e0d(%rip), %rsi # 0xd1de6
movq %rax, %rdi
callq 0x26420
movq 0xa3008(%rip), %rsi # 0x120ff0
movq 0xa2f69(%rip), %rdx # 0x120f58
movq %r14, %rdi
callq 0x275b0
leaq 0xa4672(%rip), %rdi # 0x122670
callq 0x27700
testl %eax, %eax
je 0x7dee5
leaq 0xa463e(%rip), %rdi # 0x122650
leaq 0x53deb(%rip), %rsi # 0xd1e04
pushq $0x10
popq %rdx
callq 0x6d972
leaq -0x3b74a(%rip), %rdi # 0x428de
leaq 0xa4621(%rip), %rsi # 0x122650
leaq 0xa3ca2(%rip), %rdx # 0x121cd8
callq 0x26aa0
leaq 0xa462e(%rip), %rdi # 0x122670
callq 0x26800
jmp 0x7dee5
movq %rax, %rbx
leaq 0xa461a(%rip), %rdi # 0x122670
callq 0x267e0
jmp 0x7e08d
jmp 0x7e080
movq %rax, %rbx
movq %r14, %rdi
callq 0x268f0
jmp 0x7e083
movq %rax, %rbx
jmp 0x7e08d
movq %rax, %rbx
movq %r14, %rdi
callq 0x268f0
jmp 0x7e08d
jmp 0x7e080
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4dd26
leaq 0x18(%rsp), %rdi
callq 0x4dd26
movq %rbx, %rdi
callq 0x27660
|
_ZN5minja6Parser17parseIfExpressionEv:
push r15
push r14
push rbx
sub rsp, 40h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+58h+var_48]
mov rdi, r15; this
call _ZN5minja6Parser14parseLogicalOrEv; minja::Parser::parseLogicalOr(void)
cmp qword ptr [r15], 0
jz loc_7DFC7
lea rax, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; `guard variable for'minja::Parser::parseIfExpression(void)::else_tok
mov al, [rax]
test al, al
jz loc_7DFF7
loc_7DEE5:
xorps xmm0, xmm0
movaps [rsp+58h+var_58], xmm0
lea rdx, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rdi, [rsp+58h+var_38]
push 1
pop rcx
mov rsi, r14
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rdi, [rsp+58h+var_38]; void *
mov r15, [rdi+8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r15, r15
jz short loc_7DF7A
lea rdi, [rsp+58h+var_38]; this
push 1
pop rdx
mov rsi, r14; bool
call _ZN5minja6Parser15parseExpressionEb; minja::Parser::parseExpression(bool)
mov r14, rsp
lea rsi, [rsp+58h+var_38]
mov rdi, r14
call _ZNSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEaSEOS4_; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>&&)
lea rdi, [rsp+58h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, [r14]
test rax, rax
jnz short loc_7DF7E
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedElseEx; "Expected 'else' expression"
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
jmp short loc_7DFF7
loc_7DF7A:
mov rax, qword ptr [rsp+58h+var_58]
loc_7DF7E:
lea r14, [rsp+58h+var_40]
movaps xmm0, xmmword ptr [r14-8]
and qword ptr [r14], 0
and qword ptr [r14-8], 0
movups xmmword ptr [rbx], xmm0
mov [rbx+10h], rax
lea rdi, [rsp+58h+var_58+8]
mov rax, [rdi]
and qword ptr [rdi], 0
mov [rbx+18h], rax
and qword ptr [rdi-8], 0
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop r15
retn
loc_7DFC7:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedCondit_1; "Expected condition expression"
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_7DFF7:
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_7DEE5
lea rdi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rsi, aElseB; "else\\b"
push 10h
pop rdx
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_7DEE5
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_7E08D
jmp short loc_7E080
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_7E083
mov rbx, rax
jmp short loc_7E08D
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_7E08D
jmp short $+2
loc_7E080:
mov rbx, rax
loc_7E083:
lea rdi, [rsp+arg_0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_7E08D:
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, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseIfExpression(minja::Parser *this, _QWORD *a2)
{
long long v2; // r15
long long v3; // rax
std::runtime_error *v4; // r14
__int128 v5; // xmm0
long long v6; // rax
std::runtime_error *exception; // r14
__int128 v9; // [rsp+0h] [rbp-58h] BYREF
__int128 v10; // [rsp+10h] [rbp-48h] BYREF
long long v11; // [rsp+20h] [rbp-38h] BYREF
_QWORD v12[6]; // [rsp+28h] [rbp-30h] BYREF
minja::Parser::parseLogicalOr((minja::Parser *)&v10, a2);
if ( !(_QWORD)v10 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected condition expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
(long long)"else\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]);
}
v9 = 0LL;
minja::Parser::consumeToken(
&v11,
(long long)a2,
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
1u);
v2 = v12[0];
std::string::~string(&v11);
if ( v2 )
{
minja::Parser::parseExpression((minja::Parser *)&v11, a2, 1);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=(&v9, &v11);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v12);
v3 = v9;
if ( !(_QWORD)v9 )
{
v4 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v4, "Expected 'else' expression");
__cxa_throw(
v4,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
else
{
v3 = v9;
}
v5 = v10;
v10 = 0uLL;
*(_OWORD *)this = v5;
*((_QWORD *)this + 2) = v3;
v6 = *((_QWORD *)&v9 + 1);
*((_QWORD *)&v9 + 1) = 0LL;
*((_QWORD *)this + 3) = v6;
*(_QWORD *)&v9 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v9 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v10 + 1);
return this;
}
|
parseIfExpression:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x10]
MOV RDI,R15
CALL 0x0017dcac
CMP qword ptr [R15],0x0
JZ 0x0017dfc7
LEA RAX,[0x222670]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x0017dff7
LAB_0017dee5:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
LAB_0017deec:
LEA RDX,[0x222650]
LEA RDI,[RSP + 0x20]
PUSH 0x1
POP RCX
MOV RSI,R14
CALL 0x0017ca3c
LEA RDI,[RSP + 0x20]
MOV R15,qword ptr [RDI + 0x8]
CALL 0x00127998
TEST R15,R15
JZ 0x0017df7a
LAB_0017df16:
LEA RDI,[RSP + 0x20]
PUSH 0x1
POP RDX
MOV RSI,R14
CALL 0x0017c856
LAB_0017df26:
MOV R14,RSP
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x0018d870
LEA RDI,[RSP + 0x28]
CALL 0x0014dd26
MOV RAX,qword ptr [R14]
TEST RAX,RAX
JNZ 0x0017df7e
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV R14,RAX
LAB_0017df53:
LEA RSI,[0x1d1e0b]
MOV RDI,RAX
CALL 0x00126420
LAB_0017df62:
MOV RSI,qword ptr [0x00220ff0]
MOV RDX,qword ptr [0x00220f58]
MOV RDI,R14
CALL 0x001275b0
LAB_0017df7a:
MOV RAX,qword ptr [RSP]
LAB_0017df7e:
LEA R14,[RSP + 0x18]
MOVAPS XMM0,xmmword ptr [R14 + -0x8]
AND qword ptr [R14],0x0
AND qword ptr [R14 + -0x8],0x0
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RBX + 0x10],RAX
LEA RDI,[RSP + 0x8]
MOV RAX,qword ptr [RDI]
AND qword ptr [RDI],0x0
MOV qword ptr [RBX + 0x18],RAX
AND qword ptr [RDI + -0x8],0x0
CALL 0x0014dd26
MOV RDI,R14
CALL 0x0014dd26
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
LAB_0017dfc7:
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV R14,RAX
LAB_0017dfd2:
LEA RSI,[0x1d1de6]
MOV RDI,RAX
CALL 0x00126420
LAB_0017dfe1:
MOV RSI,qword ptr [0x00220ff0]
MOV RDX,qword ptr [0x00220f58]
MOV RDI,R14
CALL 0x001275b0
LAB_0017dff7:
LEA RDI,[0x222670]
CALL 0x00127700
TEST EAX,EAX
JZ 0x0017dee5
LAB_0017e00b:
LEA RDI,[0x222650]
LEA RSI,[0x1d1e04]
PUSH 0x10
POP RDX
CALL 0x0016d972
LAB_0017e021:
LEA RDI,[0x1428de]
LEA RSI,[0x222650]
LEA RDX,[0x221cd8]
CALL 0x00126aa0
LEA RDI,[0x222670]
CALL 0x00126800
JMP 0x0017dee5
|
/* minja::Parser::parseIfExpression() */
void minja::Parser::parseIfExpression(void)
{
long lVar1;
long lVar2;
long lVar3;
int iVar4;
runtime_error *prVar5;
long *in_RDI;
long local_58;
long lStack_50;
long local_48;
long lStack_40;
string local_38 [8];
long local_30 [3];
parseLogicalOr();
if (local_48 == 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017dfd2 to 0017dfe0 has its CatchHandler @ 0017e071 */
std::runtime_error::runtime_error(prVar5,"Expected condition expression");
/* try { // try from 0017dfe1 to 0017dff6 has its CatchHandler @ 0017e06c */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00220ff0,PTR__runtime_error_00220f58);
}
if ((parseIfExpression()::else_tok_abi_cxx11_ == '\0') &&
(iVar4 = __cxa_guard_acquire(&parseIfExpression()::else_tok_abi_cxx11_), iVar4 != 0)) {
/* try { // try from 0017e00b to 0017e020 has its CatchHandler @ 0017e04c */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseIfExpression()::else_tok_abi_cxx11_,"else\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseIfExpression()::else_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseIfExpression()::else_tok_abi_cxx11_);
}
local_58 = 0;
lStack_50 = 0;
/* try { // try from 0017deec to 0017df02 has its CatchHandler @ 0017e080 */
consumeToken(local_38);
std::__cxx11::string::~string(local_38);
if (local_30[0] != 0) {
/* try { // try from 0017df16 to 0017df25 has its CatchHandler @ 0017e07e */
parseExpression(SUB81(local_38,0));
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2> *)&local_58,
(__shared_ptr *)local_38);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)local_30);
if (local_58 == 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017df53 to 0017df61 has its CatchHandler @ 0017e05f */
std::runtime_error::runtime_error(prVar5,"Expected \'else\' expression");
/* try { // try from 0017df62 to 0017df77 has its CatchHandler @ 0017e05d */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00220ff0,PTR__runtime_error_00220f58);
}
}
lVar3 = lStack_40;
lVar2 = local_48;
lVar1 = lStack_50;
lStack_40 = 0;
local_48 = 0;
*in_RDI = lVar2;
in_RDI[1] = lVar3;
in_RDI[2] = local_58;
lStack_50 = 0;
in_RDI[3] = lVar1;
local_58 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&lStack_50);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&lStack_40);
return;
}
|
|
11,310 |
mthd_stmt_get_param_metadata
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
my_bool mthd_stmt_get_param_metadata(MYSQL_STMT *stmt)
{
MYSQL_DATA *result;
if (!(result= stmt->mysql->methods->db_read_rows(stmt->mysql, (MYSQL_FIELD *)0,
7 + ma_extended_type_info_rows(stmt->mysql))))
return(1);
free_rows(result);
return(0);
}
|
O0
|
c
|
mthd_stmt_get_param_metadata:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2bb10
movq -0x28(%rbp), %rdi
movl %eax, %edx
movq -0x20(%rbp), %rax
addl $0x7, %edx
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2baef
movb $0x1, -0x1(%rbp)
jmp 0x2bafc
movq -0x18(%rbp), %rdi
callq 0x177c0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mthd_stmt_get_param_metadata:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
call ma_extended_type_info_rows
mov rdi, [rbp+var_28]
mov edx, eax
mov rax, [rbp+var_20]
add edx, 7
xor ecx, ecx
mov esi, ecx
call rax
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_2BAEF
mov [rbp+var_1], 1
jmp short loc_2BAFC
loc_2BAEF:
mov rdi, [rbp+var_18]
call free_rows
mov [rbp+var_1], 0
loc_2BAFC:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char mthd_stmt_get_param_metadata(long long a1)
{
int v1; // eax
long long v3; // [rsp+8h] [rbp-28h]
long long ( *v4)(long long, _QWORD, _QWORD); // [rsp+10h] [rbp-20h]
long long v5; // [rsp+18h] [rbp-18h]
v4 = *(long long ( **)(long long, _QWORD, _QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 40LL);
v3 = *(_QWORD *)(a1 + 56);
v1 = ma_extended_type_info_rows(v3);
v5 = v4(v3, 0LL, (unsigned int)(v1 + 7));
if ( !v5 )
return 1;
free_rows(v5);
return 0;
}
|
mthd_stmt_get_param_metadata:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
CALL 0x0012bb10
MOV RDI,qword ptr [RBP + -0x28]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD EDX,0x7
XOR ECX,ECX
MOV ESI,ECX
CALL RAX
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0012baef
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012bafc
LAB_0012baef:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001177c0
MOV byte ptr [RBP + -0x1],0x0
LAB_0012bafc:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
bool mthd_stmt_get_param_metadata(long param_1)
{
code *pcVar1;
int8 uVar2;
int iVar3;
long lVar4;
bool local_9;
pcVar1 = *(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x28);
uVar2 = *(int8 *)(param_1 + 0x38);
iVar3 = ma_extended_type_info_rows(*(int8 *)(param_1 + 0x38));
lVar4 = (*pcVar1)(uVar2,0,iVar3 + 7);
if (lVar4 != 0) {
free_rows(lVar4);
}
local_9 = lVar4 == 0;
return local_9;
}
|
|
11,311 |
dbgprintf(char const*, ...)
|
DanielDanyang[P]CSC3050-2025-Spring-Project-4/include/Debug.h
|
inline void dbgprintf(const char *format, ...) {
#ifdef DEBUG
char buf[BUFSIZ];
va_list args;
va_start(args, format);
vsprintf(buf, format, args);
fprintf(stderr, "%s", buf);
va_end(args);
#endif
}
|
O0
|
c
|
dbgprintf(char const*, ...):
subq $0x20e8, %rsp # imm = 0x20E8
testb %al, %al
je 0x2f9f
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20e0(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0xd0(%rsp)
leaq 0x20f0(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x8, 0xc0(%rsp)
movq 0x20e0(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0xc0(%rsp), %rdx
callq 0x20d0
movq 0x8(%rsp), %rdx
movq 0x8fb7(%rip), %rax # 0xbfd8
movq (%rax), %rdi
leaq 0x50d5(%rip), %rsi # 0x8100
xorl %eax, %eax
callq 0x2240
addq $0x20e8, %rsp # imm = 0x20E8
retq
nopw (%rax,%rax)
|
_Z9dbgprintfPKcz:
sub rsp, 20E8h
test al, al
jz short loc_2F9F
movaps [rsp+20E8h+var_20A8], xmm0
movaps [rsp+20E8h+var_2098], xmm1
movaps [rsp+20E8h+var_2088], xmm2
movaps [rsp+20E8h+var_2078], xmm3
movaps [rsp+20E8h+var_2068], xmm4
movaps [rsp+20E8h+var_2058], xmm5
movaps [rsp+20E8h+var_2048], xmm6
movaps [rsp+20E8h+var_2038], xmm7
loc_2F9F:
mov [rsp+20E8h+var_20B0], r9
mov [rsp+20E8h+var_20B8], r8
mov [rsp+20E8h+var_20C0], rcx
mov [rsp+20E8h+var_20C8], rdx
mov [rsp+20E8h+var_20D0], rsi
mov [rsp+20E8h+var_8], rdi
lea rax, [rsp+20E8h+var_20D8]
mov [rsp+20E8h+var_2018], rax
lea rax, [rsp+20E8h+arg_0]
mov [rsp+20E8h+var_2020], rax
mov [rsp+20E8h+var_2024], 30h ; '0'
mov [rsp+20E8h+var_2028], 8
mov rsi, [rsp+20E8h+var_8]
lea rdi, [rsp+20E8h+var_2008]
mov [rsp+20E8h+var_20E0], rdi
lea rdx, [rsp+20E8h+var_2028]
call _vsprintf
mov rdx, [rsp+20E8h+var_20E0]
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aS; "%s"
xor eax, eax
call _fprintf
add rsp, 20E8h
retn
|
long long dbgprintf(
const char *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v16; // [rsp+10h] [rbp-20D8h] BYREF
long long v17; // [rsp+18h] [rbp-20D0h]
long long v18; // [rsp+20h] [rbp-20C8h]
long long v19; // [rsp+28h] [rbp-20C0h]
long long v20; // [rsp+30h] [rbp-20B8h]
long long v21; // [rsp+38h] [rbp-20B0h]
__m128 v22; // [rsp+40h] [rbp-20A8h]
__m128 v23; // [rsp+50h] [rbp-2098h]
__m128 v24; // [rsp+60h] [rbp-2088h]
__m128 v25; // [rsp+70h] [rbp-2078h]
__m128 v26; // [rsp+80h] [rbp-2068h]
__m128 v27; // [rsp+90h] [rbp-2058h]
__m128 v28; // [rsp+A0h] [rbp-2048h]
__m128 v29; // [rsp+B0h] [rbp-2038h]
_DWORD v30[2]; // [rsp+C0h] [rbp-2028h] BYREF
char *v31; // [rsp+C8h] [rbp-2020h]
char *v32; // [rsp+D0h] [rbp-2018h]
char v33[8192]; // [rsp+E0h] [rbp-2008h] BYREF
const char *v34; // [rsp+20E0h] [rbp-8h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v21 = a6;
v20 = a5;
v19 = a4;
v18 = a3;
v17 = a2;
v34 = a1;
v32 = &v16;
v31 = &a15;
v30[1] = 48;
v30[0] = 8;
vsprintf(v33, a1, v30);
return fprintf(stderr, "%s", v33);
}
|
dbgprintf:
SUB RSP,0x20e8
TEST AL,AL
JZ 0x00102f9f
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM1
MOVAPS xmmword ptr [RSP + 0x60],XMM2
MOVAPS xmmword ptr [RSP + 0x70],XMM3
MOVAPS xmmword ptr [RSP + 0x80],XMM4
MOVAPS xmmword ptr [RSP + 0x90],XMM5
MOVAPS xmmword ptr [RSP + 0xa0],XMM6
MOVAPS xmmword ptr [RSP + 0xb0],XMM7
LAB_00102f9f:
MOV qword ptr [RSP + 0x38],R9
MOV qword ptr [RSP + 0x30],R8
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x20e0],RDI
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP + 0xd0],RAX
LEA RAX,[RSP + 0x20f0]
MOV qword ptr [RSP + 0xc8],RAX
MOV dword ptr [RSP + 0xc4],0x30
MOV dword ptr [RSP + 0xc0],0x8
MOV RSI,qword ptr [RSP + 0x20e0]
LEA RDI,[RSP + 0xe0]
MOV qword ptr [RSP + 0x8],RDI
LEA RDX,[RSP + 0xc0]
CALL 0x001020d0
MOV RDX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [0x0010bfd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x108100]
XOR EAX,EAX
CALL 0x00102240
ADD RSP,0x20e8
RET
|
/* dbgprintf(char const*, ...) */
void dbgprintf(char *param_1,...)
{
char in_AL;
int8 in_RCX;
int8 in_RDX;
int8 in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
int1 local_20d8 [8];
int8 local_20d0;
int8 local_20c8;
int8 local_20c0;
int8 local_20b8;
int8 local_20b0;
int8 local_20a8;
int8 local_2098;
int8 local_2088;
int8 local_2078;
int8 local_2068;
int8 local_2058;
int8 local_2048;
int8 local_2038;
int4 local_2028;
int4 local_2024;
int1 *local_2020;
int1 *local_2018;
char local_2008 [8192];
char *local_8;
if (in_AL != '\0') {
local_20a8 = in_XMM0_Qa;
local_2098 = in_XMM1_Qa;
local_2088 = in_XMM2_Qa;
local_2078 = in_XMM3_Qa;
local_2068 = in_XMM4_Qa;
local_2058 = in_XMM5_Qa;
local_2048 = in_XMM6_Qa;
local_2038 = in_XMM7_Qa;
}
local_2018 = local_20d8;
local_2020 = &stack0x00000008;
local_2024 = 0x30;
local_2028 = 8;
local_20d0 = in_RSI;
local_20c8 = in_RDX;
local_20c0 = in_RCX;
local_20b8 = in_R8;
local_20b0 = in_R9;
local_8 = param_1;
vsprintf(local_2008,param_1,&local_2028);
fprintf(*(FILE **)PTR_stderr_0010bfd8,"%s",local_2008);
return;
}
|
|
11,312 |
dbgprintf(char const*, ...)
|
DanielDanyang[P]CSC3050-2025-Spring-Project-4/include/Debug.h
|
inline void dbgprintf(const char *format, ...) {
#ifdef DEBUG
char buf[BUFSIZ];
va_list args;
va_start(args, format);
vsprintf(buf, format, args);
fprintf(stderr, "%s", buf);
va_end(args);
#endif
}
|
O1
|
c
|
dbgprintf(char const*, ...):
pushq %rbx
subq $0x20d0, %rsp # imm = 0x20D0
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x231f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0x20e0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0xd0(%rsp), %rbx
movq %rbx, %rdi
movq %r10, %rsi
callq 0x20c0
movq 0x5c7f(%rip), %rax # 0x7fd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2180
addq $0x20d0, %rsp # imm = 0x20D0
popq %rbx
retq
|
_Z9dbgprintfPKcz:
push rbx
sub rsp, 20D0h
mov r10, rdi
lea rdi, [rsp+20D8h+var_20B8]
mov [rdi+8], rsi
mov [rdi+10h], rdx
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test al, al
jz short loc_231F
movaps [rsp+20D8h+var_2088], xmm0
movaps [rsp+20D8h+var_2078], xmm1
movaps [rsp+20D8h+var_2068], xmm2
movaps [rsp+20D8h+var_2058], xmm3
movaps [rsp+20D8h+var_2048], xmm4
movaps [rsp+20D8h+var_2038], xmm5
movaps [rsp+20D8h+var_2028], xmm6
movaps [rsp+20D8h+var_2018], xmm7
loc_231F:
mov rdx, rsp
mov [rdx+10h], rdi
lea rax, [rsp+20D8h+arg_0]
mov [rdx+8], rax
mov rax, 3000000008h
mov [rdx], rax
lea rbx, [rsp+20D8h+var_2008]
mov rdi, rbx
mov rsi, r10
call _vsprintf
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov rdi, rbx
call _fputs
add rsp, 20D0h
pop rbx
retn
|
long long dbgprintf(
const char *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_QWORD v16[4]; // [rsp+0h] [rbp-20D8h] BYREF
char v17; // [rsp+20h] [rbp-20B8h] BYREF
long long v18; // [rsp+28h] [rbp-20B0h]
long long v19; // [rsp+30h] [rbp-20A8h]
long long v20; // [rsp+38h] [rbp-20A0h]
long long v21; // [rsp+40h] [rbp-2098h]
long long v22; // [rsp+48h] [rbp-2090h]
__m128 v23; // [rsp+50h] [rbp-2088h]
__m128 v24; // [rsp+60h] [rbp-2078h]
__m128 v25; // [rsp+70h] [rbp-2068h]
__m128 v26; // [rsp+80h] [rbp-2058h]
__m128 v27; // [rsp+90h] [rbp-2048h]
__m128 v28; // [rsp+A0h] [rbp-2038h]
__m128 v29; // [rsp+B0h] [rbp-2028h]
__m128 v30; // [rsp+C0h] [rbp-2018h]
_BYTE v31[8200]; // [rsp+D0h] [rbp-2008h] BYREF
v23 = a7;
v24 = a8;
v25 = a9;
v26 = a10;
v27 = a11;
v28 = a12;
v29 = a13;
v30 = a14;
v18 = a2;
v19 = a3;
v20 = a4;
v21 = a5;
v22 = a6;
v16[2] = &v17;
v16[1] = &a15;
v16[0] = 0x3000000008LL;
((void ( *)(_BYTE *, const char *, _QWORD *))vsprintf)(v31, a1, v16);
return fputs(v31, stderr);
}
|
dbgprintf:
PUSH RBX
SUB RSP,0x20d0
MOV R10,RDI
LEA RDI,[RSP + 0x20]
MOV qword ptr [RDI + 0x8],RSI
MOV qword ptr [RDI + 0x10],RDX
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST AL,AL
JZ 0x0010231f
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_0010231f:
MOV RDX,RSP
MOV qword ptr [RDX + 0x10],RDI
LEA RAX,[RSP + 0x20e0]
MOV qword ptr [RDX + 0x8],RAX
MOV RAX,0x3000000008
MOV qword ptr [RDX],RAX
LEA RBX,[RSP + 0xd0]
MOV RDI,RBX
MOV RSI,R10
CALL 0x001020c0
MOV RAX,qword ptr [0x00107fd8]
MOV RSI,qword ptr [RAX]
MOV RDI,RBX
CALL 0x00102180
ADD RSP,0x20d0
POP RBX
RET
|
/* dbgprintf(char const*, ...) */
void dbgprintf(char *param_1,...)
{
char in_AL;
int8 in_RCX;
int8 in_RDX;
int8 in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
int8 local_20d8;
int1 *local_20d0;
int1 *local_20c8;
int1 local_20b8 [8];
int8 local_20b0;
int8 local_20a8;
int8 local_20a0;
int8 local_2098;
int8 local_2090;
int8 local_2088;
int8 local_2078;
int8 local_2068;
int8 local_2058;
int8 local_2048;
int8 local_2038;
int8 local_2028;
int8 local_2018;
char local_2008 [8192];
local_20c8 = local_20b8;
if (in_AL != '\0') {
local_2088 = in_XMM0_Qa;
local_2078 = in_XMM1_Qa;
local_2068 = in_XMM2_Qa;
local_2058 = in_XMM3_Qa;
local_2048 = in_XMM4_Qa;
local_2038 = in_XMM5_Qa;
local_2028 = in_XMM6_Qa;
local_2018 = in_XMM7_Qa;
}
local_20d0 = &stack0x00000008;
local_20d8 = 0x3000000008;
local_20b0 = in_RSI;
local_20a8 = in_RDX;
local_20a0 = in_RCX;
local_2098 = in_R8;
local_2090 = in_R9;
vsprintf(local_2008,param_1,&local_20d8);
fputs(local_2008,*(FILE **)PTR_stderr_00107fd8);
return;
}
|
|
11,313 |
dbgprintf(char const*, ...)
|
DanielDanyang[P]CSC3050-2025-Spring-Project-4/include/Debug.h
|
inline void dbgprintf(const char *format, ...) {
#ifdef DEBUG
char buf[BUFSIZ];
va_list args;
va_start(args, format);
vsprintf(buf, format, args);
fprintf(stderr, "%s", buf);
va_end(args);
#endif
}
|
O2
|
c
|
dbgprintf(char const*, ...):
pushq %rbx
subq $0x20d0, %rsp # imm = 0x20D0
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x29dc
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0x20e0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0xd0(%rsp), %rbx
movq %rbx, %rdi
movq %r10, %rsi
callq 0x20d0
movq 0x55c2(%rip), %rax # 0x7fd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2180
addq $0x20d0, %rsp # imm = 0x20D0
popq %rbx
retq
nop
|
_Z9dbgprintfPKcz:
push rbx
sub rsp, 20D0h
mov r10, rdi
lea rdi, [rsp+20D8h+var_20B8]
mov [rdi+8], rsi
mov [rdi+10h], rdx
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test al, al
jz short loc_29DC
movaps [rsp+20D8h+var_2088], xmm0
movaps [rsp+20D8h+var_2078], xmm1
movaps [rsp+20D8h+var_2068], xmm2
movaps [rsp+20D8h+var_2058], xmm3
movaps [rsp+20D8h+var_2048], xmm4
movaps [rsp+20D8h+var_2038], xmm5
movaps [rsp+20D8h+var_2028], xmm6
movaps [rsp+20D8h+var_2018], xmm7
loc_29DC:
mov rdx, rsp
mov [rdx+10h], rdi
lea rax, [rsp+20D8h+arg_0]
mov [rdx+8], rax
mov rax, 3000000008h
mov [rdx], rax
lea rbx, [rsp+20D8h+var_2008]
mov rdi, rbx
mov rsi, r10
call _vsprintf
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov rdi, rbx
call _fputs
add rsp, 20D0h
pop rbx
retn
|
long long dbgprintf(
const char *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_QWORD v16[4]; // [rsp+0h] [rbp-20D8h] BYREF
char v17; // [rsp+20h] [rbp-20B8h] BYREF
long long v18; // [rsp+28h] [rbp-20B0h]
long long v19; // [rsp+30h] [rbp-20A8h]
long long v20; // [rsp+38h] [rbp-20A0h]
long long v21; // [rsp+40h] [rbp-2098h]
long long v22; // [rsp+48h] [rbp-2090h]
__m128 v23; // [rsp+50h] [rbp-2088h]
__m128 v24; // [rsp+60h] [rbp-2078h]
__m128 v25; // [rsp+70h] [rbp-2068h]
__m128 v26; // [rsp+80h] [rbp-2058h]
__m128 v27; // [rsp+90h] [rbp-2048h]
__m128 v28; // [rsp+A0h] [rbp-2038h]
__m128 v29; // [rsp+B0h] [rbp-2028h]
__m128 v30; // [rsp+C0h] [rbp-2018h]
_BYTE v31[8200]; // [rsp+D0h] [rbp-2008h] BYREF
v23 = a7;
v24 = a8;
v25 = a9;
v26 = a10;
v27 = a11;
v28 = a12;
v29 = a13;
v30 = a14;
v18 = a2;
v19 = a3;
v20 = a4;
v21 = a5;
v22 = a6;
v16[2] = &v17;
v16[1] = &a15;
v16[0] = 0x3000000008LL;
((void ( *)(_BYTE *, const char *, _QWORD *))vsprintf)(v31, a1, v16);
return fputs(v31, stderr);
}
|
dbgprintf:
PUSH RBX
SUB RSP,0x20d0
MOV R10,RDI
LEA RDI,[RSP + 0x20]
MOV qword ptr [RDI + 0x8],RSI
MOV qword ptr [RDI + 0x10],RDX
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST AL,AL
JZ 0x001029dc
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_001029dc:
MOV RDX,RSP
MOV qword ptr [RDX + 0x10],RDI
LEA RAX,[RSP + 0x20e0]
MOV qword ptr [RDX + 0x8],RAX
MOV RAX,0x3000000008
MOV qword ptr [RDX],RAX
LEA RBX,[RSP + 0xd0]
MOV RDI,RBX
MOV RSI,R10
CALL 0x001020d0
MOV RAX,qword ptr [0x00107fd8]
MOV RSI,qword ptr [RAX]
MOV RDI,RBX
CALL 0x00102180
ADD RSP,0x20d0
POP RBX
RET
|
/* dbgprintf(char const*, ...) */
void dbgprintf(char *param_1,...)
{
char in_AL;
int8 in_RCX;
int8 in_RDX;
int8 in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
int8 local_20d8;
int1 *local_20d0;
int1 *local_20c8;
int1 local_20b8 [8];
int8 local_20b0;
int8 local_20a8;
int8 local_20a0;
int8 local_2098;
int8 local_2090;
int8 local_2088;
int8 local_2078;
int8 local_2068;
int8 local_2058;
int8 local_2048;
int8 local_2038;
int8 local_2028;
int8 local_2018;
char local_2008 [8192];
local_20c8 = local_20b8;
if (in_AL != '\0') {
local_2088 = in_XMM0_Qa;
local_2078 = in_XMM1_Qa;
local_2068 = in_XMM2_Qa;
local_2058 = in_XMM3_Qa;
local_2048 = in_XMM4_Qa;
local_2038 = in_XMM5_Qa;
local_2028 = in_XMM6_Qa;
local_2018 = in_XMM7_Qa;
}
local_20d0 = &stack0x00000008;
local_20d8 = 0x3000000008;
local_20b0 = in_RSI;
local_20a8 = in_RDX;
local_20a0 = in_RCX;
local_2098 = in_R8;
local_2090 = in_R9;
vsprintf(local_2008,param_1,&local_20d8);
fputs(local_2008,*(FILE **)PTR_stderr_00107fd8);
return;
}
|
|
11,314 |
tensor_to_float(ggml_tensor const*)
|
llama.cpp/tests/test-backend-ops.cpp
|
static std::vector<float> tensor_to_float(const ggml_tensor * t) {
std::vector<float> tv;
tv.reserve(ggml_nelements(t));
std::vector<uint8_t> buf(ggml_nbytes(t));
ggml_backend_tensor_get(t, buf.data(), 0, ggml_nbytes(t));
const auto * tt = ggml_get_type_traits(t->type);
size_t bs = ggml_blck_size(t->type);
std::vector<float> vq(ggml_blck_size(t->type));
bool quantized = ggml_is_quantized(t->type);
// access elements by index to avoid gaps in views
for (int64_t i3 = 0; i3 < t->ne[3]; i3++) {
for (int64_t i2 = 0; i2 < t->ne[2]; i2++) {
for (int64_t i1 = 0; i1 < t->ne[1]; i1++) {
for (int64_t i0 = 0; i0 < t->ne[0]; i0 += bs) {
size_t i = i3*t->nb[3] + i2*t->nb[2] + i1*t->nb[1] + i0/bs*t->nb[0];
if (t->type == GGML_TYPE_F16) {
tv.push_back(ggml_fp16_to_fp32(*(ggml_fp16_t*)&buf[i]));
} else if (t->type == GGML_TYPE_BF16) {
tv.push_back(ggml_bf16_to_fp32(*(ggml_bf16_t*)&buf[i]));
} else if (t->type == GGML_TYPE_F32) {
tv.push_back(*(float *) &buf[i]);
} else if (t->type == GGML_TYPE_I64) {
tv.push_back((float)*(int64_t *) &buf[i]);
} else if (t->type == GGML_TYPE_I32) {
tv.push_back((float)*(int32_t *) &buf[i]);
} else if (t->type == GGML_TYPE_I16) {
tv.push_back((float)*(int16_t *) &buf[i]);
} else if (t->type == GGML_TYPE_I8) {
tv.push_back((float)*(int8_t *) &buf[i]);
} else if (quantized) {
tt->to_float(&buf[i], vq.data(), bs);
tv.insert(tv.end(), vq.begin(), vq.end());
} else {
GGML_ABORT("fatal error");
}
}
}
}
}
return tv;
}
|
O3
|
cpp
|
tensor_to_float(ggml_tensor const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x1cb00
movq %rbx, %rdi
movq %rax, %rsi
callq 0x671ee
movq %r14, %rdi
callq 0x1cbb0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rax, %rsi
callq 0x2bcf0
movq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x1cbb0
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x1ccf0
movl (%r14), %edi
callq 0x1c3c0
movq %rax, 0x40(%rsp)
movl (%r14), %edi
callq 0x1ce80
movq %rax, %r12
movl (%r14), %edi
callq 0x1ce80
leaq 0x28(%rsp), %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x2b93c
movl (%r14), %edi
callq 0x1c0e0
movb %al, 0x7(%rsp)
movq 0x28(%r14), %rcx
testq %rcx, %rcx
jle 0x285e2
movq 0x20(%r14), %rax
movq $0x0, 0x20(%rsp)
testq %rax, %rax
jle 0x285cc
movq 0x18(%r14), %rcx
xorl %ebp, %ebp
testq %rcx, %rcx
jle 0x285bc
movq 0x10(%r14), %rax
xorl %r13d, %r13d
testq %rax, %rax
jle 0x285ac
xorl %r15d, %r15d
movq 0x48(%r14), %rax
imulq 0x20(%rsp), %rax
movq 0x40(%r14), %rcx
imulq %rbp, %rcx
addq %rax, %rcx
movq 0x38(%r14), %rsi
imulq %r13, %rsi
addq %rcx, %rsi
movq %r15, %rax
xorl %edx, %edx
divq %r12
imulq 0x30(%r14), %rax
addq %rsi, %rax
movl (%r14), %ecx
leal -0x18(%rcx), %edx
cmpl $0x6, %edx
ja 0x2843e
leaq 0x3ffde(%rip), %rsi # 0x683e0
movslq (%rsi,%rdx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movq 0x8(%rsp), %rcx
movsbl (%rcx,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
jne 0x2857d
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x6728a
jmp 0x28589
testl %ecx, %ecx
je 0x2856a
cmpl $0x1, %ecx
jne 0x2847c
movq 0x8(%rsp), %rcx
movzwl (%rcx,%rax), %edi
callq 0x1c320
movss %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
jne 0x2857d
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x6728a
jmp 0x28589
cmpb $0x0, 0x7(%rsp)
je 0x2861f
addq 0x8(%rsp), %rax
movq 0x28(%rsp), %rsi
movq %rax, %rdi
movq %r12, %rdx
movq 0x40(%rsp), %rax
callq *0x28(%rax)
movq 0x8(%rbx), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq %rbx, %rdi
callq 0x6748e
jmp 0x28589
movq 0x8(%rsp), %rcx
movswl (%rcx,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
jne 0x2857d
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x6728a
jmp 0x28589
movq 0x8(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2ssl (%rcx,%rax), %xmm0
movss %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
jne 0x2857d
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x6728a
jmp 0x28589
movq 0x8(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2ssq (%rcx,%rax), %xmm0
movss %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
jne 0x2857d
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x6728a
jmp 0x28589
movq 0x8(%rsp), %rcx
movzwl (%rcx,%rax), %edi
callq 0x1cea0
movss %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
jne 0x2857d
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x6728a
jmp 0x28589
addq 0x8(%rsp), %rax
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2859b
movss (%rax), %xmm0
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
addq %r12, %r15
movq 0x10(%r14), %rax
cmpq %rax, %r15
jl 0x283c0
jmp 0x285a8
movq %rbx, %rdi
movq %rax, %rdx
callq 0x673ae
jmp 0x28589
movq 0x18(%r14), %rcx
incq %r13
cmpq %rcx, %r13
jl 0x283b4
movq 0x20(%r14), %rax
incq %rbp
cmpq %rax, %rbp
jl 0x283a4
movq 0x28(%r14), %rcx
movq 0x20(%rsp), %rsi
incq %rsi
movq %rsi, 0x20(%rsp)
cmpq %rcx, %rsi
jl 0x28395
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x285f9
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x1c100
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x28610
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1c100
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4066e(%rip), %rdi # 0x68c94
leaq 0x407af(%rip), %rdx # 0x68ddc
movl $0xa6, %esi
xorl %eax, %eax
callq 0x1c980
jmp 0x28661
jmp 0x28647
jmp 0x28647
jmp 0x28647
jmp 0x28647
jmp 0x2864c
jmp 0x2864c
movq %rax, %r14
jmp 0x2867b
movq %rax, %r14
jmp 0x28692
jmp 0x28661
jmp 0x28661
jmp 0x28661
jmp 0x28661
jmp 0x28661
jmp 0x28661
jmp 0x28661
jmp 0x28661
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2867b
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x1c100
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x28692
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1c100
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x286a6
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1c100
movq %r14, %rdi
callq 0x1c6d0
|
_ZL15tensor_to_floatPK11ggml_tensor:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdi, rsi
call _ggml_nelements
mov rdi, rbx
mov rsi, rax
call _ZNSt6vectorIfSaIfEE7reserveEm; std::vector<float>::reserve(ulong)
mov rdi, r14
call _ggml_nbytes
lea rdi, [rsp+78h+var_70]
lea rdx, [rsp+78h+var_50]
mov rsi, rax
call _ZNSt6vectorIhSaIhEEC2EmRKS0_; std::vector<uchar>::vector(ulong,std::allocator<uchar> const&)
mov r15, [rsp+78h+var_70]
mov rdi, r14
call _ggml_nbytes
mov rdi, r14
mov rsi, r15
xor edx, edx
mov rcx, rax
call _ggml_backend_tensor_get
mov edi, [r14]
call _ggml_get_type_traits
mov [rsp+78h+var_38], rax
mov edi, [r14]
call _ggml_blck_size
mov r12, rax
mov edi, [r14]
call _ggml_blck_size
lea rdi, [rsp+78h+var_50]
mov rdx, rsp
mov rsi, rax
call _ZNSt6vectorIfSaIfEEC2EmRKS0_; std::vector<float>::vector(ulong,std::allocator<float> const&)
mov edi, [r14]
call _ggml_is_quantized
mov [rsp+78h+var_71], al
mov rcx, [r14+28h]
test rcx, rcx
jle loc_285E2
mov rax, [r14+20h]
mov [rsp+78h+var_58], 0
loc_28395:
test rax, rax
jle loc_285CC
mov rcx, [r14+18h]
xor ebp, ebp
loc_283A4:
test rcx, rcx
jle loc_285BC
mov rax, [r14+10h]
xor r13d, r13d
loc_283B4:
test rax, rax
jle loc_285AC
xor r15d, r15d
loc_283C0:
mov rax, [r14+48h]
imul rax, [rsp+78h+var_58]
mov rcx, [r14+40h]
imul rcx, rbp
add rcx, rax
mov rsi, [r14+38h]
imul rsi, r13
add rsi, rcx
mov rax, r15
xor edx, edx
div r12
imul rax, [r14+30h]
add rax, rsi
mov ecx, [r14]
lea edx, [rcx-18h]; switch 7 cases
cmp edx, 6
ja short def_28409; jumptable 0000000000028409 default case
lea rsi, jpt_28409
movsxd rcx, ds:(jpt_28409 - 683E0h)[rsi+rdx*4]
add rcx, rsi
jmp rcx; switch jump
loc_2840B:
mov rcx, [rsp+78h+var_70]; jumptable 0000000000028409 case 24
movsx eax, byte ptr [rcx+rax]
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss [rsp+78h+var_78], xmm0
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jnz loc_2857D
mov rdi, rbx
mov rdx, rsp
call _ZNSt6vectorIfSaIfEE17_M_realloc_insertIJfEEEvN9__gnu_cxx17__normal_iteratorIPfS1_EEDpOT_; std::vector<float>::_M_realloc_insert<float>(__gnu_cxx::__normal_iterator<float *,std::vector<float>>,float &&)
jmp loc_28589
def_28409:
test ecx, ecx; jumptable 0000000000028409 default case
jz loc_2856A
cmp ecx, 1
jnz short loc_2847C; jumptable 0000000000028409 cases 28,29
mov rcx, [rsp+78h+var_70]
movzx edi, word ptr [rcx+rax]
call _ggml_fp16_to_fp32
movss [rsp+78h+var_78], xmm0
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jnz loc_2857D
mov rdi, rbx
mov rdx, rsp
call _ZNSt6vectorIfSaIfEE17_M_realloc_insertIJfEEEvN9__gnu_cxx17__normal_iteratorIPfS1_EEDpOT_; std::vector<float>::_M_realloc_insert<float>(__gnu_cxx::__normal_iterator<float *,std::vector<float>>,float &&)
jmp loc_28589
loc_2847C:
cmp [rsp+78h+var_71], 0; jumptable 0000000000028409 cases 28,29
jz loc_2861F
add rax, [rsp+78h+var_70]
mov rsi, [rsp+78h+var_50]
mov rdi, rax
mov rdx, r12
mov rax, [rsp+78h+var_38]
call qword ptr [rax+28h]
mov rsi, [rbx+8]
mov rdx, [rsp+78h+var_50]
mov rcx, [rsp+78h+var_48]
mov rdi, rbx
call _ZNSt6vectorIfSaIfEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPfS1_EEEEvS6_T_S7_St20forward_iterator_tag; std::vector<float>::_M_range_insert<__gnu_cxx::__normal_iterator<float *,std::vector<float>>>(__gnu_cxx::__normal_iterator<float *,std::vector<float>>,__gnu_cxx::__normal_iterator<float *,std::vector<float>>,__gnu_cxx::__normal_iterator<float *,std::vector<float>>,std::forward_iterator_tag)
jmp loc_28589
loc_284BA:
mov rcx, [rsp+78h+var_70]; jumptable 0000000000028409 case 25
movsx eax, word ptr [rcx+rax]
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss [rsp+78h+var_78], xmm0
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jnz loc_2857D
mov rdi, rbx
mov rdx, rsp
call _ZNSt6vectorIfSaIfEE17_M_realloc_insertIJfEEEvN9__gnu_cxx17__normal_iteratorIPfS1_EEDpOT_; std::vector<float>::_M_realloc_insert<float>(__gnu_cxx::__normal_iterator<float *,std::vector<float>>,float &&)
jmp loc_28589
loc_284ED:
mov rcx, [rsp+78h+var_70]; jumptable 0000000000028409 case 26
xorps xmm0, xmm0
cvtsi2ss xmm0, dword ptr [rcx+rax]
movss [rsp+78h+var_78], xmm0
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jnz short loc_2857D
mov rdi, rbx
mov rdx, rsp
call _ZNSt6vectorIfSaIfEE17_M_realloc_insertIJfEEEvN9__gnu_cxx17__normal_iteratorIPfS1_EEDpOT_; std::vector<float>::_M_realloc_insert<float>(__gnu_cxx::__normal_iterator<float *,std::vector<float>>,float &&)
jmp short loc_28589
loc_28516:
mov rcx, [rsp+78h+var_70]; jumptable 0000000000028409 case 27
xorps xmm0, xmm0
cvtsi2ss xmm0, qword ptr [rcx+rax]
movss [rsp+78h+var_78], xmm0
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jnz short loc_2857D
mov rdi, rbx
mov rdx, rsp
call _ZNSt6vectorIfSaIfEE17_M_realloc_insertIJfEEEvN9__gnu_cxx17__normal_iteratorIPfS1_EEDpOT_; std::vector<float>::_M_realloc_insert<float>(__gnu_cxx::__normal_iterator<float *,std::vector<float>>,float &&)
jmp short loc_28589
loc_28540:
mov rcx, [rsp+78h+var_70]; jumptable 0000000000028409 case 30
movzx edi, word ptr [rcx+rax]
call _ggml_bf16_to_fp32
movss [rsp+78h+var_78], xmm0
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jnz short loc_2857D
mov rdi, rbx
mov rdx, rsp
call _ZNSt6vectorIfSaIfEE17_M_realloc_insertIJfEEEvN9__gnu_cxx17__normal_iteratorIPfS1_EEDpOT_; std::vector<float>::_M_realloc_insert<float>(__gnu_cxx::__normal_iterator<float *,std::vector<float>>,float &&)
jmp short loc_28589
loc_2856A:
add rax, [rsp+78h+var_70]
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jz short loc_2859B
movss xmm0, dword ptr [rax]
loc_2857D:
movss dword ptr [rsi], xmm0
add rsi, 4
mov [rbx+8], rsi
loc_28589:
add r15, r12
mov rax, [r14+10h]
cmp r15, rax
jl loc_283C0
jmp short loc_285A8
loc_2859B:
mov rdi, rbx
mov rdx, rax
call _ZNSt6vectorIfSaIfEE17_M_realloc_insertIJRKfEEEvN9__gnu_cxx17__normal_iteratorIPfS1_EEDpOT_; std::vector<float>::_M_realloc_insert<float const&>(__gnu_cxx::__normal_iterator<float *,std::vector<float>>,float const&)
jmp short loc_28589
loc_285A8:
mov rcx, [r14+18h]
loc_285AC:
inc r13
cmp r13, rcx
jl loc_283B4
mov rax, [r14+20h]
loc_285BC:
inc rbp
cmp rbp, rax
jl loc_283A4
mov rcx, [r14+28h]
loc_285CC:
mov rsi, [rsp+78h+var_58]
inc rsi
mov [rsp+78h+var_58], rsi
cmp rsi, rcx
jl loc_28395
loc_285E2:
mov rdi, [rsp+78h+var_50]; void *
test rdi, rdi
jz short loc_285F9
mov rsi, [rsp+78h+var_40]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_285F9:
mov rdi, [rsp+78h+var_70]; void *
test rdi, rdi
jz short loc_28610
mov rsi, [rsp+78h+var_60]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_28610:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2861F:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aFatalError; "fatal error"
mov esi, 0A6h
xor eax, eax
call _ggml_abort
jmp short loc_28661
jmp short loc_28647
jmp short loc_28647
jmp short loc_28647
jmp short loc_28647
jmp short loc_2864C
jmp short loc_2864C
loc_28647:
mov r14, rax
jmp short loc_2867B
loc_2864C:
mov r14, rax
jmp short loc_28692
jmp short loc_28661
jmp short loc_28661
jmp short loc_28661
jmp short loc_28661
jmp short loc_28661
jmp short loc_28661
jmp short loc_28661
jmp short $+2
loc_28661:
mov r14, rax
mov rdi, [rsp+78h+var_50]; void *
test rdi, rdi
jz short loc_2867B
mov rsi, [rsp+78h+var_40]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2867B:
mov rdi, [rsp+78h+var_70]; void *
test rdi, rdi
jz short loc_28692
mov rsi, [rsp+78h+var_60]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_28692:
mov rdi, [rbx]; void *
test rdi, rdi
jz short loc_286A6
mov rsi, [rbx+10h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_286A6:
mov rdi, r14
call __Unwind_Resume
|
void tensor_to_float(long long a1, unsigned int *a2)
{
long long v3; // rax
long long v4; // rax
void *v5; // r15
long long v6; // rax
unsigned long long v7; // r12
long long v8; // rsi
long long v9; // rcx
long long v10; // rax
long long v11; // rcx
long long v12; // rbp
long long v13; // rax
long long v14; // r13
long long v15; // r15
unsigned long long v16; // rax
int v17; // ecx
float v18; // xmm0_4
float *v19; // rsi
float *v20; // rax
long long v21; // r14
float v22; // [rsp+0h] [rbp-78h] BYREF
char is_quantized; // [rsp+7h] [rbp-71h]
void *v24; // [rsp+8h] [rbp-70h] BYREF
long long v25; // [rsp+18h] [rbp-60h]
long long v26; // [rsp+20h] [rbp-58h]
void *v27[2]; // [rsp+28h] [rbp-50h] BYREF
long long v28; // [rsp+38h] [rbp-40h]
long long type_traits; // [rsp+40h] [rbp-38h]
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v3 = ggml_nelements(a2);
std::vector<float>::reserve(a1, v3);
v4 = ggml_nbytes(a2);
std::vector<unsigned char>::vector(&v24, v4, v27);
v5 = v24;
v6 = ggml_nbytes(a2);
ggml_backend_tensor_get(a2, v5, 0LL, v6);
type_traits = ggml_get_type_traits(*a2);
v7 = ggml_blck_size(*a2);
v8 = ggml_blck_size(*a2);
std::vector<float>::vector(v27, v8, &v22);
is_quantized = ggml_is_quantized(*a2);
v9 = *((_QWORD *)a2 + 5);
if ( v9 <= 0 )
goto LABEL_37;
v10 = *((_QWORD *)a2 + 4);
v26 = 0LL;
LABEL_3:
if ( v10 <= 0 )
goto LABEL_36;
v11 = *((_QWORD *)a2 + 3);
v12 = 0LL;
LABEL_5:
if ( v11 <= 0 )
goto LABEL_34;
v13 = *((_QWORD *)a2 + 2);
v14 = 0LL;
LABEL_7:
if ( v13 <= 0 )
goto LABEL_32;
v15 = 0LL;
while ( 2 )
{
v16 = v26 * *((_QWORD *)a2 + 9)
+ v12 * *((_QWORD *)a2 + 8)
+ v14 * *((_QWORD *)a2 + 7)
+ *((_QWORD *)a2 + 6) * (v15 / v7);
v17 = *a2;
switch ( *a2 )
{
case 0x18u:
v18 = (float)*((char *)v24 + v16);
v22 = v18;
v19 = *(float **)(a1 + 8);
if ( v19 != *(float **)(a1 + 16) )
goto LABEL_28;
goto LABEL_25;
case 0x19u:
v18 = (float)*(__int16 *)((char *)v24 + v16);
v22 = v18;
v19 = *(float **)(a1 + 8);
if ( v19 == *(float **)(a1 + 16) )
goto LABEL_25;
goto LABEL_28;
case 0x1Au:
v18 = (float)*(int *)((char *)v24 + v16);
v22 = v18;
v19 = *(float **)(a1 + 8);
if ( v19 == *(float **)(a1 + 16) )
goto LABEL_25;
goto LABEL_28;
case 0x1Bu:
v18 = (float)(int)*(_QWORD *)((char *)v24 + v16);
v22 = v18;
v19 = *(float **)(a1 + 8);
if ( v19 == *(float **)(a1 + 16) )
goto LABEL_25;
goto LABEL_28;
case 0x1Cu:
case 0x1Du:
goto LABEL_16;
case 0x1Eu:
v18 = ggml_bf16_to_fp32(*(unsigned __int16 *)((char *)v24 + v16));
v22 = v18;
v19 = *(float **)(a1 + 8);
if ( v19 == *(float **)(a1 + 16) )
goto LABEL_25;
goto LABEL_28;
default:
if ( v17 )
{
if ( v17 == 1 )
{
v18 = ggml_fp16_to_fp32(*(unsigned __int16 *)((char *)v24 + v16));
v22 = v18;
v19 = *(float **)(a1 + 8);
if ( v19 == *(float **)(a1 + 16) )
{
LABEL_25:
std::vector<float>::_M_realloc_insert<float>(a1, v19, &v22);
goto LABEL_29;
}
goto LABEL_28;
}
LABEL_16:
if ( !is_quantized )
{
v21 = ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/tests/test-backend-ops.cpp",
166LL,
"fatal error");
if ( v27[0] )
operator delete(v27[0], v28 - (unsigned long long)v27[0]);
if ( v24 )
operator delete(v24, v25 - (_QWORD)v24);
if ( *(_QWORD *)a1 )
operator delete(*(void **)a1, *(_QWORD *)(a1 + 16) - *(_QWORD *)a1);
_Unwind_Resume(v21);
}
(*(void ( **)(char *, void *, unsigned long long))(type_traits + 40))((char *)v24 + v16, v27[0], v7);
std::vector<float>::_M_range_insert<__gnu_cxx::__normal_iterator<float *,std::vector<float>>>(
a1,
*(_QWORD *)(a1 + 8),
v27[0],
v27[1]);
}
else
{
v20 = (float *)((char *)v24 + v16);
v19 = *(float **)(a1 + 8);
if ( v19 != *(float **)(a1 + 16) )
{
v18 = *v20;
LABEL_28:
*v19 = v18;
*(_QWORD *)(a1 + 8) = v19 + 1;
goto LABEL_29;
}
std::vector<float>::_M_realloc_insert<float const&>(a1, v19, v20);
}
LABEL_29:
v15 += v7;
v13 = *((_QWORD *)a2 + 2);
if ( v15 < v13 )
continue;
v11 = *((_QWORD *)a2 + 3);
LABEL_32:
if ( ++v14 < v11 )
goto LABEL_7;
v10 = *((_QWORD *)a2 + 4);
LABEL_34:
if ( ++v12 < v10 )
goto LABEL_5;
v9 = *((_QWORD *)a2 + 5);
LABEL_36:
if ( ++v26 < v9 )
goto LABEL_3;
LABEL_37:
if ( v27[0] )
operator delete(v27[0], v28 - (unsigned long long)v27[0]);
if ( v24 )
operator delete(v24, v25 - (_QWORD)v24);
return;
}
}
}
|
tensor_to_float:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
LAB_001282f5:
MOV RDI,RSI
CALL 0x0011cb00
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001671ee
LAB_00128308:
MOV RDI,R14
CALL 0x0011cbb0
LAB_00128310:
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x28]
MOV RSI,RAX
CALL 0x0012bcf0
MOV R15,qword ptr [RSP + 0x8]
LAB_00128327:
MOV RDI,R14
CALL 0x0011cbb0
MOV RDI,R14
MOV RSI,R15
XOR EDX,EDX
MOV RCX,RAX
CALL 0x0011ccf0
MOV EDI,dword ptr [R14]
LAB_00128342:
CALL 0x0011c3c0
MOV qword ptr [RSP + 0x40],RAX
MOV EDI,dword ptr [R14]
LAB_0012834f:
CALL 0x0011ce80
MOV R12,RAX
MOV EDI,dword ptr [R14]
LAB_0012835a:
CALL 0x0011ce80
LAB_0012835f:
LEA RDI,[RSP + 0x28]
MOV RDX,RSP
MOV RSI,RAX
CALL 0x0012b93c
MOV EDI,dword ptr [R14]
LAB_00128372:
CALL 0x0011c0e0
MOV byte ptr [RSP + 0x7],AL
MOV RCX,qword ptr [R14 + 0x28]
TEST RCX,RCX
JLE 0x001285e2
MOV RAX,qword ptr [R14 + 0x20]
MOV qword ptr [RSP + 0x20],0x0
LAB_00128395:
TEST RAX,RAX
JLE 0x001285cc
MOV RCX,qword ptr [R14 + 0x18]
XOR EBP,EBP
LAB_001283a4:
TEST RCX,RCX
JLE 0x001285bc
MOV RAX,qword ptr [R14 + 0x10]
XOR R13D,R13D
LAB_001283b4:
TEST RAX,RAX
JLE 0x001285ac
XOR R15D,R15D
LAB_001283c0:
MOV RAX,qword ptr [R14 + 0x48]
IMUL RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [R14 + 0x40]
IMUL RCX,RBP
ADD RCX,RAX
MOV RSI,qword ptr [R14 + 0x38]
IMUL RSI,R13
ADD RSI,RCX
MOV RAX,R15
XOR EDX,EDX
DIV R12
IMUL RAX,qword ptr [R14 + 0x30]
ADD RAX,RSI
MOV ECX,dword ptr [R14]
LEA EDX,[RCX + -0x18]
CMP EDX,0x6
JA 0x0012843e
LEA RSI,[0x1683e0]
MOVSXD RCX,dword ptr [RSI + RDX*0x4]
ADD RCX,RSI
switchD:
JMP RCX
caseD_18:
MOV RCX,qword ptr [RSP + 0x8]
MOVSX EAX,byte ptr [RCX + RAX*0x1]
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS dword ptr [RSP],XMM0
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JNZ 0x0012857d
LAB_0012842e:
MOV RDI,RBX
MOV RDX,RSP
CALL 0x0016728a
JMP 0x00128589
default:
TEST ECX,ECX
JZ 0x0012856a
CMP ECX,0x1
JNZ 0x0012847c
MOV RCX,qword ptr [RSP + 0x8]
MOVZX EDI,word ptr [RCX + RAX*0x1]
LAB_00128454:
CALL 0x0011c320
MOVSS dword ptr [RSP],XMM0
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JNZ 0x0012857d
MOV RDI,RBX
MOV RDX,RSP
CALL 0x0016728a
JMP 0x00128589
caseD_1c:
CMP byte ptr [RSP + 0x7],0x0
JZ 0x0012861f
ADD RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x28]
LAB_00128491:
MOV RDI,RAX
MOV RDX,R12
MOV RAX,qword ptr [RSP + 0x40]
CALL qword ptr [RAX + 0x28]
MOV RSI,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x30]
LAB_001284ad:
MOV RDI,RBX
CALL 0x0016748e
JMP 0x00128589
caseD_19:
MOV RCX,qword ptr [RSP + 0x8]
MOVSX EAX,word ptr [RCX + RAX*0x1]
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS dword ptr [RSP],XMM0
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JNZ 0x0012857d
LAB_001284dd:
MOV RDI,RBX
MOV RDX,RSP
CALL 0x0016728a
JMP 0x00128589
caseD_1a:
MOV RCX,qword ptr [RSP + 0x8]
XORPS XMM0,XMM0
CVTSI2SS XMM0,dword ptr [RCX + RAX*0x1]
MOVSS dword ptr [RSP],XMM0
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JNZ 0x0012857d
LAB_00128509:
MOV RDI,RBX
MOV RDX,RSP
CALL 0x0016728a
JMP 0x00128589
caseD_1b:
MOV RCX,qword ptr [RSP + 0x8]
XORPS XMM0,XMM0
CVTSI2SS XMM0,qword ptr [RCX + RAX*0x1]
MOVSS dword ptr [RSP],XMM0
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JNZ 0x0012857d
LAB_00128533:
MOV RDI,RBX
MOV RDX,RSP
CALL 0x0016728a
JMP 0x00128589
caseD_1e:
MOV RCX,qword ptr [RSP + 0x8]
MOVZX EDI,word ptr [RCX + RAX*0x1]
LAB_00128549:
CALL 0x0011cea0
MOVSS dword ptr [RSP],XMM0
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JNZ 0x0012857d
MOV RDI,RBX
MOV RDX,RSP
CALL 0x0016728a
JMP 0x00128589
LAB_0012856a:
ADD RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JZ 0x0012859b
MOVSS XMM0,dword ptr [RAX]
LAB_0012857d:
MOVSS dword ptr [RSI],XMM0
ADD RSI,0x4
MOV qword ptr [RBX + 0x8],RSI
LAB_00128589:
ADD R15,R12
MOV RAX,qword ptr [R14 + 0x10]
CMP R15,RAX
JL 0x001283c0
JMP 0x001285a8
LAB_0012859b:
MOV RDI,RBX
MOV RDX,RAX
CALL 0x001673ae
JMP 0x00128589
LAB_001285a8:
MOV RCX,qword ptr [R14 + 0x18]
LAB_001285ac:
INC R13
CMP R13,RCX
JL 0x001283b4
MOV RAX,qword ptr [R14 + 0x20]
LAB_001285bc:
INC RBP
CMP RBP,RAX
JL 0x001283a4
MOV RCX,qword ptr [R14 + 0x28]
LAB_001285cc:
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
MOV qword ptr [RSP + 0x20],RSI
CMP RSI,RCX
JL 0x00128395
LAB_001285e2:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x001285f9
MOV RSI,qword ptr [RSP + 0x38]
SUB RSI,RDI
CALL 0x0011c100
LAB_001285f9:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00128610
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x0011c100
LAB_00128610:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012861f:
LEA RDI,[0x168c94]
LEA RDX,[0x168ddc]
MOV ESI,0xa6
XOR EAX,EAX
CALL 0x0011c980
|
/* tensor_to_float(ggml_tensor const*) */
void tensor_to_float(ggml_tensor *param_1)
{
int iVar1;
ulong uVar2;
allocator *paVar3;
long lVar4;
long lVar5;
long lVar6;
int *in_RSI;
float *pfVar7;
long lVar8;
ulong uVar9;
float fVar10;
float local_78;
char local_71;
void *local_70 [2];
long local_60;
long local_58;
void *local_50;
int8 local_48;
long local_40;
long local_38;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
/* try { // try from 001282f5 to 00128307 has its CatchHandler @ 0012864c */
uVar2 = ggml_nelements();
std::vector<float,std::allocator<float>>::reserve
((vector<float,std::allocator<float>> *)param_1,uVar2);
/* try { // try from 00128308 to 0012830f has its CatchHandler @ 00128645 */
paVar3 = (allocator *)ggml_nbytes();
/* try { // try from 00128310 to 00128321 has its CatchHandler @ 00128643 */
std::vector<unsigned_char,std::allocator<unsigned_char>>::vector((ulong)local_70,paVar3);
/* try { // try from 00128327 to 0012833e has its CatchHandler @ 00128647 */
ggml_nbytes();
ggml_backend_tensor_get();
/* try { // try from 00128342 to 0012834b has its CatchHandler @ 00128641 */
local_38 = ggml_get_type_traits(*in_RSI);
/* try { // try from 0012834f to 00128353 has its CatchHandler @ 0012863f */
uVar2 = ggml_blck_size(*in_RSI);
/* try { // try from 0012835a to 0012835e has its CatchHandler @ 0012863d */
paVar3 = (allocator *)ggml_blck_size(*in_RSI);
/* try { // try from 0012835f to 0012836e has its CatchHandler @ 0012863b */
std::vector<float,std::allocator<float>>::vector((ulong)&local_50,paVar3);
/* try { // try from 00128372 to 0012837a has its CatchHandler @ 00128639 */
local_71 = ggml_is_quantized(*in_RSI);
lVar4 = *(long *)(in_RSI + 10);
if (0 < lVar4) {
lVar5 = *(long *)(in_RSI + 8);
local_58 = 0;
do {
if (0 < lVar5) {
lVar4 = *(long *)(in_RSI + 6);
lVar6 = 0;
do {
if (0 < lVar4) {
lVar5 = *(long *)(in_RSI + 4);
lVar8 = 0;
do {
if (0 < lVar5) {
uVar9 = 0;
do {
lVar4 = (uVar9 / uVar2) * *(long *)(in_RSI + 0xc) +
*(long *)(in_RSI + 0xe) * lVar8 +
*(long *)(in_RSI + 0x10) * lVar6 + *(long *)(in_RSI + 0x12) * local_58;
iVar1 = *in_RSI;
switch(iVar1) {
case 0x18:
fVar10 = (float)(int)*(char *)((long)local_70[0] + lVar4);
pfVar7 = *(float **)(param_1 + 8);
local_78 = fVar10;
if (pfVar7 == *(float **)(param_1 + 0x10)) {
/* try { // try from 0012842e to 00128438 has its CatchHandler @ 00128657 */
std::vector<float,std::allocator<float>>::_M_realloc_insert<float>
((vector<float,std::allocator<float>> *)param_1,pfVar7,&local_78);
}
else {
LAB_0012857d:
*pfVar7 = fVar10;
*(float **)(param_1 + 8) = pfVar7 + 1;
}
break;
case 0x19:
fVar10 = (float)(int)*(short *)((long)local_70[0] + lVar4);
pfVar7 = *(float **)(param_1 + 8);
local_78 = fVar10;
if (pfVar7 != *(float **)(param_1 + 0x10)) goto LAB_0012857d;
/* try { // try from 001284dd to 001284e7 has its CatchHandler @ 00128655 */
std::vector<float,std::allocator<float>>::_M_realloc_insert<float>
((vector<float,std::allocator<float>> *)param_1,pfVar7,&local_78);
break;
case 0x1a:
fVar10 = (float)*(int *)((long)local_70[0] + lVar4);
pfVar7 = *(float **)(param_1 + 8);
local_78 = fVar10;
if (pfVar7 != *(float **)(param_1 + 0x10)) goto LAB_0012857d;
/* try { // try from 00128509 to 00128513 has its CatchHandler @ 00128653 */
std::vector<float,std::allocator<float>>::_M_realloc_insert<float>
((vector<float,std::allocator<float>> *)param_1,pfVar7,&local_78);
break;
case 0x1b:
fVar10 = (float)*(long *)((long)local_70[0] + lVar4);
pfVar7 = *(float **)(param_1 + 8);
local_78 = fVar10;
if (pfVar7 != *(float **)(param_1 + 0x10)) goto LAB_0012857d;
/* try { // try from 00128533 to 0012853d has its CatchHandler @ 00128651 */
std::vector<float,std::allocator<float>>::_M_realloc_insert<float>
((vector<float,std::allocator<float>> *)param_1,pfVar7,&local_78);
break;
case 0x1c:
case 0x1d:
switchD_00128409_caseD_1c:
if (local_71 == '\0') {
/* try { // try from 0012861f to 00128638 has its CatchHandler @ 0012865d */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/tests/test-backend-ops.cpp"
,0xa6,"fatal error");
}
/* try { // try from 00128491 to 0012849e has its CatchHandler @ 00128661 */
(**(code **)(local_38 + 0x28))(lVar4 + (long)local_70[0],local_50,uVar2);
/* try { // try from 001284ad to 001284b4 has its CatchHandler @ 0012865b */
std::vector<float,std::allocator<float>>::
_M_range_insert<__gnu_cxx::__normal_iterator<float*,std::vector<float,std::allocator<float>>>>
(param_1,*(int8 *)(param_1 + 8),local_50,local_48);
break;
case 0x1e:
/* try { // try from 00128549 to 00128567 has its CatchHandler @ 0012865f */
fVar10 = (float)ggml_bf16_to_fp32(*(int2 *)((long)local_70[0] + lVar4));
pfVar7 = *(float **)(param_1 + 8);
local_78 = fVar10;
if (pfVar7 != *(float **)(param_1 + 0x10)) goto LAB_0012857d;
std::vector<float,std::allocator<float>>::_M_realloc_insert<float>
((vector<float,std::allocator<float>> *)param_1,pfVar7,&local_78);
break;
default:
if (iVar1 == 0) {
pfVar7 = *(float **)(param_1 + 8);
if (pfVar7 != *(float **)(param_1 + 0x10)) {
fVar10 = *(float *)(lVar4 + (long)local_70[0]);
goto LAB_0012857d;
}
/* try { // try from 0012859b to 001285a5 has its CatchHandler @ 00128661 */
std::vector<float,std::allocator<float>>::_M_realloc_insert<float_const&>
((vector<float,std::allocator<float>> *)param_1,pfVar7,
(float *)(lVar4 + (long)local_70[0]));
}
else {
if (iVar1 != 1) goto switchD_00128409_caseD_1c;
/* try { // try from 00128454 to 00128476 has its CatchHandler @ 00128659 */
fVar10 = (float)ggml_fp16_to_fp32(*(int2 *)((long)local_70[0] + lVar4));
pfVar7 = *(float **)(param_1 + 8);
local_78 = fVar10;
if (pfVar7 != *(float **)(param_1 + 0x10)) goto LAB_0012857d;
std::vector<float,std::allocator<float>>::_M_realloc_insert<float>
((vector<float,std::allocator<float>> *)param_1,pfVar7,&local_78);
}
}
uVar9 = uVar9 + uVar2;
lVar5 = *(long *)(in_RSI + 4);
} while ((long)uVar9 < lVar5);
lVar4 = *(long *)(in_RSI + 6);
}
lVar8 = lVar8 + 1;
} while (lVar8 < lVar4);
lVar5 = *(long *)(in_RSI + 8);
}
lVar6 = lVar6 + 1;
} while (lVar6 < lVar5);
lVar4 = *(long *)(in_RSI + 10);
}
local_58 = local_58 + 1;
} while (local_58 < lVar4);
}
if (local_50 != (void *)0x0) {
operator_delete(local_50,local_40 - (long)local_50);
}
if (local_70[0] != (void *)0x0) {
operator_delete(local_70[0],local_60 - (long)local_70[0]);
}
return;
}
|
|
11,315 |
test_if_hard_path
|
eloqsql/mysys/my_getwd.c
|
int test_if_hard_path(register const char *dir_name)
{
if (dir_name[0] == FN_HOMELIB && dir_name[1] == FN_LIBCHAR)
return (home_dir != NullS && test_if_hard_path(home_dir));
if (dir_name[0] == FN_LIBCHAR)
return (TRUE);
#ifdef FN_DEVCHAR
return (strchr(dir_name,FN_DEVCHAR) != 0);
#else
return FALSE;
#endif
}
|
O0
|
c
|
test_if_hard_path:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0x2eebc
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x2eebc
xorl %eax, %eax
leaq 0x356e5a(%rip), %rcx # 0x385ce8
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x2eeaf
leaq 0x356e4a(%rip), %rax # 0x385ce8
movq (%rax), %rdi
callq 0x2ee60
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x2eed8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x2eed1
movl $0x1, -0x4(%rbp)
jmp 0x2eed8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
test_if_hard_path:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 7Eh ; '~'
jnz short loc_2EEBC
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
cmp eax, 2Fh ; '/'
jnz short loc_2EEBC
xor eax, eax
lea rcx, home_dir
cmp qword ptr [rcx], 0
mov [rbp+var_11], al
jz short loc_2EEAF
lea rax, home_dir
mov rdi, [rax]
call test_if_hard_path
cmp eax, 0
setnz al
mov [rbp+var_11], al
loc_2EEAF:
mov al, [rbp+var_11]
and al, 1
movzx eax, al
mov [rbp+var_4], eax
jmp short loc_2EED8
loc_2EEBC:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_2EED1
mov [rbp+var_4], 1
jmp short loc_2EED8
loc_2EED1:
mov [rbp+var_4], 0
loc_2EED8:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
_BOOL8 test_if_hard_path(char *a1)
{
bool v2; // [rsp+Fh] [rbp-11h]
if ( *a1 == 126 && a1[1] == 47 )
{
v2 = 0;
if ( home_dir )
return (unsigned int)test_if_hard_path(home_dir) != 0;
return v2;
}
else
{
return *a1 == 47;
}
}
|
test_if_hard_path:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7e
JNZ 0x0012eebc
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x2f
JNZ 0x0012eebc
XOR EAX,EAX
LEA RCX,[0x485ce8]
CMP qword ptr [RCX],0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x0012eeaf
LEA RAX,[0x485ce8]
MOV RDI,qword ptr [RAX]
CALL 0x0012ee60
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x11],AL
LAB_0012eeaf:
MOV AL,byte ptr [RBP + -0x11]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0012eed8
LAB_0012eebc:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x0012eed1
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0012eed8
LAB_0012eed1:
MOV dword ptr [RBP + -0x4],0x0
LAB_0012eed8:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
bool test_if_hard_path(char *param_1)
{
int iVar1;
bool local_19;
if ((*param_1 == '~') && (param_1[1] == '/')) {
local_19 = false;
if (home_dir != 0) {
iVar1 = test_if_hard_path(home_dir);
local_19 = iVar1 != 0;
}
}
else if (*param_1 == '/') {
local_19 = true;
}
else {
local_19 = false;
}
return local_19;
}
|
|
11,316 |
lodepng_color_stats_init(LodePNGColorStats*)
|
aimrt_mujoco_sim/_deps/lodepng-src/lodepng.cpp
|
void lodepng_color_stats_init(LodePNGColorStats* stats) {
/*stats*/
stats->colored = 0;
stats->key = 0;
stats->key_r = stats->key_g = stats->key_b = 0;
stats->alpha = 0;
stats->numcolors = 0;
stats->bits = 1;
stats->numpixels = 0;
/*settings*/
stats->allow_palette = 1;
stats->allow_greyscale = 1;
}
|
O0
|
cpp
|
lodepng_color_stats_init(LodePNGColorStats*):
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rsp), %rax
movw $0x0, 0xc(%rax)
movq -0x8(%rsp), %rax
movw $0x0, 0xa(%rax)
movq -0x8(%rsp), %rax
movw $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x418(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x420(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x428(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x42c(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_Z24lodepng_color_stats_initP17LodePNGColorStats:
mov [rsp+var_8], rdi
mov rax, [rsp+var_8]
mov dword ptr [rax], 0
mov rax, [rsp+var_8]
mov dword ptr [rax+4], 0
mov rax, [rsp+var_8]
mov word ptr [rax+0Ch], 0
mov rax, [rsp+var_8]
mov word ptr [rax+0Ah], 0
mov rax, [rsp+var_8]
mov word ptr [rax+8], 0
mov rax, [rsp+var_8]
mov dword ptr [rax+10h], 0
mov rax, [rsp+var_8]
mov dword ptr [rax+14h], 0
mov rax, [rsp+var_8]
mov dword ptr [rax+418h], 1
mov rax, [rsp+var_8]
mov qword ptr [rax+420h], 0
mov rax, [rsp+var_8]
mov dword ptr [rax+428h], 1
mov rax, [rsp+var_8]
mov dword ptr [rax+42Ch], 1
retn
|
long long lodepng_color_stats_init(long long a1)
{
long long result; // rax
*(_DWORD *)a1 = 0;
*(_DWORD *)(a1 + 4) = 0;
*(_WORD *)(a1 + 12) = 0;
*(_WORD *)(a1 + 10) = 0;
*(_WORD *)(a1 + 8) = 0;
*(_DWORD *)(a1 + 16) = 0;
*(_DWORD *)(a1 + 20) = 0;
*(_DWORD *)(a1 + 1048) = 1;
*(_QWORD *)(a1 + 1056) = 0LL;
*(_DWORD *)(a1 + 1064) = 1;
result = a1;
*(_DWORD *)(a1 + 1068) = 1;
return result;
}
|
_M_rightmost:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
ADD RAX,0x8
ADD RAX,0x18
RET
|
/* std::_Rb_tree<int, std::pair<int const, std::__cxx11::string >, std::_Select1st<std::pair<int
const, std::__cxx11::string > >, std::less<int>, std::allocator<std::pair<int const,
std::__cxx11::string > > >::_M_rightmost() */
_Rb_tree<int,std::pair<int_const,std::__cxx11::string>,std::_Select1st<std::pair<int_const,std::__cxx11::string>>,std::less<int>,std::allocator<std::pair<int_const,std::__cxx11::string>>>
* __thiscall
std::
_Rb_tree<int,std::pair<int_const,std::__cxx11::string>,std::_Select1st<std::pair<int_const,std::__cxx11::string>>,std::less<int>,std::allocator<std::pair<int_const,std::__cxx11::string>>>
::_M_rightmost(_Rb_tree<int,std::pair<int_const,std::__cxx11::string>,std::_Select1st<std::pair<int_const,std::__cxx11::string>>,std::less<int>,std::allocator<std::pair<int_const,std::__cxx11::string>>>
*this)
{
return this + 0x20;
}
|
|
11,317 |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&)
|
giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc
|
void JsonUnitTestResultPrinter::PrintJsonTestList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
int total_tests = 0;
for (auto test_suite : test_suites) {
total_tests += test_suite->total_test_count();
}
OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);
OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
*stream << kIndent << "\"" << kTestsuites << "\": [\n";
for (size_t i = 0; i < test_suites.size(); ++i) {
if (i != 0) {
*stream << ",\n";
}
PrintJsonTestSuite(stream, *test_suites[i]);
}
*stream << "\n"
<< kIndent << "]\n"
<< "}\n";
}
|
O1
|
cpp
|
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1695f(%rip), %rsi # 0x435b7
leaq 0x16962(%rip), %rdx # 0x435c1
leaq 0x48(%rsp), %rdi
callq 0x39504
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0x20, %edx
callq 0x85e0
leaq 0x16a23(%rip), %rsi # 0x436b0
movl $0x2, %edx
movq %rbx, %rdi
callq 0x85b0
movq (%r14), %rax
movq 0x8(%r14), %rcx
xorl %ebp, %ebp
cmpq %rcx, %rax
je 0x2ccbf
movq (%rax), %rdx
movq 0x38(%rdx), %rsi
subq 0x30(%rdx), %rsi
shrq $0x3, %rsi
addl %esi, %ebp
addq $0x8, %rax
jmp 0x2cca3
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1594b(%rip), %rsi # 0x4261a
leaq 0x15949(%rip), %rdx # 0x4261f
leaq 0x8(%rsp), %rdi
callq 0x39504
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %r8
movq %rbx, %rdi
movl %ebp, %ecx
movl $0x1, %r9d
callq 0x294f2
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2cd16
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x167eb(%rip), %rsi # 0x43510
leaq 0x167e8(%rip), %rdx # 0x43514
callq 0x39504
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x168a9(%rip), %rsi # 0x435ea
leaq 0x168aa(%rip), %rdx # 0x435f2
leaq 0x68(%rsp), %rdi
callq 0x39504
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x68(%rsp), %rcx
leaq 0x28(%rsp), %r8
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x292ea
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2cd8b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2cda2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x85b0
movq %rax, %r15
leaq 0x1692d(%rip), %rsi # 0x436eb
movl $0x1, %edx
movq %rax, %rdi
callq 0x85b0
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r15, %rdi
callq 0x85b0
leaq 0x1689d(%rip), %rsi # 0x43681
movl $0x5, %edx
movq %rax, %rdi
callq 0x85b0
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x2ce3a
xorl %ebp, %ebp
leaq 0x168c2(%rip), %r15 # 0x436c5
testq %rbp, %rbp
je 0x2ce18
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x85b0
movq (%r14), %rax
movq (%rax,%rbp,8), %rsi
movq %rbx, %rdi
callq 0x2c518
incq %rbp
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
cmpq %rax, %rbp
jb 0x2ce03
leaq 0x1649c(%rip), %rsi # 0x432dd
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85b0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x85b0
movq %rax, %rbx
leaq 0x1681d(%rip), %rsi # 0x43687
movl $0x2, %edx
movq %rax, %rdi
callq 0x85b0
leaq 0x1686f(%rip), %rsi # 0x436ed
movl $0x2, %edx
movq %rbx, %rdi
callq 0x85b0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2cea2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ceb9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x84e0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2ceee
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x2ceee
jmp 0x2ceeb
jmp 0x2cf12
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2cf15
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x2cf15
jmp 0x2cf12
jmp 0x2cf12
movq %rax, %rbx
jmp 0x2cf2c
jmp 0x2cf12
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2cf2c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x2cf43
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rdi
callq 0x8990
nop
|
_ZN7testing8internal25JsonUnitTestResultPrinter17PrintJsonTestListEPSoRKSt6vectorIPNS_9TestSuiteESaIS5_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r14, rsi
mov rbx, rdi
lea r12, [rsp+0B8h+var_60]
mov [r12-10h], r12
lea rsi, aTestsuites; "testsuites"
lea rdx, aTestsuites+0Ah; ""
lea rdi, [rsp+0B8h+var_70]
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 r13, [rsp+0B8h+var_80]
mov [r13-10h], r13
lea rdi, [rsp+0B8h+var_90]
mov esi, 2
mov edx, 20h ; ' '
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
lea rsi, asc_436AE+2; "{\n"
mov edx, 2
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [r14]
mov rcx, [r14+8]
xor ebp, ebp
loc_2CCA3:
cmp rax, rcx
jz short loc_2CCBF
mov rdx, [rax]
mov rsi, [rdx+38h]
sub rsi, [rdx+30h]
shr rsi, 3
add ebp, esi
add rax, 8
jmp short loc_2CCA3
loc_2CCBF:
lea r15, [rsp+0B8h+var_A0]
mov [r15-10h], r15
lea rsi, aAlsoRunDisable+12h; "tests"
lea rdx, aAlsoRunDisable+17h; ""
lea rdi, [rsp+0B8h+var_B0]
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 rsi, [rsp+0B8h+var_70]
lea rdx, [rsp+0B8h+var_B0]
lea r8, [rsp+0B8h+var_90]
mov rdi, rbx
mov ecx, ebp
mov r9d, 1
call _ZN7testing8internal25JsonUnitTestResultPrinter13OutputJsonKeyEPSoRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_iSA_b; testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream *,std::string const&,std::string const&,int,std::string const&,bool)
mov rdi, [rsp+0B8h+var_B0]; void *
cmp rdi, r15
jz short loc_2CD16
mov rsi, [rsp+0B8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2CD16:
lea rdi, [rsp+0B8h+var_B0]
mov [rdi], r15
lea rsi, aClassname+5; "name"
lea rdx, aClassname+9; ""
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 rbp, [rsp+0B8h+var_40]
mov [rbp-10h], rbp
lea rsi, aAlltests; "AllTests"
lea rdx, aAlltests+8; ""
lea rdi, [rsp+0B8h+var_50]
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 rsi, [rsp+0B8h+var_70]
lea rdx, [rsp+0B8h+var_B0]
lea rcx, [rsp+0B8h+var_50]
lea r8, [rsp+0B8h+var_90]
mov rdi, rbx
mov r9d, 1
call _ZN7testing8internal25JsonUnitTestResultPrinter13OutputJsonKeyEPSoRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_SA_SA_b; testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream *,std::string const&,std::string const&,std::string const&,std::string const&,bool)
mov rdi, [rsp+0B8h+var_50]; void *
cmp rdi, rbp
jz short loc_2CD8B
mov rsi, [rsp+0B8h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2CD8B:
mov rdi, [rsp+0B8h+var_B0]; void *
cmp rdi, r15
jz short loc_2CDA2
mov rsi, [rsp+0B8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2CDA2:
mov rsi, [rsp+0B8h+var_90]
mov rdx, [rsp+0B8h+var_88]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r15, rax
lea rsi, aMessage+0Fh; "\""
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rsp+0B8h+var_70]
mov rdx, [rsp+0B8h+var_68]
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aTestsuite_1+0Ah; "\": [\n"
mov edx, 5
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [r14+8]
cmp rax, [r14]
jz short loc_2CE3A
xor ebp, ebp
lea r15, asc_436C4+1; ",\n"
loc_2CE03:
test rbp, rbp
jz short loc_2CE18
mov edx, 2
mov rdi, rbx
mov rsi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_2CE18:
mov rax, [r14]
mov rsi, [rax+rbp*8]; std::ostream *
mov rdi, rbx; this
call _ZN7testing8internal25JsonUnitTestResultPrinter18PrintJsonTestSuiteEPSoRKNS_9TestSuiteE; testing::internal::JsonUnitTestResultPrinter::PrintJsonTestSuite(std::ostream *,testing::TestSuite const&)
inc rbp
mov rax, [r14+8]
sub rax, [r14]
sar rax, 3
cmp rbp, rax
jb short loc_2CE03
loc_2CE3A:
lea rsi, aSFromSSMsTotal+19h; "\n"
mov edx, 1
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rsp+0B8h+var_90]
mov rdx, [rsp+0B8h+var_88]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
lea rsi, asc_43687; "]\n"
mov edx, 2
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_436ED; "}\n"
mov edx, 2
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+0B8h+var_90]; void *
cmp rdi, r13
jz short loc_2CEA2
mov rsi, [rsp+0B8h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2CEA2:
mov rdi, [rsp+0B8h+var_70]; void *
cmp rdi, r12
jz short loc_2CEB9
mov rsi, [rsp+0B8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2CEB9:
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_60]; void *
cmp rdi, rbp
jz short loc_2CEEE
mov rsi, [rsp+arg_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2CEEE
jmp short loc_2CEEB
jmp short loc_2CF12
loc_2CEEB:
mov rbx, rax
loc_2CEEE:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_2CF15
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2CF15
jmp short loc_2CF12
jmp short loc_2CF12
mov rbx, rax
jmp short loc_2CF2C
jmp short $+2
loc_2CF12:
mov rbx, rax
loc_2CF15:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_2CF2C
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2CF2C:
mov rdi, [rsp+arg_40]; void *
cmp rdi, r12
jz short loc_2CF43
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2CF43:
mov rdi, rbx
call __Unwind_Resume
|
void testing::internal::JsonUnitTestResultPrinter::PrintJsonTestList(
testing::internal::JsonUnitTestResultPrinter *this,
long long *a2)
{
long long v2; // rax
int v3; // ebp
long long v4; // r15
long long v5; // rax
const testing::TestSuite *v6; // rdx
unsigned long long v7; // rbp
long long v8; // rbx
void *v9[2]; // [rsp+8h] [rbp-B0h] BYREF
_QWORD v10[2]; // [rsp+18h] [rbp-A0h] BYREF
void *v11; // [rsp+28h] [rbp-90h] BYREF
long long v12; // [rsp+30h] [rbp-88h]
_QWORD v13[2]; // [rsp+38h] [rbp-80h] BYREF
void *v14[2]; // [rsp+48h] [rbp-70h] BYREF
_QWORD v15[2]; // [rsp+58h] [rbp-60h] BYREF
void *v16[2]; // [rsp+68h] [rbp-50h] BYREF
_QWORD v17[8]; // [rsp+78h] [rbp-40h] BYREF
v14[0] = v15;
std::string::_M_construct<char const*>(v14, "testsuites", "");
v11 = v13;
std::string::_M_construct(&v11, 2LL, 32LL);
std::__ostream_insert<char,std::char_traits<char>>(this, "{\n", 2LL);
v2 = *a2;
v3 = 0;
while ( v2 != a2[1] )
{
v3 += (*(_QWORD *)(*(_QWORD *)v2 + 56LL) - *(_QWORD *)(*(_QWORD *)v2 + 48LL)) >> 3;
v2 += 8LL;
}
v9[0] = v10;
std::string::_M_construct<char const*>(v9, "tests", "");
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey((long long)this, (long long *)v14, v9, v3, &v11, 1);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
v9[0] = v10;
std::string::_M_construct<char const*>(v9, "name", "");
v16[0] = v17;
std::string::_M_construct<char const*>(v16, "AllTests", "");
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey((long long)this, (long long *)v14, v9, v16, &v11, 1);
if ( v16[0] != v17 )
operator delete(v16[0], v17[0] + 1LL);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
v4 = std::__ostream_insert<char,std::char_traits<char>>(this, v11, v12);
std::__ostream_insert<char,std::char_traits<char>>(v4, "\"", 1LL);
v5 = std::__ostream_insert<char,std::char_traits<char>>(v4, v14[0], v14[1]);
std::__ostream_insert<char,std::char_traits<char>>(v5, "\": [\n", 5LL);
if ( a2[1] != *a2 )
{
v7 = 0LL;
do
{
if ( v7 )
std::__ostream_insert<char,std::char_traits<char>>(this, ",\n", 2LL);
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestSuite(this, *(std::ostream **)(*a2 + 8 * v7++), v6);
}
while ( v7 < (a2[1] - *a2) >> 3 );
}
std::__ostream_insert<char,std::char_traits<char>>(this, "\n", 1LL);
v8 = std::__ostream_insert<char,std::char_traits<char>>(this, v11, v12);
std::__ostream_insert<char,std::char_traits<char>>(v8, "]\n", 2LL);
std::__ostream_insert<char,std::char_traits<char>>(v8, "}\n", 2LL);
if ( v11 != v13 )
operator delete(v11, v13[0] + 1LL);
if ( v14[0] != v15 )
operator delete(v14[0], v15[0] + 1LL);
}
|
PrintJsonTestList:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RSI
MOV RBX,RDI
LEA R12,[RSP + 0x58]
MOV qword ptr [R12 + -0x10],R12
LEA RSI,[0x1435b7]
LEA RDX,[0x1435c1]
LEA RDI,[RSP + 0x48]
CALL 0x00139504
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
LAB_0012cc72:
LEA RDI,[RSP + 0x28]
MOV ESI,0x2
MOV EDX,0x20
CALL 0x001085e0
LAB_0012cc86:
LEA RSI,[0x1436b0]
MOV EDX,0x2
MOV RDI,RBX
CALL 0x001085b0
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [R14 + 0x8]
XOR EBP,EBP
LAB_0012cca3:
CMP RAX,RCX
JZ 0x0012ccbf
MOV RDX,qword ptr [RAX]
MOV RSI,qword ptr [RDX + 0x38]
SUB RSI,qword ptr [RDX + 0x30]
SHR RSI,0x3
ADD EBP,ESI
ADD RAX,0x8
JMP 0x0012cca3
LAB_0012ccbf:
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0012ccc8:
LEA RSI,[0x14261a]
LEA RDX,[0x14261f]
LEA RDI,[RSP + 0x8]
CALL 0x00139504
LAB_0012cce0:
LEA RSI,[RSP + 0x48]
LEA RDX,[RSP + 0x8]
LEA R8,[RSP + 0x28]
MOV RDI,RBX
MOV ECX,EBP
MOV R9D,0x1
CALL 0x001294f2
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x0012cd16
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_0012cd16:
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI],R15
LAB_0012cd1e:
LEA RSI,[0x143510]
LEA RDX,[0x143514]
CALL 0x00139504
LEA RBP,[RSP + 0x78]
MOV qword ptr [RBP + -0x10],RBP
LAB_0012cd3a:
LEA RSI,[0x1435ea]
LEA RDX,[0x1435f2]
LEA RDI,[RSP + 0x68]
CALL 0x00139504
LAB_0012cd52:
LEA RSI,[RSP + 0x48]
LEA RDX,[RSP + 0x8]
LEA RCX,[RSP + 0x68]
LEA R8,[RSP + 0x28]
MOV RDI,RBX
MOV R9D,0x1
CALL 0x001292ea
MOV RDI,qword ptr [RSP + 0x68]
CMP RDI,RBP
JZ 0x0012cd8b
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x001084e0
LAB_0012cd8b:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x0012cda2
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_0012cda2:
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
LAB_0012cdac:
MOV RDI,RBX
CALL 0x001085b0
MOV R15,RAX
LEA RSI,[0x1436eb]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001085b0
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
MOV RDI,R15
CALL 0x001085b0
LEA RSI,[0x143681]
MOV EDX,0x5
MOV RDI,RAX
CALL 0x001085b0
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [R14]
JZ 0x0012ce3a
XOR EBP,EBP
LEA R15,[0x1436c5]
LAB_0012ce03:
TEST RBP,RBP
JZ 0x0012ce18
LAB_0012ce08:
MOV EDX,0x2
MOV RDI,RBX
MOV RSI,R15
CALL 0x001085b0
LAB_0012ce18:
MOV RAX,qword ptr [R14]
MOV RSI,qword ptr [RAX + RBP*0x8]
MOV RDI,RBX
CALL 0x0012c518
INC RBP
MOV RAX,qword ptr [R14 + 0x8]
SUB RAX,qword ptr [R14]
SAR RAX,0x3
CMP RBP,RAX
JC 0x0012ce03
LAB_0012ce3a:
LEA RSI,[0x1432dd]
MOV EDX,0x1
MOV RDI,RBX
CALL 0x001085b0
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
MOV RDI,RBX
CALL 0x001085b0
MOV RBX,RAX
LEA RSI,[0x143687]
MOV EDX,0x2
MOV RDI,RAX
CALL 0x001085b0
LEA RSI,[0x1436ed]
MOV EDX,0x2
MOV RDI,RBX
CALL 0x001085b0
LAB_0012ce8b:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x0012cea2
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001084e0
LAB_0012cea2:
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R12
JZ 0x0012ceb9
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001084e0
LAB_0012ceb9:
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::JsonUnitTestResultPrinter::PrintJsonTestList(std::ostream*,
std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*> > const&) */
void testing::internal::JsonUnitTestResultPrinter::PrintJsonTestList
(ostream *param_1,vector *param_2)
{
long *plVar1;
ostream *poVar2;
int iVar3;
ulong uVar4;
long *local_b0 [2];
long local_a0 [2];
long *local_90;
long local_88;
long local_80 [2];
long *local_70;
long local_68;
long local_60 [2];
long *local_50 [2];
long local_40 [2];
local_70 = local_60;
std::__cxx11::string::_M_construct<char_const*>(&local_70,"testsuites","");
/* try { // try from 0012cc72 to 0012cc85 has its CatchHandler @ 0012cf0b */
local_90 = local_80;
std::__cxx11::string::_M_construct((ulong)&local_90,'\x02');
/* try { // try from 0012cc86 to 0012cc99 has its CatchHandler @ 0012cf09 */
std::__ostream_insert<char,std::char_traits<char>>(param_1,"{\n",2);
iVar3 = 0;
for (plVar1 = *(long **)param_2; plVar1 != *(long **)(param_2 + 8); plVar1 = plVar1 + 1) {
iVar3 = iVar3 + (int)((ulong)(*(long *)(*plVar1 + 0x38) - *(long *)(*plVar1 + 0x30)) >> 3);
}
/* try { // try from 0012ccc8 to 0012ccdf has its CatchHandler @ 0012cf07 */
local_b0[0] = local_a0;
std::__cxx11::string::_M_construct<char_const*>(local_b0,"tests","");
/* try { // try from 0012cce0 to 0012ccfe has its CatchHandler @ 0012ceeb */
OutputJsonKey(param_1,(string *)&local_70,(string *)local_b0,iVar3,(string *)&local_90,true);
if (local_b0[0] != local_a0) {
operator_delete(local_b0[0],local_a0[0] + 1);
}
local_b0[0] = local_a0;
/* try { // try from 0012cd1e to 0012cd30 has its CatchHandler @ 0012cee9 */
std::__cxx11::string::_M_construct<char_const*>(local_b0,"name","");
/* try { // try from 0012cd3a to 0012cd51 has its CatchHandler @ 0012cee7 */
local_50[0] = local_40;
std::__cxx11::string::_M_construct<char_const*>(local_50,"AllTests","");
/* try { // try from 0012cd52 to 0012cd73 has its CatchHandler @ 0012cecb */
OutputJsonKey(param_1,(string *)&local_70,(string *)local_b0,(string *)local_50,
(string *)&local_90,true);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
if (local_b0[0] != local_a0) {
operator_delete(local_b0[0],local_a0[0] + 1);
}
/* try { // try from 0012cdac to 0012cdf0 has its CatchHandler @ 0012cf10 */
poVar2 = std::__ostream_insert<char,std::char_traits<char>>(param_1,(char *)local_90,local_88);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"\"",1);
poVar2 = std::__ostream_insert<char,std::char_traits<char>>(poVar2,(char *)local_70,local_68);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"\": [\n",5);
if (*(long *)(param_2 + 8) != *(long *)param_2) {
uVar4 = 0;
do {
if (uVar4 != 0) {
/* try { // try from 0012ce08 to 0012ce26 has its CatchHandler @ 0012cf12 */
std::__ostream_insert<char,std::char_traits<char>>(param_1,",\n",2);
}
PrintJsonTestSuite(param_1,*(TestSuite **)(*(long *)param_2 + uVar4 * 8));
uVar4 = uVar4 + 1;
} while (uVar4 < (ulong)(*(long *)(param_2 + 8) - *(long *)param_2 >> 3));
}
/* try { // try from 0012ce3a to 0012ce8a has its CatchHandler @ 0012cf10 */
std::__ostream_insert<char,std::char_traits<char>>(param_1,"\n",1);
poVar2 = std::__ostream_insert<char,std::char_traits<char>>(param_1,(char *)local_90,local_88);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"]\n",2);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"}\n",2);
if (local_90 != local_80) {
operator_delete(local_90,local_80[0] + 1);
}
if (local_70 != local_60) {
operator_delete(local_70,local_60[0] + 1);
}
return;
}
|
|
11,318 |
cs_leave
|
eloqsql/strings/ctype.c
|
static int cs_leave(MY_XML_PARSER *st,const char *attr, size_t len)
{
struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
const struct my_cs_file_section_st *s= cs_file_sec(attr,len);
int state= s ? s->state : 0;
int rc;
switch(state){
case _CS_COLLATION:
if (i->tailoring_length)
i->cs.tailoring= i->tailoring;
rc= i->loader->add_collation ? i->loader->add_collation(&i->cs) : MY_XML_OK;
break;
/* Rules: Logical Reset Positions */
case _CS_RESET_FIRST_NON_IGNORABLE:
rc= tailoring_append(st, "[first non-ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_NON_IGNORABLE:
rc= tailoring_append(st, "[last non-ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[first primary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[last primary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[first secondary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[last secondary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[first tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[last tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TRAILING:
rc= tailoring_append(st, "[first trailing]", 0, NULL);
break;
case _CS_RESET_LAST_TRAILING:
rc= tailoring_append(st, "[last trailing]", 0, NULL);
break;
case _CS_RESET_FIRST_VARIABLE:
rc= tailoring_append(st, "[first variable]", 0, NULL);
break;
case _CS_RESET_LAST_VARIABLE:
rc= tailoring_append(st, "[last variable]", 0, NULL);
break;
default:
rc=MY_XML_OK;
}
return rc;
}
|
O0
|
c
|
cs_leave:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x76e80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x75c76
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x75c7d
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x75c7d
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
subl $0x9, %eax
je 0x75d57
jmp 0x75c94
movl -0x38(%rbp), %eax
subl $0x191, %eax # imm = 0x191
je 0x75e04
jmp 0x75ca4
movl -0x38(%rbp), %eax
subl $0x192, %eax # imm = 0x192
je 0x75e23
jmp 0x75cb4
movl -0x38(%rbp), %eax
subl $0x193, %eax # imm = 0x193
je 0x75e42
jmp 0x75cc4
movl -0x38(%rbp), %eax
subl $0x194, %eax # imm = 0x194
je 0x75e61
jmp 0x75cd4
movl -0x38(%rbp), %eax
subl $0x195, %eax # imm = 0x195
je 0x75e80
jmp 0x75ce4
movl -0x38(%rbp), %eax
subl $0x196, %eax # imm = 0x196
je 0x75e9f
jmp 0x75cf4
movl -0x38(%rbp), %eax
subl $0x197, %eax # imm = 0x197
je 0x75ebb
jmp 0x75d04
movl -0x38(%rbp), %eax
subl $0x198, %eax # imm = 0x198
je 0x75ed7
jmp 0x75d14
movl -0x38(%rbp), %eax
subl $0x199, %eax # imm = 0x199
je 0x75ef3
jmp 0x75d24
movl -0x38(%rbp), %eax
subl $0x19a, %eax # imm = 0x19A
je 0x75f0f
jmp 0x75d34
movl -0x38(%rbp), %eax
subl $0x19b, %eax # imm = 0x19B
je 0x75dc6
jmp 0x75d44
movl -0x38(%rbp), %eax
subl $0x19c, %eax # imm = 0x19C
je 0x75de5
jmp 0x75f2b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x690(%rax)
je 0x75d7b
movq -0x20(%rbp), %rax
movq 0x688(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x718(%rax)
movq -0x20(%rbp), %rax
movq 0x7a8(%rax), %rax
cmpq $0x0, 0xa8(%rax)
je 0x75db4
movq -0x20(%rbp), %rax
movq 0x7a8(%rax), %rax
movq 0xa8(%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x6e0, %rdi # imm = 0x6E0
callq *%rax
movl %eax, -0x3c(%rbp)
jmp 0x75dbb
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x75dbb
movl -0x3c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x10460(%rip), %rsi # 0x86231
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x10457(%rip), %rsi # 0x86247
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x1044d(%rip), %rsi # 0x8625c
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x10448(%rip), %rsi # 0x86276
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x10442(%rip), %rsi # 0x8628f
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x1043f(%rip), %rsi # 0x862ab
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x1043b(%rip), %rsi # 0x862c6
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x10437(%rip), %rsi # 0x862e1
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x10435(%rip), %rsi # 0x862fb
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x1042a(%rip), %rsi # 0x8630c
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x1041e(%rip), %rsi # 0x8631c
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movq -0x8(%rbp), %rdi
leaq 0x10413(%rip), %rsi # 0x8632d
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76f10
movl %eax, -0x30(%rbp)
jmp 0x75f32
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
cs_leave:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov rax, [rax+140h]
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call cs_file_sec
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_75C76
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_34], eax
jmp short loc_75C7D
loc_75C76:
xor eax, eax
mov [rbp+var_34], eax
jmp short $+2
loc_75C7D:
mov eax, [rbp+var_34]
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
mov [rbp+var_38], eax
sub eax, 9
jz loc_75D57
jmp short $+2
loc_75C94:
mov eax, [rbp+var_38]
sub eax, 191h
jz loc_75E04
jmp short $+2
loc_75CA4:
mov eax, [rbp+var_38]
sub eax, 192h
jz loc_75E23
jmp short $+2
loc_75CB4:
mov eax, [rbp+var_38]
sub eax, 193h
jz loc_75E42
jmp short $+2
loc_75CC4:
mov eax, [rbp+var_38]
sub eax, 194h
jz loc_75E61
jmp short $+2
loc_75CD4:
mov eax, [rbp+var_38]
sub eax, 195h
jz loc_75E80
jmp short $+2
loc_75CE4:
mov eax, [rbp+var_38]
sub eax, 196h
jz loc_75E9F
jmp short $+2
loc_75CF4:
mov eax, [rbp+var_38]
sub eax, 197h
jz loc_75EBB
jmp short $+2
loc_75D04:
mov eax, [rbp+var_38]
sub eax, 198h
jz loc_75ED7
jmp short $+2
loc_75D14:
mov eax, [rbp+var_38]
sub eax, 199h
jz loc_75EF3
jmp short $+2
loc_75D24:
mov eax, [rbp+var_38]
sub eax, 19Ah
jz loc_75F0F
jmp short $+2
loc_75D34:
mov eax, [rbp+var_38]
sub eax, 19Bh
jz loc_75DC6
jmp short $+2
loc_75D44:
mov eax, [rbp+var_38]
sub eax, 19Ch
jz loc_75DE5
jmp loc_75F2B
loc_75D57:
mov rax, [rbp+var_20]
cmp qword ptr [rax+690h], 0
jz short loc_75D7B
mov rax, [rbp+var_20]
mov rcx, [rax+688h]
mov rax, [rbp+var_20]
mov [rax+718h], rcx
loc_75D7B:
mov rax, [rbp+var_20]
mov rax, [rax+7A8h]
cmp qword ptr [rax+0A8h], 0
jz short loc_75DB4
mov rax, [rbp+var_20]
mov rax, [rax+7A8h]
mov rax, [rax+0A8h]
mov rdi, [rbp+var_20]
add rdi, 6E0h
call rax
mov [rbp+var_3C], eax
jmp short loc_75DBB
loc_75DB4:
xor eax, eax
mov [rbp+var_3C], eax
jmp short $+2
loc_75DBB:
mov eax, [rbp+var_3C]
mov [rbp+var_30], eax
jmp loc_75F32
loc_75DC6:
mov rdi, [rbp+var_8]
lea rsi, aFirstNonIgnora; "[first non-ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_75F32
loc_75DE5:
mov rdi, [rbp+var_8]
lea rsi, aLastNonIgnorab; "[last non-ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_75F32
loc_75E04:
mov rdi, [rbp+var_8]
lea rsi, aFirstPrimaryIg; "[first primary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_75F32
loc_75E23:
mov rdi, [rbp+var_8]
lea rsi, aLastPrimaryIgn; "[last primary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_75F32
loc_75E42:
mov rdi, [rbp+var_8]
lea rsi, aFirstSecondary; "[first secondary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_75F32
loc_75E61:
mov rdi, [rbp+var_8]
lea rsi, aLastSecondaryI; "[last secondary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_75F32
loc_75E80:
mov rdi, [rbp+var_8]
lea rsi, aFirstTertiaryI; "[first tertiary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_75F32
loc_75E9F:
mov rdi, [rbp+var_8]
lea rsi, aLastTertiaryIg; "[last tertiary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_75F32
loc_75EBB:
mov rdi, [rbp+var_8]
lea rsi, aFirstTrailing; "[first trailing]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_75F32
loc_75ED7:
mov rdi, [rbp+var_8]
lea rsi, aLastTrailing; "[last trailing]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_75F32
loc_75EF3:
mov rdi, [rbp+var_8]
lea rsi, aFirstVariable; "[first variable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_75F32
loc_75F0F:
mov rdi, [rbp+var_8]
lea rsi, aLastVariable; "[last variable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_75F32
loc_75F2B:
mov [rbp+var_30], 0
loc_75F32:
mov eax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
|
long long cs_leave(long long a1, long long a2, long long a3)
{
int v5; // [rsp+Ch] [rbp-34h]
int *v7; // [rsp+18h] [rbp-28h]
_QWORD *v8; // [rsp+20h] [rbp-20h]
v8 = *(_QWORD **)(a1 + 320);
v7 = (int *)cs_file_sec(a2, a3);
if ( v7 )
v5 = *v7;
else
v5 = 0;
switch ( v5 )
{
case 9:
if ( v8[210] )
v8[227] = v8[209];
if ( *(_QWORD *)(v8[245] + 168LL) )
return (unsigned int)(*(long long ( **)(_QWORD *))(v8[245] + 168LL))(v8 + 220);
else
return 0;
case 401:
return (unsigned int)tailoring_append(a1, "[first primary ignorable]", 0LL);
case 402:
return (unsigned int)tailoring_append(a1, "[last primary ignorable]", 0LL);
case 403:
return (unsigned int)tailoring_append(a1, "[first secondary ignorable]", 0LL);
case 404:
return (unsigned int)tailoring_append(a1, "[last secondary ignorable]", 0LL);
case 405:
return (unsigned int)tailoring_append(a1, "[first tertiary ignorable]", 0LL);
case 406:
return (unsigned int)tailoring_append(a1, "[last tertiary ignorable]", 0LL);
case 407:
return (unsigned int)tailoring_append(a1, "[first trailing]", 0LL);
case 408:
return (unsigned int)tailoring_append(a1, "[last trailing]", 0LL);
case 409:
return (unsigned int)tailoring_append(a1, "[first variable]", 0LL);
case 410:
return (unsigned int)tailoring_append(a1, "[last variable]", 0LL);
case 411:
return (unsigned int)tailoring_append(a1, "[first non-ignorable]", 0LL);
case 412:
return (unsigned int)tailoring_append(a1, "[last non-ignorable]", 0LL);
default:
return 0;
}
}
|
cs_leave:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x140]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00176e80
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00175c76
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00175c7d
LAB_00175c76:
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00175c7d
LAB_00175c7d:
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x38],EAX
SUB EAX,0x9
JZ 0x00175d57
JMP 0x00175c94
LAB_00175c94:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x191
JZ 0x00175e04
JMP 0x00175ca4
LAB_00175ca4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x192
JZ 0x00175e23
JMP 0x00175cb4
LAB_00175cb4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x193
JZ 0x00175e42
JMP 0x00175cc4
LAB_00175cc4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x194
JZ 0x00175e61
JMP 0x00175cd4
LAB_00175cd4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x195
JZ 0x00175e80
JMP 0x00175ce4
LAB_00175ce4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x196
JZ 0x00175e9f
JMP 0x00175cf4
LAB_00175cf4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x197
JZ 0x00175ebb
JMP 0x00175d04
LAB_00175d04:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x198
JZ 0x00175ed7
JMP 0x00175d14
LAB_00175d14:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x199
JZ 0x00175ef3
JMP 0x00175d24
LAB_00175d24:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x19a
JZ 0x00175f0f
JMP 0x00175d34
LAB_00175d34:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x19b
JZ 0x00175dc6
JMP 0x00175d44
LAB_00175d44:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x19c
JZ 0x00175de5
JMP 0x00175f2b
LAB_00175d57:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x690],0x0
JZ 0x00175d7b
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x688]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x718],RCX
LAB_00175d7b:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x7a8]
CMP qword ptr [RAX + 0xa8],0x0
JZ 0x00175db4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x7a8]
MOV RAX,qword ptr [RAX + 0xa8]
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x6e0
CALL RAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00175dbb
LAB_00175db4:
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00175dbb
LAB_00175dbb:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175dc6:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x186231]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175de5:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x186247]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175e04:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x18625c]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175e23:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x186276]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175e42:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x18628f]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175e61:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1862ab]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175e80:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1862c6]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175e9f:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1862e1]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175ebb:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1862fb]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175ed7:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x18630c]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175ef3:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x18631c]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175f0f:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x18632d]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x00176f10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175f32
LAB_00175f2b:
MOV dword ptr [RBP + -0x30],0x0
LAB_00175f32:
MOV EAX,dword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
int4 cs_leave(long param_1,int8 param_2,int8 param_3)
{
long lVar1;
int *piVar2;
int4 local_44;
int local_3c;
int4 local_38;
lVar1 = *(long *)(param_1 + 0x140);
piVar2 = (int *)cs_file_sec(param_2,param_3);
if (piVar2 == (int *)0x0) {
local_3c = 0;
}
else {
local_3c = *piVar2;
}
if (local_3c == 9) {
if (*(long *)(lVar1 + 0x690) != 0) {
*(int8 *)(lVar1 + 0x718) = *(int8 *)(lVar1 + 0x688);
}
if (*(long *)(*(long *)(lVar1 + 0x7a8) + 0xa8) == 0) {
local_44 = 0;
}
else {
local_44 = (**(code **)(*(long *)(lVar1 + 0x7a8) + 0xa8))(lVar1 + 0x6e0);
}
local_38 = local_44;
}
else if (local_3c == 0x191) {
local_38 = tailoring_append(param_1,"[first primary ignorable]",0);
}
else if (local_3c == 0x192) {
local_38 = tailoring_append(param_1,"[last primary ignorable]",0);
}
else if (local_3c == 0x193) {
local_38 = tailoring_append(param_1,"[first secondary ignorable]",0);
}
else if (local_3c == 0x194) {
local_38 = tailoring_append(param_1,"[last secondary ignorable]",0);
}
else if (local_3c == 0x195) {
local_38 = tailoring_append(param_1,"[first tertiary ignorable]",0);
}
else if (local_3c == 0x196) {
local_38 = tailoring_append(param_1,"[last tertiary ignorable]",0);
}
else if (local_3c == 0x197) {
local_38 = tailoring_append(param_1,"[first trailing]",0);
}
else if (local_3c == 0x198) {
local_38 = tailoring_append(param_1,"[last trailing]",0);
}
else if (local_3c == 0x199) {
local_38 = tailoring_append(param_1,"[first variable]",0);
}
else if (local_3c == 0x19a) {
local_38 = tailoring_append(param_1,"[last variable]",0);
}
else if (local_3c == 0x19b) {
local_38 = tailoring_append(param_1,"[first non-ignorable]",0);
}
else if (local_3c == 0x19c) {
local_38 = tailoring_append(param_1,"[last non-ignorable]",0);
}
else {
local_38 = 0;
}
return local_38;
}
|
|
11,319 |
cs_leave
|
eloqsql/strings/ctype.c
|
static int cs_leave(MY_XML_PARSER *st,const char *attr, size_t len)
{
struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
const struct my_cs_file_section_st *s= cs_file_sec(attr,len);
int state= s ? s->state : 0;
int rc;
switch(state){
case _CS_COLLATION:
if (i->tailoring_length)
i->cs.tailoring= i->tailoring;
rc= i->loader->add_collation ? i->loader->add_collation(&i->cs) : MY_XML_OK;
break;
/* Rules: Logical Reset Positions */
case _CS_RESET_FIRST_NON_IGNORABLE:
rc= tailoring_append(st, "[first non-ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_NON_IGNORABLE:
rc= tailoring_append(st, "[last non-ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[first primary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[last primary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[first secondary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[last secondary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[first tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[last tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TRAILING:
rc= tailoring_append(st, "[first trailing]", 0, NULL);
break;
case _CS_RESET_LAST_TRAILING:
rc= tailoring_append(st, "[last trailing]", 0, NULL);
break;
case _CS_RESET_FIRST_VARIABLE:
rc= tailoring_append(st, "[first variable]", 0, NULL);
break;
case _CS_RESET_LAST_VARIABLE:
rc= tailoring_append(st, "[last variable]", 0, NULL);
break;
default:
rc=MY_XML_OK;
}
return rc;
}
|
O3
|
c
|
cs_leave:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq 0x140(%rdi), %rbx
leaq 0x29bab8(%rip), %r13 # 0x2f5490
leaq 0x8e90(%rip), %r12 # 0x6286f
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x24180
testl %eax, %eax
jne 0x599f8
cmpb $0x0, (%r12,%r14)
je 0x59a16
movq 0x18(%r13), %r12
addq $0x10, %r13
testq %r12, %r12
jne 0x599df
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%r13), %ecx
leal -0x191(%rcx), %eax
cmpl $0xb, %eax
ja 0x59a41
leaq 0x285bf0(%rip), %rcx # 0x2df61c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xb786(%rip), %rsi # 0x651c2
jmp 0x59aec
cmpl $0x9, %ecx
jne 0x59a05
cmpq $0x0, 0x690(%rbx)
je 0x59a5e
movq 0x688(%rbx), %rax
movq %rax, 0x718(%rbx)
movq 0x7a8(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x59a05
addq $0x6e0, %rbx # imm = 0x6E0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0xb71b(%rip), %rsi # 0x651ad
jmp 0x59aec
leaq 0xb791(%rip), %rsi # 0x6522c
jmp 0x59aec
leaq 0xb7ef(%rip), %rsi # 0x65293
jmp 0x59aec
leaq 0xb748(%rip), %rsi # 0x651f5
jmp 0x59aec
leaq 0xb75b(%rip), %rsi # 0x65211
jmp 0x59aec
leaq 0xb7b3(%rip), %rsi # 0x65272
jmp 0x59aec
leaq 0xb714(%rip), %rsi # 0x651dc
jmp 0x59aec
leaq 0xb776(%rip), %rsi # 0x65247
jmp 0x59aec
leaq 0xb787(%rip), %rsi # 0x65261
jmp 0x59aec
leaq 0xb6b4(%rip), %rsi # 0x65197
jmp 0x59aec
leaq 0xb796(%rip), %rsi # 0x65282
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5a33c
|
cs_leave:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, [rdi+140h]
lea r13, sec
lea r12, aIndexXml+6; "xml"
loc_599DF:
mov rdi, r15
mov rsi, r12
mov rdx, r14
call _strncmp
test eax, eax
jnz short loc_599F8
cmp byte ptr [r12+r14], 0
jz short loc_59A16
loc_599F8:
mov r12, [r13+18h]
add r13, 10h
test r12, r12
jnz short loc_599DF
loc_59A05:
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_59A16:
mov ecx, [r13+0]
lea eax, [rcx-191h]; switch 12 cases
cmp eax, 0Bh
ja short def_59A33; jumptable 0000000000059A33 default case
lea rcx, jpt_59A33
movsxd rax, ds:(jpt_59A33 - 2DF61Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_59A35:
lea rsi, aFirstPrimaryIg; jumptable 0000000000059A33 case 401
jmp loc_59AEC
def_59A33:
cmp ecx, 9; jumptable 0000000000059A33 default case
jnz short loc_59A05
cmp qword ptr [rbx+690h], 0
jz short loc_59A5E
mov rax, [rbx+688h]
mov [rbx+718h], rax
loc_59A5E:
mov rax, [rbx+7A8h]
mov rax, [rax+0A8h]
test rax, rax
jz short loc_59A05
add rbx, 6E0h
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
loc_59A8B:
lea rsi, aLastNonIgnorab; jumptable 0000000000059A33 case 412
jmp short loc_59AEC
loc_59A94:
lea rsi, aFirstTertiaryI; jumptable 0000000000059A33 case 405
jmp short loc_59AEC
loc_59A9D:
lea rsi, aLastVariable; jumptable 0000000000059A33 case 410
jmp short loc_59AEC
loc_59AA6:
lea rsi, aFirstSecondary; jumptable 0000000000059A33 case 403
jmp short loc_59AEC
loc_59AAF:
lea rsi, aLastSecondaryI; jumptable 0000000000059A33 case 404
jmp short loc_59AEC
loc_59AB8:
lea rsi, aLastTrailing; jumptable 0000000000059A33 case 408
jmp short loc_59AEC
loc_59AC1:
lea rsi, aLastPrimaryIgn; jumptable 0000000000059A33 case 402
jmp short loc_59AEC
loc_59ACA:
lea rsi, aLastTertiaryIg; jumptable 0000000000059A33 case 406
jmp short loc_59AEC
loc_59AD3:
lea rsi, aFirstTrailing; jumptable 0000000000059A33 case 407
jmp short loc_59AEC
loc_59ADC:
lea rsi, aFirstNonIgnora; jumptable 0000000000059A33 case 411
jmp short loc_59AEC
loc_59AE5:
lea rsi, aFirstVariable; jumptable 0000000000059A33 case 409
loc_59AEC:
mov rdi, rbx
xor edx, edx
xor ecx, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp tailoring_append
|
long long cs_leave(long long a1, long long a2, long long a3, long long a4)
{
_QWORD *v5; // rbx
char *v6; // r13
char *v7; // r12
long long result; // rax
long long ( *v9)(_QWORD *); // rax
v5 = *(_QWORD **)(a1 + 320);
v6 = (char *)&sec;
v7 = "xml";
while ( (unsigned int)strncmp(a2, v7, a3, a4) || v7[a3] )
{
v7 = (char *)*((_QWORD *)v6 + 3);
v6 += 16;
if ( !v7 )
return 0LL;
}
switch ( *(_DWORD *)v6 )
{
case 0x191:
result = tailoring_append(v5, "[first primary ignorable]", 0LL, 0LL);
break;
case 0x192:
result = tailoring_append(v5, "[last primary ignorable]", 0LL, 0LL);
break;
case 0x193:
result = tailoring_append(v5, "[first secondary ignorable]", 0LL, 0LL);
break;
case 0x194:
result = tailoring_append(v5, "[last secondary ignorable]", 0LL, 0LL);
break;
case 0x195:
result = tailoring_append(v5, "[first tertiary ignorable]", 0LL, 0LL);
break;
case 0x196:
result = tailoring_append(v5, "[last tertiary ignorable]", 0LL, 0LL);
break;
case 0x197:
result = tailoring_append(v5, "[first trailing]", 0LL, 0LL);
break;
case 0x198:
result = tailoring_append(v5, "[last trailing]", 0LL, 0LL);
break;
case 0x199:
result = tailoring_append(v5, "[first variable]", 0LL, 0LL);
break;
case 0x19A:
result = tailoring_append(v5, "[last variable]", 0LL, 0LL);
break;
case 0x19B:
result = tailoring_append(v5, "[first non-ignorable]", 0LL, 0LL);
break;
case 0x19C:
result = tailoring_append(v5, "[last non-ignorable]", 0LL, 0LL);
break;
default:
if ( *(_DWORD *)v6 != 9 )
return 0LL;
if ( v5[210] )
v5[227] = v5[209];
v9 = *(long long ( **)(_QWORD *))(v5[245] + 168LL);
if ( !v9 )
return 0LL;
result = v9(v5 + 220);
break;
}
return result;
}
|
cs_leave:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,qword ptr [RDI + 0x140]
LEA R13,[0x3f5490]
LEA R12,[0x16286f]
LAB_001599df:
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
CALL 0x00124180
TEST EAX,EAX
JNZ 0x001599f8
CMP byte ptr [R12 + R14*0x1],0x0
JZ 0x00159a16
LAB_001599f8:
MOV R12,qword ptr [R13 + 0x18]
ADD R13,0x10
TEST R12,R12
JNZ 0x001599df
LAB_00159a05:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00159a16:
MOV ECX,dword ptr [R13]
LEA EAX,[RCX + -0x191]
CMP EAX,0xb
JA 0x00159a41
LEA RCX,[0x3df61c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_191:
LEA RSI,[0x1651c2]
JMP 0x00159aec
LAB_00159a41:
CMP ECX,0x9
JNZ 0x00159a05
CMP qword ptr [RBX + 0x690],0x0
JZ 0x00159a5e
MOV RAX,qword ptr [RBX + 0x688]
MOV qword ptr [RBX + 0x718],RAX
LAB_00159a5e:
MOV RAX,qword ptr [RBX + 0x7a8]
MOV RAX,qword ptr [RAX + 0xa8]
TEST RAX,RAX
JZ 0x00159a05
ADD RBX,0x6e0
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
caseD_19c:
LEA RSI,[0x1651ad]
JMP 0x00159aec
caseD_195:
LEA RSI,[0x16522c]
JMP 0x00159aec
caseD_19a:
LEA RSI,[0x165293]
JMP 0x00159aec
caseD_193:
LEA RSI,[0x1651f5]
JMP 0x00159aec
caseD_194:
LEA RSI,[0x165211]
JMP 0x00159aec
caseD_198:
LEA RSI,[0x165272]
JMP 0x00159aec
caseD_192:
LEA RSI,[0x1651dc]
JMP 0x00159aec
caseD_196:
LEA RSI,[0x165247]
JMP 0x00159aec
caseD_197:
LEA RSI,[0x165261]
JMP 0x00159aec
caseD_19b:
LEA RSI,[0x165197]
JMP 0x00159aec
caseD_199:
LEA RSI,[0x165282]
LAB_00159aec:
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0015a33c
|
int8 cs_leave(long param_1,char *param_2,size_t param_3)
{
long lVar1;
code *UNRECOVERED_JUMPTABLE;
int iVar2;
int8 uVar3;
char *pcVar4;
int *piVar5;
lVar1 = *(long *)(param_1 + 0x140);
piVar5 = &sec;
pcVar4 = "xml";
while ((iVar2 = strncmp(param_2,pcVar4,param_3), iVar2 != 0 || (pcVar4[param_3] != '\0'))) {
pcVar4 = *(char **)(piVar5 + 6);
piVar5 = piVar5 + 4;
if (pcVar4 == (char *)0x0) {
return 0;
}
}
switch(*piVar5) {
case 0x191:
pcVar4 = "[first primary ignorable]";
break;
case 0x192:
pcVar4 = "[last primary ignorable]";
break;
case 0x193:
pcVar4 = "[first secondary ignorable]";
break;
case 0x194:
pcVar4 = "[last secondary ignorable]";
break;
case 0x195:
pcVar4 = "[first tertiary ignorable]";
break;
case 0x196:
pcVar4 = "[last tertiary ignorable]";
break;
case 0x197:
pcVar4 = "[first trailing]";
break;
case 0x198:
pcVar4 = "[last trailing]";
break;
case 0x199:
pcVar4 = "[first variable]";
break;
case 0x19a:
pcVar4 = "[last variable]";
break;
case 0x19b:
pcVar4 = "[first non-ignorable]";
break;
case 0x19c:
pcVar4 = "[last non-ignorable]";
break;
default:
if (*piVar5 != 9) {
return 0;
}
if (*(long *)(lVar1 + 0x690) != 0) {
*(int8 *)(lVar1 + 0x718) = *(int8 *)(lVar1 + 0x688);
}
UNRECOVERED_JUMPTABLE = *(code **)(*(long *)(lVar1 + 0x7a8) + 0xa8);
if (UNRECOVERED_JUMPTABLE == (code *)0x0) {
return 0;
}
/* WARNING: Could not recover jumptable at 0x00159a89. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar3 = (*UNRECOVERED_JUMPTABLE)(lVar1 + 0x6e0);
return uVar3;
}
uVar3 = tailoring_append(lVar1,pcVar4,0,0);
return uVar3;
}
|
|
11,320 |
translog_buffer_decrease_writers
|
eloqsql/storage/maria/ma_loghandler.c
|
static void translog_buffer_decrease_writers(struct st_translog_buffer *buffer)
{
DBUG_ENTER("translog_buffer_decrease_writers");
translog_buffer_lock_assert_owner(buffer);
buffer->copy_to_buffer_in_progress--;
DBUG_PRINT("info",
("copy_to_buffer_in_progress. Buffer #%u %p progress: %d",
(uint) buffer->buffer_no, buffer,
buffer->copy_to_buffer_in_progress));
if (buffer->copy_to_buffer_in_progress == 0)
mysql_cond_broadcast(&buffer->waiting_filling_buffer);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
translog_buffer_decrease_writers:
decl 0x100078(%rdi)
je 0x4f9ec
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x100070(%rdi), %rdi
addq $0x100040, %rbx # imm = 0x100040
testq %rdi, %rdi
jne 0x4fa16
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x296f0
leaq 0x3365f3(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x178(%rax)
jmp 0x4fa08
|
translog_buffer_decrease_writers:
dec ds:dword_100078[rdi]
jz short loc_4F9EC
retn
loc_4F9EC:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, ds:qword_100070[rdi]
add rbx, 100040h
test rdi, rdi
jnz short loc_4FA16
loc_4FA08:
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp _pthread_cond_broadcast
loc_4FA16:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+178h]
jmp short loc_4FA08
|
long long translog_buffer_decrease_writers(long long a1)
{
long long v3; // rdi
long long v4; // rbx
long long result; // rax
if ( (*(int *)((char *)&dword_100078 + a1))-- == 1 )
{
v3 = *(long long *)((char *)&qword_100070 + a1);
v4 = a1 + 1048640;
if ( v3 )
((void ( *)(long long))PSI_server[47])(v3);
return pthread_cond_broadcast(v4);
}
return result;
}
|
translog_buffer_decrease_writers:
DEC dword ptr [RDI + 0x100078]
JZ 0x0014f9ec
RET
LAB_0014f9ec:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x100070]
ADD RBX,0x100040
TEST RDI,RDI
JNZ 0x0014fa16
LAB_0014fa08:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001296f0
LAB_0014fa16:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x178]
JMP 0x0014fa08
|
void translog_buffer_decrease_writers(long param_1)
{
int *piVar1;
piVar1 = (int *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_type + param_1);
*piVar1 = *piVar1 + -1;
if (*piVar1 != 0) {
return;
}
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[0].p_align + param_1) != 0) {
(**(code **)(PSI_server + 0x178))();
}
pthread_cond_broadcast((pthread_cond_t *)((long)&Elf64_Phdr_ARRAY_00100040[0].p_type + param_1));
return;
}
|
|
11,321 |
Json::Value::Value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
aimrt_mujoco_sim/_deps/jsoncpp-src/src/lib_json/json_value.cpp
|
Value::Value(const String& value) {
initBasic(stringValue, true);
value_.string_ = duplicateAndPrefixStringValue(
value.data(), static_cast<unsigned>(value.length()));
}
|
O3
|
cpp
|
Json::Value::Value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xfffffe00, %eax # imm = 0xFFFFFE00
andl 0x8(%rdi), %eax
leaq 0x10(%rdi), %rbx
orl $0x104, %eax # imm = 0x104
movw %ax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq (%rsi), %rdi
movl 0x8(%rsi), %esi
callq 0x768ed
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x76abc
movq %rbx, %rdi
callq 0x1f740
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x1ffd0
nop
|
_ZN4Json5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
push rax
mov r14, rdi
mov eax, 0FFFFFE00h
and eax, [rdi+8]
lea rbx, [rdi+10h]
or eax, 104h
mov [rdi+8], ax
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
mov qword ptr [rdi+20h], 0
mov rdi, [rsi]; this
mov esi, [rsi+8]; char *
call _ZN4JsonL29duplicateAndPrefixStringValueEPKcj; Json::duplicateAndPrefixStringValue(char const*,uint)
mov [r14], rax
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
mov rsi, [rbx]
test rsi, rsi
jz short loc_76ABC
mov rdi, rbx
call __ZNKSt14default_deleteISt5arrayINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEELm3EEEclEPS7_; std::default_delete<std::array<std::string,3ul>>::operator()(std::array<std::string,3ul>*)
loc_76ABC:
mov qword ptr [rbx], 0
mov rdi, r14
call __Unwind_Resume
|
_DWORD * Json::Value::Value(long long a1, long long a2)
{
_DWORD *result; // rax
*(_WORD *)(a1 + 8) = *(_WORD *)(a1 + 8) & 0xFE00 | 0x104;
*(_OWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 32) = 0LL;
result = Json::duplicateAndPrefixStringValue(*(Json **)a2, (const char *)*(unsigned int *)(a2 + 8));
*(_QWORD *)a1 = result;
return result;
}
|
Value:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV EAX,0xfffffe00
AND EAX,dword ptr [RDI + 0x8]
LEA RBX,[RDI + 0x10]
OR EAX,0x104
MOV word ptr [RDI + 0x8],AX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOV qword ptr [RDI + 0x20],0x0
MOV RDI,qword ptr [RSI]
MOV ESI,dword ptr [RSI + 0x8]
LAB_00176a99:
CALL 0x001768ed
LAB_00176a9e:
MOV qword ptr [R14],RAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* Json::Value::Value(std::__cxx11::string const&) */
void __thiscall Json::Value::Value(Value *this,string *param_1)
{
int8 uVar1;
*(ushort *)(this + 8) = (ushort)*(int4 *)(this + 8) & 0xfe00 | 0x104;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
/* try { // try from 00176a99 to 00176a9d has its CatchHandler @ 00176aa9 */
uVar1 = duplicateAndPrefixStringValue(*(char **)param_1,*(uint *)(param_1 + 8));
*(int8 *)this = uVar1;
return;
}
|
|
11,322 |
dequantize_row_iq4_xs
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c
|
void dequantize_row_iq4_xs(const block_iq4_xs * restrict x, float * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
for (int i = 0; i < nb; i++) {
const uint8_t * qs = x[i].qs;
const float d = GGML_FP16_TO_FP32(x[i].d);
for (int ib = 0; ib < QK_K/32; ++ib) {
const int ls = ((x[i].scales_l[ib/2] >> 4*(ib%2)) & 0xf) | (((x[i].scales_h >> 2*ib) & 3) << 4);
const float dl = d * (ls - 32);
for (int j = 0; j < 16; ++j) {
y[j+ 0] = dl * kvalues_iq4nl[qs[j] & 0xf];
y[j+16] = dl * kvalues_iq4nl[qs[j] >> 4];
}
y += 32;
qs += 16;
}
}
}
|
O0
|
c
|
dequantize_row_iq4_xs:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x100, %ecx # imm = 0x100
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x79fba
jmp 0x79fd9
leaq 0x47183(%rip), %rdi # 0xc1144
leaq 0x46d94(%rip), %rsi # 0xc0d5c
movl $0x997, %edx # imm = 0x997
leaq 0x4788a(%rip), %rcx # 0xc185e
callq 0x44810
movq -0x18(%rbp), %rax
movl $0x100, %ecx # imm = 0x100
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x7a1a5
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movzwl (%rax), %edi
callq 0x6e6e0
movss %xmm0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x8, -0x38(%rbp)
jge 0x7a195
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x50(%rbp), %rax
movslq %ecx, %rcx
movzbl 0x4(%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
movl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x48(%rbp), %eax
movl %edx, %ecx
shll $0x2, %ecx
sarl %cl, %eax
andl $0xf, %eax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
imulq $0x88, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x2(%rcx), %edx
movl -0x38(%rbp), %ecx
shll %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl %eax, -0x3c(%rbp)
movss -0x34(%rbp), %xmm0
movl -0x3c(%rbp), %eax
subl $0x20, %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x10, -0x44(%rbp)
jge 0x7a16d
movss -0x40(%rbp), %xmm0
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x4480b(%rip), %rax # 0xbe910
movsbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x40(%rbp), %xmm0
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movzbl (%rax,%rcx), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0x447cf(%rip), %rax # 0xbe910
movsbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x7a0dd
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x7a040
jmp 0x7a197
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x79ff2
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
dequantize_row_iq4_xs:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_18]
mov ecx, 100h
cqo
idiv rcx
cmp rdx, 0
jnz short loc_79FBA
jmp short loc_79FD9
loc_79FBA:
lea rdi, aKQkK0; "k % QK_K == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
mov edx, 997h
lea rcx, aVoidDequantize_19; "void dequantize_row_iq4_xs(const block_"...
call ___assert_fail
loc_79FD9:
mov rax, [rbp+var_18]
mov ecx, 100h
cqo
idiv rcx
mov [rbp+var_20], rax
mov [rbp+var_24], 0
loc_79FF2:
movsxd rax, [rbp+var_24]
cmp rax, [rbp+var_20]
jge loc_7A1A5
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_24]
imul rcx, 88h
add rax, rcx
add rax, 8
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_24]
imul rcx, 88h
add rax, rcx
movzx edi, word ptr [rax]
call ggml_lookup_fp16_to_fp32_0
movss [rbp+var_34], xmm0
mov [rbp+var_38], 0
loc_7A040:
cmp [rbp+var_38], 8
jge loc_7A195
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_24]
imul rcx, 88h
add rax, rcx
mov [rbp+var_50], rax
mov eax, [rbp+var_38]
mov ecx, 2
cdq
idiv ecx
mov ecx, eax
mov rax, [rbp+var_50]
movsxd rcx, ecx
movzx eax, byte ptr [rax+rcx+4]
mov [rbp+var_48], eax
mov eax, [rbp+var_38]
mov ecx, 2
cdq
idiv ecx
mov eax, [rbp+var_48]
mov ecx, edx
shl ecx, 2
sar eax, cl
and eax, 0Fh
mov rcx, [rbp+var_8]
movsxd rdx, [rbp+var_24]
imul rdx, 88h
add rcx, rdx
movzx edx, word ptr [rcx+2]
mov ecx, [rbp+var_38]
shl ecx, 1
sar edx, cl
mov ecx, edx
and ecx, 3
shl ecx, 4
or eax, ecx
mov [rbp+var_3C], eax
movss xmm0, [rbp+var_34]
mov eax, [rbp+var_3C]
sub eax, 20h ; ' '
cvtsi2ss xmm1, eax
mulss xmm0, xmm1
movss [rbp+var_40], xmm0
mov [rbp+var_44], 0
loc_7A0DD:
cmp [rbp+var_44], 10h
jge loc_7A16D
movss xmm0, [rbp+var_40]
mov rax, [rbp+var_30]
movsxd rcx, [rbp+var_44]
movzx eax, byte ptr [rax+rcx]
and eax, 0Fh
movsxd rcx, eax
lea rax, kvalues_iq4nl
movsx eax, byte ptr [rax+rcx]
cvtsi2ss xmm1, eax
mulss xmm0, xmm1
mov rax, [rbp+var_10]
mov ecx, [rbp+var_44]
add ecx, 0
movsxd rcx, ecx
movss dword ptr [rax+rcx*4], xmm0
movss xmm0, [rbp+var_40]
mov rax, [rbp+var_30]
movsxd rcx, [rbp+var_44]
movzx eax, byte ptr [rax+rcx]
sar eax, 4
movsxd rcx, eax
lea rax, kvalues_iq4nl
movsx eax, byte ptr [rax+rcx]
cvtsi2ss xmm1, eax
mulss xmm0, xmm1
mov rax, [rbp+var_10]
mov ecx, [rbp+var_44]
add ecx, 10h
movsxd rcx, ecx
movss dword ptr [rax+rcx*4], xmm0
mov eax, [rbp+var_44]
add eax, 1
mov [rbp+var_44], eax
jmp loc_7A0DD
loc_7A16D:
mov rax, [rbp+var_10]
add rax, 80h
mov [rbp+var_10], rax
mov rax, [rbp+var_30]
add rax, 10h
mov [rbp+var_30], rax
mov eax, [rbp+var_38]
add eax, 1
mov [rbp+var_38], eax
jmp loc_7A040
loc_7A195:
jmp short $+2
loc_7A197:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_79FF2
loc_7A1A5:
add rsp, 50h
pop rbp
retn
|
long long dequantize_row_iq4_xs(long long a1, long long a2, long long a3)
{
long long result; // rax
int k; // [rsp+Ch] [rbp-44h]
float v5; // [rsp+10h] [rbp-40h]
int j; // [rsp+18h] [rbp-38h]
float v7; // [rsp+1Ch] [rbp-34h]
long long v8; // [rsp+20h] [rbp-30h]
int i; // [rsp+2Ch] [rbp-24h]
if ( a3 % 256 )
__assert_fail(
"k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
2455LL,
"void dequantize_row_iq4_xs(const block_iq4_xs *restrict, float *restrict, int64_t)");
for ( i = 0; ; ++i )
{
result = i;
if ( i >= a3 / 256 )
break;
v8 = 136LL * i + a1 + 8;
v7 = ggml_lookup_fp16_to_fp32_0(*(_WORD *)(136LL * i + a1));
for ( j = 0; j < 8; ++j )
{
v5 = v7
* (float)(((16 * (((int)*(unsigned __int16 *)(136LL * i + a1 + 2) >> (2 * j)) & 3)) | ((int)*(unsigned __int8 *)(136LL * i + a1 + j / 2 + 4) >> (4 * (j % 2))) & 0xF)
- 32);
for ( k = 0; k < 16; ++k )
{
*(float *)(a2 + 4LL * k) = v5 * (float)kvalues_iq4nl[*(_BYTE *)(v8 + k) & 0xF];
*(float *)(a2 + 4LL * (k + 16)) = v5 * (float)kvalues_iq4nl[(int)*(unsigned __int8 *)(v8 + k) >> 4];
}
a2 += 128LL;
v8 += 16LL;
}
}
return result;
}
|
dequantize_row_iq4_xs:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,0x100
CQO
IDIV RCX
CMP RDX,0x0
JNZ 0x00179fba
JMP 0x00179fd9
LAB_00179fba:
LEA RDI,[0x1c1144]
LEA RSI,[0x1c0d5c]
MOV EDX,0x997
LEA RCX,[0x1c185e]
CALL 0x00144810
LAB_00179fd9:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,0x100
CQO
IDIV RCX
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x24],0x0
LAB_00179ff2:
MOVSXD RAX,dword ptr [RBP + -0x24]
CMP RAX,qword ptr [RBP + -0x20]
JGE 0x0017a1a5
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x24]
IMUL RCX,RCX,0x88
ADD RAX,RCX
ADD RAX,0x8
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x24]
IMUL RCX,RCX,0x88
ADD RAX,RCX
MOVZX EDI,word ptr [RAX]
CALL 0x0016e6e0
MOVSS dword ptr [RBP + -0x34],XMM0
MOV dword ptr [RBP + -0x38],0x0
LAB_0017a040:
CMP dword ptr [RBP + -0x38],0x8
JGE 0x0017a195
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x24]
IMUL RCX,RCX,0x88
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,0x2
CDQ
IDIV ECX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOVSXD RCX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x4]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,0x2
CDQ
IDIV ECX
MOV EAX,dword ptr [RBP + -0x48]
MOV ECX,EDX
SHL ECX,0x2
SAR EAX,CL
AND EAX,0xf
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RDX,dword ptr [RBP + -0x24]
IMUL RDX,RDX,0x88
ADD RCX,RDX
MOVZX EDX,word ptr [RCX + 0x2]
MOV ECX,dword ptr [RBP + -0x38]
SHL ECX,0x1
SAR EDX,CL
MOV ECX,EDX
AND ECX,0x3
SHL ECX,0x4
OR EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
MOVSS XMM0,dword ptr [RBP + -0x34]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x20
CVTSI2SS XMM1,EAX
MULSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x40],XMM0
MOV dword ptr [RBP + -0x44],0x0
LAB_0017a0dd:
CMP dword ptr [RBP + -0x44],0x10
JGE 0x0017a16d
MOVSS XMM0,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RCX,dword ptr [RBP + -0x44]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
AND EAX,0xf
MOVSXD RCX,EAX
LEA RAX,[0x1be910]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CVTSI2SS XMM1,EAX
MULSS XMM0,XMM1
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x44]
ADD ECX,0x0
MOVSXD RCX,ECX
MOVSS dword ptr [RAX + RCX*0x4],XMM0
MOVSS XMM0,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RCX,dword ptr [RBP + -0x44]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
SAR EAX,0x4
MOVSXD RCX,EAX
LEA RAX,[0x1be910]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CVTSI2SS XMM1,EAX
MULSS XMM0,XMM1
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x44]
ADD ECX,0x10
MOVSXD RCX,ECX
MOVSS dword ptr [RAX + RCX*0x4],XMM0
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,0x1
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0017a0dd
LAB_0017a16d:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x80
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x10
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0017a040
LAB_0017a195:
JMP 0x0017a197
LAB_0017a197:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00179ff2
LAB_0017a1a5:
ADD RSP,0x50
POP RBP
RET
|
void dequantize_row_iq4_xs(long param_1,long param_2,long param_3)
{
float fVar1;
float fVar2;
int local_4c;
int local_40;
long local_38;
int local_2c;
long local_18;
if (param_3 % 0x100 == 0) {
local_18 = param_2;
for (local_2c = 0; (long)local_2c < param_3 / 0x100; local_2c = local_2c + 1) {
local_38 = param_1 + (long)local_2c * 0x88 + 8;
fVar1 = (float)ggml_lookup_fp16_to_fp32(*(int2 *)(param_1 + (long)local_2c * 0x88));
for (local_40 = 0; local_40 < 8; local_40 = local_40 + 1) {
fVar2 = fVar1 * (float)(int)(((int)(uint)*(byte *)(param_1 + (long)local_2c * 0x88 + 4 +
(long)(local_40 / 2)) >>
((byte)(local_40 % 2 << 2) & 0x1f) & 0xfU |
((int)(uint)*(ushort *)(param_1 + (long)local_2c * 0x88 + 2) >>
((byte)(local_40 << 1) & 0x1f) & 3U) << 4) - 0x20);
for (local_4c = 0; local_4c < 0x10; local_4c = local_4c + 1) {
*(float *)(local_18 + (long)local_4c * 4) =
fVar2 * (float)(int)(char)kvalues_iq4nl[(int)(*(byte *)(local_38 + local_4c) & 0xf)];
*(float *)(local_18 + (long)(local_4c + 0x10) * 4) =
fVar2 * (float)(int)(char)kvalues_iq4nl
[(int)(uint)*(byte *)(local_38 + local_4c) >> 4];
}
local_18 = local_18 + 0x80;
local_38 = local_38 + 0x10;
}
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x997,
"void dequantize_row_iq4_xs(const block_iq4_xs *restrict, float *restrict, int64_t)"
);
}
|
|
11,323 |
dequantize_row_iq4_xs
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c
|
void dequantize_row_iq4_xs(const block_iq4_xs * restrict x, float * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
for (int i = 0; i < nb; i++) {
const uint8_t * qs = x[i].qs;
const float d = GGML_FP16_TO_FP32(x[i].d);
for (int ib = 0; ib < QK_K/32; ++ib) {
const int ls = ((x[i].scales_l[ib/2] >> 4*(ib%2)) & 0xf) | (((x[i].scales_h >> 2*ib) & 3) << 4);
const float dl = d * (ls - 32);
for (int j = 0; j < 16; ++j) {
y[j+ 0] = dl * kvalues_iq4nl[qs[j] & 0xf];
y[j+16] = dl * kvalues_iq4nl[qs[j] >> 4];
}
y += 32;
qs += 16;
}
}
}
|
O1
|
c
|
dequantize_row_iq4_xs:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testb %dl, %dl
jne 0x34d94
sarq $0x8, %rdx
testq %rdx, %rdx
jle 0x34d8b
xorl %eax, %eax
movq 0x392f6(%rip), %r8 # 0x6dfa8
leaq 0x1c0d7(%rip), %r9 # 0x50d90
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rcx
leaq (%rdi,%rcx), %r10
leaq (%rdi,%rcx), %r11
addq $0x8, %r11
movzwl -0x8(%r11), %ecx
movss (%r8,%rcx,4), %xmm0
movzwl -0x6(%r11), %ebx
xorl %r14d, %r14d
movl %r14d, %ecx
shrl %ecx
movzbl 0x4(%r10,%rcx), %r15d
leal (,%r14,4), %ecx
andb $0x4, %cl
shrl %cl, %r15d
leal (%r14,%r14), %ecx
movl %ebx, %r12d
shrl %cl, %r12d
andl $0xf, %r15d
shll $0x4, %r12d
andl $0x30, %r12d
leal (%r12,%r15), %ecx
addl $-0x20, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
mulss %xmm0, %xmm1
xorl %ecx, %ecx
movzbl (%r11,%rcx), %r15d
movl %r15d, %r12d
andl $0xf, %r12d
movsbl (%r12,%r9), %ebp
xorps %xmm2, %xmm2
cvtsi2ss %ebp, %xmm2
mulss %xmm1, %xmm2
movss %xmm2, (%rsi,%rcx,4)
shrl $0x4, %r15d
movsbl (%r15,%r9), %ebp
xorps %xmm2, %xmm2
cvtsi2ss %ebp, %xmm2
mulss %xmm1, %xmm2
movss %xmm2, 0x40(%rsi,%rcx,4)
incq %rcx
cmpq $0x10, %rcx
jne 0x34d26
subq $-0x80, %rsi
addq $0x10, %r11
incl %r14d
cmpl $0x8, %r14d
jne 0x34ce3
incq %rax
cmpq %rdx, %rax
jne 0x34cb9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26e51(%rip), %rdi # 0x5bbec
leaq 0x26a62(%rip), %rsi # 0x5b804
leaq 0x2755d(%rip), %rcx # 0x5c306
movl $0x997, %edx # imm = 0x997
callq 0x17b00
|
dequantize_row_iq4_xs:
push rbp
push r15
push r14
push r12
push rbx
test dl, dl
jnz loc_34D94
sar rdx, 8
test rdx, rdx
jle loc_34D8B
xor eax, eax
mov r8, cs:ggml_table_f32_f16_ptr
lea r9, kvalues_iq4nl
loc_34CB9:
mov rcx, rax
shl rcx, 7
lea rcx, [rcx+rax*8]
lea r10, [rdi+rcx]
lea r11, [rdi+rcx]
add r11, 8
movzx ecx, word ptr [r11-8]
movss xmm0, dword ptr [r8+rcx*4]
movzx ebx, word ptr [r11-6]
xor r14d, r14d
loc_34CE3:
mov ecx, r14d
shr ecx, 1
movzx r15d, byte ptr [r10+rcx+4]
lea ecx, ds:0[r14*4]
and cl, 4
shr r15d, cl
lea ecx, [r14+r14]
mov r12d, ebx
shr r12d, cl
and r15d, 0Fh
shl r12d, 4
and r12d, 30h
lea ecx, [r12+r15]
add ecx, 0FFFFFFE0h
xorps xmm1, xmm1
cvtsi2ss xmm1, ecx
mulss xmm1, xmm0
xor ecx, ecx
loc_34D26:
movzx r15d, byte ptr [r11+rcx]
mov r12d, r15d
and r12d, 0Fh
movsx ebp, byte ptr [r12+r9]
xorps xmm2, xmm2
cvtsi2ss xmm2, ebp
mulss xmm2, xmm1
movss dword ptr [rsi+rcx*4], xmm2
shr r15d, 4
movsx ebp, byte ptr [r15+r9]
xorps xmm2, xmm2
cvtsi2ss xmm2, ebp
mulss xmm2, xmm1
movss dword ptr [rsi+rcx*4+40h], xmm2
inc rcx
cmp rcx, 10h
jnz short loc_34D26
sub rsi, 0FFFFFFFFFFFFFF80h
add r11, 10h
inc r14d
cmp r14d, 8
jnz loc_34CE3
inc rax
cmp rax, rdx
jnz loc_34CB9
loc_34D8B:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_34D94:
lea rdi, aKQkK0; "k % QK_K == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidDequantize_19; "void dequantize_row_iq4_xs(const block_"...
mov edx, 997h
call ___assert_fail
|
void dequantize_row_iq4_xs(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long i; // rax
long long v5; // r11
float v6; // xmm0_4
unsigned int v7; // ebx
unsigned int j; // r14d
float v9; // xmm1_4
long long k; // rcx
unsigned int v11; // r15d
if ( (_BYTE)a3 )
__assert_fail(
"k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
2455LL,
"void dequantize_row_iq4_xs(const block_iq4_xs *restrict, float *restrict, int64_t)");
v3 = a3 >> 8;
if ( v3 > 0 )
{
for ( i = 0LL; i != v3; ++i )
{
v5 = a1 + 136 * i + 8;
v6 = ggml_table_f32_f16[*(unsigned __int16 *)(a1 + 136 * i)];
v7 = *(unsigned __int16 *)(a1 + 136 * i + 2);
for ( j = 0; j != 8; ++j )
{
v9 = (float)(((16 * (unsigned __int8)(v7 >> (2 * j))) & 0x30)
+ ((*(unsigned __int8 *)(a1 + 136 * i + (j >> 1) + 4) >> ((4 * j) & 4)) & 0xF)
- 32)
* v6;
for ( k = 0LL; k != 16; ++k )
{
v11 = *(unsigned __int8 *)(v5 + k);
*(float *)(a2 + 4 * k) = (float)kvalues_iq4nl[*(_BYTE *)(v5 + k) & 0xF] * v9;
*(float *)(a2 + 4 * k + 64) = (float)kvalues_iq4nl[v11 >> 4] * v9;
}
a2 += 128LL;
v5 += 16LL;
}
}
}
}
|
dequantize_row_iq4_xs:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
TEST DL,DL
JNZ 0x00134d94
SAR RDX,0x8
TEST RDX,RDX
JLE 0x00134d8b
XOR EAX,EAX
MOV R8,qword ptr [0x0016dfa8]
LEA R9,[0x150d90]
LAB_00134cb9:
MOV RCX,RAX
SHL RCX,0x7
LEA RCX,[RCX + RAX*0x8]
LEA R10,[RDI + RCX*0x1]
LEA R11,[RDI + RCX*0x1]
ADD R11,0x8
MOVZX ECX,word ptr [R11 + -0x8]
MOVSS XMM0,dword ptr [R8 + RCX*0x4]
MOVZX EBX,word ptr [R11 + -0x6]
XOR R14D,R14D
LAB_00134ce3:
MOV ECX,R14D
SHR ECX,0x1
MOVZX R15D,byte ptr [R10 + RCX*0x1 + 0x4]
LEA ECX,[R14*0x4]
AND CL,0x4
SHR R15D,CL
LEA ECX,[R14 + R14*0x1]
MOV R12D,EBX
SHR R12D,CL
AND R15D,0xf
SHL R12D,0x4
AND R12D,0x30
LEA ECX,[R12 + R15*0x1]
ADD ECX,-0x20
XORPS XMM1,XMM1
CVTSI2SS XMM1,ECX
MULSS XMM1,XMM0
XOR ECX,ECX
LAB_00134d26:
MOVZX R15D,byte ptr [R11 + RCX*0x1]
MOV R12D,R15D
AND R12D,0xf
MOVSX EBP,byte ptr [R12 + R9*0x1]
XORPS XMM2,XMM2
CVTSI2SS XMM2,EBP
MULSS XMM2,XMM1
MOVSS dword ptr [RSI + RCX*0x4],XMM2
SHR R15D,0x4
MOVSX EBP,byte ptr [R15 + R9*0x1]
XORPS XMM2,XMM2
CVTSI2SS XMM2,EBP
MULSS XMM2,XMM1
MOVSS dword ptr [RSI + RCX*0x4 + 0x40],XMM2
INC RCX
CMP RCX,0x10
JNZ 0x00134d26
SUB RSI,-0x80
ADD R11,0x10
INC R14D
CMP R14D,0x8
JNZ 0x00134ce3
INC RAX
CMP RAX,RDX
JNZ 0x00134cb9
LAB_00134d8b:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00134d94:
LEA RDI,[0x15bbec]
LEA RSI,[0x15b804]
LEA RCX,[0x15c306]
MOV EDX,0x997
CALL 0x00117b00
|
void dequantize_row_iq4_xs(long param_1,long param_2,long param_3)
{
ushort *puVar1;
float fVar2;
byte bVar3;
ushort uVar4;
int *puVar5;
long lVar6;
long lVar7;
ushort *puVar8;
uint uVar9;
ulong uVar10;
float fVar11;
puVar5 = PTR_ggml_table_f32_f16_0016dfa8;
if ((char)param_3 == '\0') {
if (0 < param_3 >> 8) {
lVar6 = 0;
do {
puVar1 = (ushort *)(param_1 + lVar6 * 0x88);
puVar8 = puVar1 + 4;
fVar2 = *(float *)(puVar5 + (ulong)*puVar1 * 4);
uVar4 = puVar1[1];
uVar10 = 0;
do {
fVar11 = (float)(int)((uVar4 >> ((char)uVar10 * '\x02' & 0x1fU) & 3) * 0x10 +
(*(byte *)(param_1 + lVar6 * 0x88 + 4 + (uVar10 >> 1)) >>
((char)uVar10 * '\x04' & 4U) & 0xf) + -0x20) * fVar2;
lVar7 = 0;
do {
bVar3 = *(byte *)((long)puVar8 + lVar7);
*(float *)(param_2 + lVar7 * 4) =
(float)(int)(char)(&kvalues_iq4nl)[bVar3 & 0xf] * fVar11;
*(float *)(param_2 + 0x40 + lVar7 * 4) =
(float)(int)(char)(&kvalues_iq4nl)[bVar3 >> 4] * fVar11;
lVar7 = lVar7 + 1;
} while (lVar7 != 0x10);
param_2 = param_2 + 0x80;
puVar8 = puVar8 + 8;
uVar9 = (int)uVar10 + 1;
uVar10 = (ulong)uVar9;
} while (uVar9 != 8);
lVar6 = lVar6 + 1;
} while (lVar6 != param_3 >> 8);
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x997,
"void dequantize_row_iq4_xs(const block_iq4_xs *restrict, float *restrict, int64_t)"
);
}
|
|
11,324 |
httplib::detail::SocketStream::read(char*, unsigned long)
|
hkr04[P]cpp-mcp/common/httplib.h
|
inline ssize_t SocketStream::read(char *ptr, size_t size) {
#ifdef _WIN32
size =
(std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
#else
size = (std::min)(size,
static_cast<size_t>((std::numeric_limits<ssize_t>::max)()));
#endif
if (read_buff_off_ < read_buff_content_size_) {
auto remaining_size = read_buff_content_size_ - read_buff_off_;
if (size <= remaining_size) {
memcpy(ptr, read_buff_.data() + read_buff_off_, size);
read_buff_off_ += size;
return static_cast<ssize_t>(size);
} else {
memcpy(ptr, read_buff_.data() + read_buff_off_, remaining_size);
read_buff_off_ += remaining_size;
return static_cast<ssize_t>(remaining_size);
}
}
if (!is_readable()) { return -1; }
read_buff_off_ = 0;
read_buff_content_size_ = 0;
if (size < read_buff_size_) {
auto n = read_socket(sock_, read_buff_.data(), read_buff_size_,
CPPHTTPLIB_RECV_FLAGS);
if (n <= 0) {
return n;
} else if (n <= static_cast<ssize_t>(size)) {
memcpy(ptr, read_buff_.data(), static_cast<size_t>(n));
return n;
} else {
memcpy(ptr, read_buff_.data(), size);
read_buff_off_ = size;
read_buff_content_size_ = static_cast<size_t>(n);
return static_cast<ssize_t>(size);
}
} else {
return read_socket(sock_, ptr, size, CPPHTTPLIB_RECV_FLAGS);
}
}
|
O1
|
c
|
httplib::detail::SocketStream::read(char*, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movabsq $0x7fffffffffffffff, %rbx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rbx, %rdx
cmovbq %rdx, %rbx
movq %rdi, %r15
movq 0x58(%rdi), %rsi
movq 0x60(%rdi), %r12
subq %rsi, %r12
jbe 0x1696d
addq 0x40(%r15), %rsi
cmpq %r12, %rbx
cmovbq %rbx, %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x8480
addq %r12, 0x58(%r15)
jmp 0x16acd
movq %rdx, %r13
movq %r15, %rdi
callq 0x16570
movq $-0x1, %r12
testb %al, %al
je 0x16acd
leaq 0x58(%r15), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl 0x8(%r15), %ebp
cmpq $0xfff, %r13 # imm = 0xFFF
ja 0x16a55
movq 0x40(%r15), %r13
movl $0x1000, %edx # imm = 0x1000
movl %ebp, %edi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x8180
movq %rax, %r12
testq %rax, %rax
jns 0x16a27
movq %r13, 0x20(%rsp)
movl %ebp, 0xc(%rsp)
callq 0x8060
cmpl $0x4, (%rax)
jne 0x16a27
movq %rax, %r13
leaq 0x10(%rsp), %rbp
movq $0x0, 0x10(%rsp)
movq $0x3e8, 0x18(%rsp) # imm = 0x3E8
movq %rbp, %rdi
movq %rbp, %rsi
callq 0x8130
cmpl $-0x1, %eax
jne 0x16a03
cmpl $0x4, (%r13)
je 0x169ec
movl $0x1000, %edx # imm = 0x1000
movl 0xc(%rsp), %edi
movq 0x20(%rsp), %rsi
xorl %ecx, %ecx
callq 0x8180
movq %rax, %r12
testq %rax, %rax
jns 0x16a27
cmpl $0x4, (%r13)
je 0x169da
testq %r12, %r12
jle 0x16acd
movq 0x40(%r15), %rsi
movq %r14, %rdi
cmpq %rbx, %r12
jle 0x16ac5
movq %rbx, %rdx
callq 0x8480
movq %rbx, 0x58(%r15)
movq %r12, 0x60(%r15)
movq %rbx, %r12
jmp 0x16acd
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x8180
movq %rax, %r12
testq %rax, %rax
jns 0x16acd
callq 0x8060
cmpl $0x4, (%rax)
jne 0x16acd
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq $0x0, 0x10(%rsp)
movq $0x3e8, 0x18(%rsp) # imm = 0x3E8
movq %r13, %rdi
movq %r13, %rsi
callq 0x8130
cmpl $-0x1, %eax
jne 0x16aa6
cmpl $0x4, (%r15)
je 0x16a90
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x8180
movq %rax, %r12
testq %rax, %rax
jns 0x16acd
cmpl $0x4, (%r15)
je 0x16a7e
jmp 0x16acd
movq %r12, %rdx
callq 0x8480
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN7httplib6detail12SocketStream4readEPcm:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, 7FFFFFFFFFFFFFFFh
cmp rdx, rbx
cmovb rbx, rdx
mov r15, rdi
mov rsi, [rdi+58h]
mov r12, [rdi+60h]
sub r12, rsi
jbe short loc_1696D
add rsi, [r15+40h]
cmp rbx, r12
cmovb r12, rbx
mov rdi, r14
mov rdx, r12
call _memcpy
add [r15+58h], r12
jmp loc_16ACD
loc_1696D:
mov r13, rdx
mov rdi, r15; this
call _ZNK7httplib6detail12SocketStream11is_readableEv; httplib::detail::SocketStream::is_readable(void)
mov r12, 0FFFFFFFFFFFFFFFFh
test al, al
jz loc_16ACD
lea rax, [r15+58h]
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov ebp, [r15+8]
cmp r13, 0FFFh
ja loc_16A55
mov r13, [r15+40h]
mov edx, 1000h
mov edi, ebp
mov rsi, r13
xor ecx, ecx
call _recv
mov r12, rax
test rax, rax
jns short loc_16A27
mov [rsp+58h+var_38], r13
mov [rsp+58h+var_4C], ebp
call ___errno_location
cmp dword ptr [rax], 4
jnz short loc_16A27
mov r13, rax
lea rbp, [rsp+58h+var_48]
loc_169DA:
mov [rsp+58h+var_48], 0
mov [rsp+58h+var_40], 3E8h
loc_169EC:
mov rdi, rbp
mov rsi, rbp
call _nanosleep
cmp eax, 0FFFFFFFFh
jnz short loc_16A03
cmp dword ptr [r13+0], 4
jz short loc_169EC
loc_16A03:
mov edx, 1000h
mov edi, [rsp+58h+var_4C]
mov rsi, [rsp+58h+var_38]
xor ecx, ecx
call _recv
mov r12, rax
test rax, rax
jns short loc_16A27
cmp dword ptr [r13+0], 4
jz short loc_169DA
loc_16A27:
test r12, r12
jle loc_16ACD
mov rsi, [r15+40h]
mov rdi, r14
cmp r12, rbx
jle loc_16AC5
mov rdx, rbx
call _memcpy
mov [r15+58h], rbx
mov [r15+60h], r12
mov r12, rbx
jmp short loc_16ACD
loc_16A55:
mov edi, ebp
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call _recv
mov r12, rax
test rax, rax
jns short loc_16ACD
call ___errno_location
cmp dword ptr [rax], 4
jnz short loc_16ACD
mov r15, rax
lea r13, [rsp+58h+var_48]
loc_16A7E:
mov [rsp+58h+var_48], 0
mov [rsp+58h+var_40], 3E8h
loc_16A90:
mov rdi, r13
mov rsi, r13
call _nanosleep
cmp eax, 0FFFFFFFFh
jnz short loc_16AA6
cmp dword ptr [r15], 4
jz short loc_16A90
loc_16AA6:
mov edi, ebp
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call _recv
mov r12, rax
test rax, rax
jns short loc_16ACD
cmp dword ptr [r15], 4
jz short loc_16A7E
jmp short loc_16ACD
loc_16AC5:
mov rdx, r12
call _memcpy
loc_16ACD:
mov rax, r12
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long httplib::detail::SocketStream::read(
httplib::detail::SocketStream *this,
char *a2,
unsigned long long a3)
{
long long v4; // rbx
unsigned long long v5; // rsi
unsigned long long v6; // r12
bool v7; // cc
long long v8; // r12
unsigned long long v9; // rsi
unsigned int v11; // ebp
long long v12; // r13
_DWORD *v13; // rax
_DWORD *v14; // r13
long long v15; // rsi
_DWORD *v16; // rax
_DWORD *v17; // r15
long long v19; // [rsp+10h] [rbp-48h] BYREF
long long v20; // [rsp+18h] [rbp-40h]
long long v21; // [rsp+20h] [rbp-38h]
v4 = 0x7FFFFFFFFFFFFFFFLL;
if ( a3 < 0x7FFFFFFFFFFFFFFFLL )
v4 = a3;
v5 = *((_QWORD *)this + 11);
v6 = *((_QWORD *)this + 12);
v7 = v6 <= v5;
v8 = v6 - v5;
if ( v7 )
{
v8 = -1LL;
if ( httplib::detail::SocketStream::is_readable(this) )
{
*(_OWORD *)((char *)this + 88) = 0LL;
v11 = *((_DWORD *)this + 2);
if ( a3 > 0xFFF )
{
v8 = recv(v11, a2, v4, 0LL);
if ( v8 < 0 )
{
v16 = (_DWORD *)__errno_location(v11, a2);
if ( *v16 == 4 )
{
v17 = v16;
do
{
v19 = 0LL;
v20 = 1000LL;
while ( (unsigned int)nanosleep(&v19, &v19) == -1 && *v17 == 4 )
;
v8 = recv(v11, a2, v4, 0LL);
}
while ( v8 < 0 && *v17 == 4 );
}
}
}
else
{
v12 = *((_QWORD *)this + 8);
v8 = recv(v11, v12, 4096LL, 0LL);
if ( v8 < 0 )
{
v21 = v12;
v13 = (_DWORD *)__errno_location(v11, v12);
if ( *v13 == 4 )
{
v14 = v13;
do
{
v19 = 0LL;
v20 = 1000LL;
while ( (unsigned int)nanosleep(&v19, &v19) == -1 && *v14 == 4 )
;
v8 = recv(v11, v21, 4096LL, 0LL);
}
while ( v8 < 0 && *v14 == 4 );
}
}
if ( v8 > 0 )
{
v15 = *((_QWORD *)this + 8);
if ( v8 <= v4 )
{
memcpy(a2, v15, v8);
}
else
{
memcpy(a2, v15, v4);
*((_QWORD *)this + 11) = v4;
*((_QWORD *)this + 12) = v8;
return v4;
}
}
}
}
}
else
{
v9 = *((_QWORD *)this + 8) + v5;
if ( v4 < (unsigned long long)v8 )
v8 = v4;
memcpy(a2, v9, v8);
*((_QWORD *)this + 11) += v8;
}
return v8;
}
|
read:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,0x7fffffffffffffff
CMP RDX,RBX
CMOVC RBX,RDX
MOV R15,RDI
MOV RSI,qword ptr [RDI + 0x58]
MOV R12,qword ptr [RDI + 0x60]
SUB R12,RSI
JBE 0x0011696d
ADD RSI,qword ptr [R15 + 0x40]
CMP RBX,R12
CMOVC R12,RBX
MOV RDI,R14
MOV RDX,R12
CALL 0x00108480
ADD qword ptr [R15 + 0x58],R12
JMP 0x00116acd
LAB_0011696d:
MOV R13,RDX
MOV RDI,R15
CALL 0x00116570
MOV R12,-0x1
TEST AL,AL
JZ 0x00116acd
LEA RAX,[R15 + 0x58]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV EBP,dword ptr [R15 + 0x8]
CMP R13,0xfff
JA 0x00116a55
MOV R13,qword ptr [R15 + 0x40]
MOV EDX,0x1000
MOV EDI,EBP
MOV RSI,R13
XOR ECX,ECX
CALL 0x00108180
MOV R12,RAX
TEST RAX,RAX
JNS 0x00116a27
MOV qword ptr [RSP + 0x20],R13
MOV dword ptr [RSP + 0xc],EBP
CALL 0x00108060
CMP dword ptr [RAX],0x4
JNZ 0x00116a27
MOV R13,RAX
LEA RBP,[RSP + 0x10]
LAB_001169da:
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x3e8
LAB_001169ec:
MOV RDI,RBP
MOV RSI,RBP
CALL 0x00108130
CMP EAX,-0x1
JNZ 0x00116a03
CMP dword ptr [R13],0x4
JZ 0x001169ec
LAB_00116a03:
MOV EDX,0x1000
MOV EDI,dword ptr [RSP + 0xc]
MOV RSI,qword ptr [RSP + 0x20]
XOR ECX,ECX
CALL 0x00108180
MOV R12,RAX
TEST RAX,RAX
JNS 0x00116a27
CMP dword ptr [R13],0x4
JZ 0x001169da
LAB_00116a27:
TEST R12,R12
JLE 0x00116acd
MOV RSI,qword ptr [R15 + 0x40]
MOV RDI,R14
CMP R12,RBX
JLE 0x00116ac5
MOV RDX,RBX
CALL 0x00108480
MOV qword ptr [R15 + 0x58],RBX
MOV qword ptr [R15 + 0x60],R12
MOV R12,RBX
JMP 0x00116acd
LAB_00116a55:
MOV EDI,EBP
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x00108180
MOV R12,RAX
TEST RAX,RAX
JNS 0x00116acd
CALL 0x00108060
CMP dword ptr [RAX],0x4
JNZ 0x00116acd
MOV R15,RAX
LEA R13,[RSP + 0x10]
LAB_00116a7e:
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x3e8
LAB_00116a90:
MOV RDI,R13
MOV RSI,R13
CALL 0x00108130
CMP EAX,-0x1
JNZ 0x00116aa6
CMP dword ptr [R15],0x4
JZ 0x00116a90
LAB_00116aa6:
MOV EDI,EBP
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x00108180
MOV R12,RAX
TEST RAX,RAX
JNS 0x00116acd
CMP dword ptr [R15],0x4
JZ 0x00116a7e
JMP 0x00116acd
LAB_00116ac5:
MOV RDX,R12
CALL 0x00108480
LAB_00116acd:
MOV RAX,R12
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* httplib::detail::SocketStream::read(char*, unsigned long) */
ulong __thiscall httplib::detail::SocketStream::read(SocketStream *this,char *param_1,ulong param_2)
{
int __fd;
ulong uVar1;
void *__buf;
char cVar2;
int iVar3;
int *piVar4;
ulong __n;
size_t __n_00;
timespec local_48;
void *local_38;
__n = 0x7fffffffffffffff;
if (param_2 < 0x7fffffffffffffff) {
__n = param_2;
}
uVar1 = *(ulong *)(this + 0x58);
__n_00 = *(ulong *)(this + 0x60) - uVar1;
if (*(ulong *)(this + 0x60) < uVar1 || __n_00 == 0) {
cVar2 = is_readable(this);
__n_00 = 0xffffffffffffffff;
if (cVar2 != '\0') {
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
__fd = *(int *)(this + 8);
if (param_2 < 0x1000) {
__buf = *(void **)(this + 0x40);
__n_00 = recv(__fd,__buf,0x1000,0);
if (((long)__n_00 < 0) && (local_38 = __buf, piVar4 = __errno_location(), *piVar4 == 4)) {
do {
local_48.tv_sec = 0;
local_48.tv_nsec = 1000;
do {
iVar3 = nanosleep(&local_48,&local_48);
if (iVar3 != -1) break;
} while (*piVar4 == 4);
__n_00 = recv(__fd,local_38,0x1000,0);
} while (((long)__n_00 < 0) && (*piVar4 == 4));
}
if (0 < (long)__n_00) {
if ((long)__n < (long)__n_00) {
memcpy(param_1,*(void **)(this + 0x40),__n);
*(ulong *)(this + 0x58) = __n;
*(size_t *)(this + 0x60) = __n_00;
__n_00 = __n;
}
else {
memcpy(param_1,*(void **)(this + 0x40),__n_00);
}
}
}
else {
__n_00 = recv(__fd,param_1,__n,0);
if (((long)__n_00 < 0) && (piVar4 = __errno_location(), *piVar4 == 4)) {
do {
local_48.tv_sec = 0;
local_48.tv_nsec = 1000;
do {
iVar3 = nanosleep(&local_48,&local_48);
if (iVar3 != -1) break;
} while (*piVar4 == 4);
__n_00 = recv(__fd,param_1,__n,0);
} while (((long)__n_00 < 0) && (*piVar4 == 4));
}
}
}
}
else {
if (__n < __n_00) {
__n_00 = __n;
}
memcpy(param_1,(void *)(uVar1 + *(long *)(this + 0x40)),__n_00);
*(size_t *)(this + 0x58) = *(long *)(this + 0x58) + __n_00;
}
return __n_00;
}
|
|
11,325 |
my_xml_error_lineno
|
eloqsql/strings/xml.c
|
uint my_xml_error_lineno(MY_XML_PARSER *p)
{
uint res=0;
const char *s;
for (s=p->beg ; s<p->cur; s++)
{
if (s[0] == '\n')
res++;
}
return res;
}
|
O0
|
c
|
my_xml_error_lineno:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x130(%rcx), %rax
jae 0x7e894
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x7e884
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7e886
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7e85e
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
my_xml_error_lineno:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
mov rax, [rbp+var_8]
mov rax, [rax+128h]
mov [rbp+var_18], rax
loc_7E85E:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
cmp rax, [rcx+130h]
jnb short loc_7E894
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 0Ah
jnz short loc_7E884
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
loc_7E884:
jmp short $+2
loc_7E886:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_7E85E
loc_7E894:
mov eax, [rbp+var_C]
pop rbp
retn
|
long long my_xml_error_lineno(long long a1)
{
_BYTE *i; // [rsp+0h] [rbp-18h]
unsigned int v3; // [rsp+Ch] [rbp-Ch]
v3 = 0;
for ( i = *(_BYTE **)(a1 + 296); (unsigned long long)i < *(_QWORD *)(a1 + 304); ++i )
{
if ( *i == 10 )
++v3;
}
return v3;
}
|
my_xml_error_lineno:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x128]
MOV qword ptr [RBP + -0x18],RAX
LAB_0017e85e:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x130]
JNC 0x0017e894
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0xa
JNZ 0x0017e884
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
LAB_0017e884:
JMP 0x0017e886
LAB_0017e886:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0017e85e
LAB_0017e894:
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET
|
int my_xml_error_lineno(long param_1)
{
char *local_20;
int local_14;
local_14 = 0;
for (local_20 = *(char **)(param_1 + 0x128); local_20 < *(char **)(param_1 + 0x130);
local_20 = local_20 + 1) {
if (*local_20 == '\n') {
local_14 = local_14 + 1;
}
}
return local_14;
}
|
|
11,326 |
plutovg_path_get_current_point
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-path.c
|
void plutovg_path_get_current_point(const plutovg_path_t* path, float* x, float* y)
{
float xx = 0.f;
float yy = 0.f;
if(path->num_points > 0) {
xx = path->elements.data[path->elements.size - 1].point.x;
yy = path->elements.data[path->elements.size - 1].point.y;
}
if(x) *x = xx;
if(y) *y = yy;
}
|
O1
|
c
|
plutovg_path_get_current_point:
cmpl $0x0, 0x4(%rdi)
jle 0xa50d
movq 0x18(%rdi), %rax
movslq 0x20(%rdi), %rcx
movss -0x8(%rax,%rcx,8), %xmm1
movss -0x4(%rax,%rcx,8), %xmm0
jmp 0xa513
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
testq %rsi, %rsi
je 0xa51c
movss %xmm1, (%rsi)
testq %rdx, %rdx
je 0xa525
movss %xmm0, (%rdx)
retq
|
plutovg_path_get_current_point:
cmp dword ptr [rdi+4], 0
jle short loc_A50D
mov rax, [rdi+18h]
movsxd rcx, dword ptr [rdi+20h]
movss xmm1, dword ptr [rax+rcx*8-8]
movss xmm0, dword ptr [rax+rcx*8-4]
jmp short loc_A513
loc_A50D:
xorps xmm1, xmm1
xorps xmm0, xmm0
loc_A513:
test rsi, rsi
jz short loc_A51C
movss dword ptr [rsi], xmm1
loc_A51C:
test rdx, rdx
jz short locret_A525
movss dword ptr [rdx], xmm0
locret_A525:
retn
|
long long plutovg_path_get_current_point(long long a1, _DWORD *a2, _DWORD *a3)
{
long long result; // rax
long long v4; // rcx
int v5; // xmm1_4
int v6; // xmm0_4
if ( *(int *)(a1 + 4) <= 0 )
{
v5 = 0;
v6 = 0;
}
else
{
result = *(_QWORD *)(a1 + 24);
v4 = *(int *)(a1 + 32);
v5 = *(_DWORD *)(result + 8 * v4 - 8);
v6 = *(_DWORD *)(result + 8 * v4 - 4);
}
if ( a2 )
*a2 = v5;
if ( a3 )
*a3 = v6;
return result;
}
|
plutovg_path_get_current_point:
CMP dword ptr [RDI + 0x4],0x0
JLE 0x0010a50d
MOV RAX,qword ptr [RDI + 0x18]
MOVSXD RCX,dword ptr [RDI + 0x20]
MOVSS XMM1,dword ptr [RAX + RCX*0x8 + -0x8]
MOVSS XMM0,dword ptr [RAX + RCX*0x8 + -0x4]
JMP 0x0010a513
LAB_0010a50d:
XORPS XMM1,XMM1
XORPS XMM0,XMM0
LAB_0010a513:
TEST RSI,RSI
JZ 0x0010a51c
MOVSS dword ptr [RSI],XMM1
LAB_0010a51c:
TEST RDX,RDX
JZ 0x0010a525
MOVSS dword ptr [RDX],XMM0
LAB_0010a525:
RET
|
void plutovg_path_get_current_point(long param_1,int4 *param_2,int4 *param_3)
{
int4 uVar1;
int4 uVar2;
if (*(int *)(param_1 + 4) < 1) {
uVar2 = 0;
uVar1 = 0;
}
else {
uVar2 = *(int4 *)(*(long *)(param_1 + 0x18) + -8 + (long)*(int *)(param_1 + 0x20) * 8);
uVar1 = *(int4 *)(*(long *)(param_1 + 0x18) + -4 + (long)*(int *)(param_1 + 0x20) * 8);
}
if (param_2 != (int4 *)0x0) {
*param_2 = uVar2;
}
if (param_3 != (int4 *)0x0) {
*param_3 = uVar1;
}
return;
}
|
|
11,327 |
ggml_build_backward_gradient_checkpointing
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
void ggml_build_backward_gradient_checkpointing(
struct ggml_context * ctx,
struct ggml_cgraph * gf,
struct ggml_cgraph * gb,
struct ggml_cgraph * gb_tmp,
struct ggml_tensor * * checkpoints,
int n_checkpoints) {
ggml_graph_cpy(gf, gb_tmp);
ggml_build_backward_expand(ctx, gf, gb_tmp, true);
if (n_checkpoints <= 0) {
ggml_graph_cpy(gb_tmp, gb);
return;
}
struct hash_map * replacements = ggml_new_hash_map(gf->n_nodes + gf->n_leafs + n_checkpoints);
// insert checkpoints in replacements
for (int i = 0; i < n_checkpoints; ++i) {
size_t k = ggml_hash_find(replacements->set, checkpoints[i]);
GGML_ASSERT(k != GGML_HASHTABLE_FULL); // assert that not full
GGML_ASSERT(replacements->set.keys[k] == NULL); // assert that we don't overwrite
replacements->set.keys[k] = checkpoints[i];
replacements->vals[k] = checkpoints[i];
}
ggml_graph_cpy(gf, gb);
// rewrite gb_tmp->nodes[gf->n_nodes:gb_tmp->n_nodes],
// replacing references to gb_tmp->nodes[0:gf->n_nodes] ( == gf->nodes[0:gf->n_nodes]),
// by recomputing them from checkpoints
for (int i = gf->n_nodes; i<gb_tmp->n_nodes; ++i) {
struct ggml_tensor * node = gb_tmp->nodes[i];
for (int k = 0; k < GGML_MAX_SRC; ++k) {
// insert new tensors recomputing src, reusing already made replacements,
// remember replacements: remember new tensors with mapping from corresponding gf nodes
// recurse for input tensors,
// unless (i.e. terminating when) input tensors are replacements (like checkpoints)
node->src[k] = ggml_recompute_graph_node(ctx, gf, replacements, node->src[k]);
}
// insert rewritten backward node with replacements made into resulting backward graph gb
ggml_build_forward_expand(gb, node);
}
ggml_hash_map_free(replacements);
}
|
O1
|
c
|
ggml_build_backward_gradient_checkpointing:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x96289
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x96380
testl %ebp, %ebp
jle 0x96266
movq %r13, 0x10(%rsp)
movl 0x4(%r15), %eax
addl %ebp, %eax
addl 0x8(%r15), %eax
movq %r14, 0x18(%rsp)
movl %ebp, 0x8(%rsp)
movslq %eax, %rbp
movl $0x18, %edi
callq 0xa7c0
movq %rax, %r13
movq %rbp, %rdi
callq 0x9678a
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
leaq (,%rax,8), %rdi
movq %rdi, 0x20(%rsp)
callq 0xa7c0
movq %rax, %rbp
movq %rax, 0x10(%r13)
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
movq 0x20(%rsp), %rdx
callq 0xa300
movq (%r13), %rsi
movq 0x8(%r13), %rdi
movl 0x8(%rsp), %r8d
movq (%rbx,%r14,8), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %rax
movq (%rdi,%rax,8), %r9
testq %r9, %r9
je 0x961a8
cmpq %rcx, %r9
je 0x961a8
incq %rax
cmpq %rsi, %rax
movl $0x0, %r9d
cmoveq %r9, %rax
cmpq %rdx, %rax
jne 0x9617e
movq $-0x1, %rax
cmpq $-0x1, %rax
je 0x9627f
cmpq $0x0, (%rdi,%rax,8)
jne 0x96284
movq %rcx, (%rdi,%rax,8)
movq (%rbx,%r14,8), %rcx
movq %rcx, (%rbp,%rax,8)
incq %r14
cmpq %r8, %r14
jne 0x9616f
movq %rbp, 0x8(%rsp)
movq %r15, %rdi
movq 0x18(%rsp), %rsi
callq 0x96289
movslq 0x4(%r15), %r14
movq 0x10(%rsp), %rcx
cmpl 0x4(%rcx), %r14d
jge 0x9623d
movq 0x10(%rcx), %rax
movq (%rax,%r14,8), %rbx
movl $0x14, %ebp
movq (%rbx,%rbp,8), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x964b4
movq %rax, (%rbx,%rbp,8)
incq %rbp
cmpq $0x1e, %rbp
jne 0x96200
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x9675b
incq %r14
movq 0x10(%rsp), %rcx
movslq 0x4(%rcx), %rax
cmpq %rax, %r14
jl 0x961f3
movq 0x8(%r13), %rdi
callq 0xa700
movq 0x8(%rsp), %rdi
callq 0xa700
movq %r13, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa700
movq %r13, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x96289
callq 0xf194
callq 0xf14f
|
ggml_build_backward_gradient_checkpointing:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, r9d
mov rbx, r8
mov r13, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
mov rdi, rsi
mov rsi, rcx
call ggml_graph_cpy
mov rdi, r12
mov rsi, r15
mov rdx, r13
mov ecx, 1
call ggml_build_backward_expand
test ebp, ebp
jle loc_96266
mov [rsp+58h+var_48], r13
mov eax, [r15+4]
add eax, ebp
add eax, [r15+8]
mov [rsp+58h+var_40], r14
mov dword ptr [rsp+58h+var_50], ebp
movsxd rbp, eax
mov edi, 18h
call _malloc
mov r13, rax
mov rdi, rbp
call ggml_hash_set_new
mov [r13+0], rax
mov [r13+8], rdx
lea rdi, ds:0[rax*8]
mov [rsp+58h+var_38], rdi
call _malloc
mov rbp, rax
mov [r13+10h], rax
xor r14d, r14d
mov rdi, rax
xor esi, esi
mov rdx, [rsp+58h+var_38]
call _memset
mov rsi, [r13+0]
mov rdi, [r13+8]
mov r8d, dword ptr [rsp+58h+var_50]
loc_9616F:
mov rcx, [rbx+r14*8]
mov rax, rcx
xor edx, edx
div rsi
mov rax, rdx
loc_9617E:
mov r9, [rdi+rax*8]
test r9, r9
jz short loc_961A8
cmp r9, rcx
jz short loc_961A8
inc rax
cmp rax, rsi
mov r9d, 0
cmovz rax, r9
cmp rax, rdx
jnz short loc_9617E
mov rax, 0FFFFFFFFFFFFFFFFh
loc_961A8:
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_9627F
cmp qword ptr [rdi+rax*8], 0
jnz loc_96284
mov [rdi+rax*8], rcx
mov rcx, [rbx+r14*8]
mov [rbp+rax*8+0], rcx
inc r14
cmp r14, r8
jnz short loc_9616F
mov [rsp+58h+var_50], rbp
mov rdi, r15
mov rsi, [rsp+58h+var_40]
call ggml_graph_cpy
movsxd r14, dword ptr [r15+4]
mov rcx, [rsp+58h+var_48]
cmp r14d, [rcx+4]
jge short loc_9623D
loc_961F3:
mov rax, [rcx+10h]
mov rbx, [rax+r14*8]
mov ebp, 14h
loc_96200:
mov rcx, [rbx+rbp*8]
mov rdi, r12
mov rsi, r15
mov rdx, r13
call ggml_recompute_graph_node
mov [rbx+rbp*8], rax
inc rbp
cmp rbp, 1Eh
jnz short loc_96200
mov rdi, [rsp+58h+var_40]
mov rsi, rbx
call ggml_build_forward_expand
inc r14
mov rcx, [rsp+58h+var_48]
movsxd rax, dword ptr [rcx+4]
cmp r14, rax
jl short loc_961F3
loc_9623D:
mov rdi, [r13+8]
call _free
mov rdi, [rsp+58h+var_50]
call _free
mov rdi, r13
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _free
loc_96266:
mov rdi, r13
mov rsi, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp ggml_graph_cpy
loc_9627F:
call ggml_build_backward_gradient_checkpointing_cold_2
loc_96284:
call ggml_build_backward_gradient_checkpointing_cold_1
|
long long ggml_build_backward_gradient_checkpointing(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6)
{
long long v12; // rbp
long long *v13; // r13
long long v14; // rax
long long v15; // rdx
long long v16; // rbp
long long v17; // r14
unsigned long long v18; // rsi
long long v19; // rdi
unsigned long long v20; // rcx
unsigned long long v21; // rdx
long long v22; // rax
long long v23; // r9
long long v24; // r14
long long v25; // rcx
long long v26; // rbx
long long i; // rbp
unsigned int v29; // [rsp+8h] [rbp-50h]
long long v30; // [rsp+8h] [rbp-50h]
long long v31; // [rsp+10h] [rbp-48h]
long long v32; // [rsp+18h] [rbp-40h]
long long v33; // [rsp+20h] [rbp-38h]
ggml_graph_cpy(a2, a4);
ggml_build_backward_expand(a1, a2, a4, 1LL);
if ( a6 <= 0 )
return ggml_graph_cpy(a4, a3);
v31 = a4;
v32 = a3;
v29 = a6;
v12 = *(_DWORD *)(a2 + 8) + a6 + *(_DWORD *)(a2 + 4);
v13 = (long long *)malloc(24LL);
v14 = ggml_hash_set_new(v12);
*v13 = v14;
v13[1] = v15;
v33 = 8 * v14;
v16 = malloc(8 * v14);
v13[2] = v16;
v17 = 0LL;
memset(v16, 0LL, v33);
v18 = *v13;
v19 = v13[1];
do
{
v20 = *(_QWORD *)(a5 + 8 * v17);
v21 = v20 % v18;
v22 = v20 % v18;
while ( 1 )
{
v23 = *(_QWORD *)(v19 + 8 * v22);
if ( !v23 || v23 == v20 )
break;
if ( ++v22 == v18 )
v22 = 0LL;
if ( v22 == v21 )
{
v22 = -1LL;
break;
}
}
if ( v22 == -1 )
ggml_build_backward_gradient_checkpointing_cold_2(v19, v18, v21, v20, v29);
if ( *(_QWORD *)(v19 + 8 * v22) )
ggml_build_backward_gradient_checkpointing_cold_1(v19, v18, v21, v20, v29);
*(_QWORD *)(v19 + 8 * v22) = v20;
*(_QWORD *)(v16 + 8 * v22) = *(_QWORD *)(a5 + 8 * v17++);
}
while ( v17 != v29 );
v30 = v16;
ggml_graph_cpy(a2, v32);
v24 = *(int *)(a2 + 4);
v25 = v31;
if ( (int)v24 < *(_DWORD *)(v31 + 4) )
{
do
{
v26 = *(_QWORD *)(*(_QWORD *)(v25 + 16) + 8 * v24);
for ( i = 20LL; i != 30; ++i )
*(_QWORD *)(v26 + 8 * i) = ggml_recompute_graph_node(a1, a2, v13, *(_QWORD *)(v26 + 8 * i));
ggml_build_forward_expand(v32, v26);
++v24;
v25 = v31;
}
while ( v24 < *(int *)(v31 + 4) );
}
free(v13[1]);
free(v30);
return free(v13);
}
| |||
11,328 |
ggml_build_backward_gradient_checkpointing
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
void ggml_build_backward_gradient_checkpointing(
struct ggml_context * ctx,
struct ggml_cgraph * gf,
struct ggml_cgraph * gb,
struct ggml_cgraph * gb_tmp,
struct ggml_tensor * * checkpoints,
int n_checkpoints) {
ggml_graph_cpy(gf, gb_tmp);
ggml_build_backward_expand(ctx, gf, gb_tmp, true);
if (n_checkpoints <= 0) {
ggml_graph_cpy(gb_tmp, gb);
return;
}
struct hash_map * replacements = ggml_new_hash_map(gf->n_nodes + gf->n_leafs + n_checkpoints);
// insert checkpoints in replacements
for (int i = 0; i < n_checkpoints; ++i) {
size_t k = ggml_hash_find(replacements->set, checkpoints[i]);
GGML_ASSERT(k != GGML_HASHTABLE_FULL); // assert that not full
GGML_ASSERT(replacements->set.keys[k] == NULL); // assert that we don't overwrite
replacements->set.keys[k] = checkpoints[i];
replacements->vals[k] = checkpoints[i];
}
ggml_graph_cpy(gf, gb);
// rewrite gb_tmp->nodes[gf->n_nodes:gb_tmp->n_nodes],
// replacing references to gb_tmp->nodes[0:gf->n_nodes] ( == gf->nodes[0:gf->n_nodes]),
// by recomputing them from checkpoints
for (int i = gf->n_nodes; i<gb_tmp->n_nodes; ++i) {
struct ggml_tensor * node = gb_tmp->nodes[i];
for (int k = 0; k < GGML_MAX_SRC; ++k) {
// insert new tensors recomputing src, reusing already made replacements,
// remember replacements: remember new tensors with mapping from corresponding gf nodes
// recurse for input tensors,
// unless (i.e. terminating when) input tensors are replacements (like checkpoints)
node->src[k] = ggml_recompute_graph_node(ctx, gf, replacements, node->src[k]);
}
// insert rewritten backward node with replacements made into resulting backward graph gb
ggml_build_forward_expand(gb, node);
}
ggml_hash_map_free(replacements);
}
|
O2
|
c
|
ggml_build_backward_gradient_checkpointing:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebp
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x6fcf6
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6fec3
testl %ebp, %ebp
jle 0x6fc64
movq %r14, 0x18(%rsp)
movq %rbx, 0x30(%rsp)
movl 0x4(%r15), %eax
addl %ebp, %eax
addl 0x8(%r15), %eax
movslq %eax, %r14
pushq $0x18
popq %rdi
callq 0xa7e0
movq %rax, %r13
movq %r14, %rdi
callq 0x702c6
movq %rdx, %rbx
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %rax, 0x20(%rsp)
leaq (,%rax,8), %rsi
pushq $0x1
popq %rdi
callq 0xa390
movl %ebp, %ecx
movq %rbx, %rbp
movq %rax, 0x10(%rsp)
movq %rax, 0x10(%r13)
movl %ecx, %eax
movq %rax, 0x28(%rsp)
xorl %ebx, %ebx
cmpq %rbx, 0x28(%rsp)
je 0x6fbd8
movq 0x8(%rsp), %rax
movq (%rax,%rbx,8), %r14
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x6f96c
cmpq $-0x1, %rax
je 0x6fc7d
cmpq $0x0, (%rbp,%rax,8)
jne 0x6fcb2
movq %r14, (%rbp,%rax,8)
movq 0x8(%rsp), %rcx
movq (%rcx,%rbx,8), %rcx
movq 0x10(%rsp), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rbx
jmp 0x6fb86
movq %rbp, 0x8(%rsp)
movq %r15, %rdi
movq 0x18(%rsp), %rsi
callq 0x6fcf6
movslq 0x4(%r15), %r14
movq 0x30(%rsp), %rcx
movslq 0x4(%rcx), %rax
cmpq %rax, %r14
jge 0x6fc3a
movq 0x10(%rcx), %rax
movq (%rax,%r14,8), %rbx
pushq $0x14
popq %rbp
cmpq $0x1e, %rbp
je 0x6fc28
movq (%rbx,%rbp,8), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x7001c
movq %rax, (%rbx,%rbp,8)
incq %rbp
jmp 0x6fc07
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x70258
incq %r14
jmp 0x6fbee
movq 0x8(%rsp), %rdi
callq 0xa710
movq 0x10(%rsp), %rdi
callq 0xa710
movq %r13, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa710
movq %rbx, %rdi
movq %r14, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6fcf6
movq 0x662c4(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x66315(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2a581(%rip), %rsi # 0x9a21e
leaq 0x31bda(%rip), %rdx # 0xa187e
leaq 0x32578(%rip), %r8 # 0xa2223
movl $0x3a6d, %ecx # imm = 0x3A6D
jmp 0x6fce5
movq 0x6628f(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x662e0(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2a54c(%rip), %rsi # 0x9a21e
leaq 0x31ba5(%rip), %rdx # 0xa187e
leaq 0x3255c(%rip), %r8 # 0xa223c
movl $0x3a6e, %ecx # imm = 0x3A6E
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
|
ggml_build_backward_gradient_checkpointing:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov ebp, r9d
mov [rsp+68h+var_60], r8
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
mov rdi, rsi
mov rsi, rcx
call ggml_graph_cpy
push 1
pop rcx
mov rdi, r12
mov rsi, r15
mov rdx, rbx
call ggml_build_backward_expand
test ebp, ebp
jle loc_6FC64
mov [rsp+68h+var_50], r14
mov [rsp+68h+var_38], rbx
mov eax, [r15+4]
add eax, ebp
add eax, [r15+8]
movsxd r14, eax
push 18h
pop rdi
call _malloc
mov r13, rax
mov rdi, r14
call ggml_hash_set_new
mov rbx, rdx
mov [r13+0], rax
mov [r13+8], rdx
mov [rsp+68h+var_48], rax
lea rsi, ds:0[rax*8]
push 1
pop rdi
call _calloc
mov ecx, ebp
mov rbp, rbx
mov [rsp+68h+var_58], rax
mov [r13+10h], rax
mov eax, ecx
mov [rsp+68h+var_40], rax
xor ebx, ebx
loc_6FB86:
cmp [rsp+68h+var_40], rbx
jz short loc_6FBD8
mov rax, [rsp+68h+var_60]
mov r14, [rax+rbx*8]
mov rdi, [rsp+68h+var_48]
mov rsi, rbp
mov rdx, r14
call ggml_hash_find
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_6FC7D
cmp qword ptr [rbp+rax*8+0], 0
jnz loc_6FCB2
mov [rbp+rax*8+0], r14
mov rcx, [rsp+68h+var_60]
mov rcx, [rcx+rbx*8]
mov rdx, [rsp+68h+var_58]
mov [rdx+rax*8], rcx
inc rbx
jmp short loc_6FB86
loc_6FBD8:
mov [rsp+68h+var_60], rbp
mov rdi, r15
mov rsi, [rsp+68h+var_50]
call ggml_graph_cpy
movsxd r14, dword ptr [r15+4]
loc_6FBEE:
mov rcx, [rsp+68h+var_38]
movsxd rax, dword ptr [rcx+4]
cmp r14, rax
jge short loc_6FC3A
mov rax, [rcx+10h]
mov rbx, [rax+r14*8]
push 14h
pop rbp
loc_6FC07:
cmp rbp, 1Eh
jz short loc_6FC28
mov rcx, [rbx+rbp*8]
mov rdi, r12
mov rsi, r15
mov rdx, r13
call ggml_recompute_graph_node
mov [rbx+rbp*8], rax
inc rbp
jmp short loc_6FC07
loc_6FC28:
mov rdi, [rsp+68h+var_50]
mov rsi, rbx
call ggml_build_forward_expand
inc r14
jmp short loc_6FBEE
loc_6FC3A:
mov rdi, [rsp+68h+var_60]
call _free
mov rdi, [rsp+68h+var_58]
call _free
mov rdi, r13
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _free
loc_6FC64:
mov rdi, rbx
mov rsi, r14
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp ggml_graph_cpy
loc_6FC7D:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aKGgmlHashtable; "k != GGML_HASHTABLE_FULL"
mov ecx, 3A6Dh
jmp short loc_6FCE5
loc_6FCB2:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aReplacementsSe; "replacements->set.keys[k] == NULL"
mov ecx, 3A6Eh
loc_6FCE5:
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
|
long long ggml_build_backward_gradient_checkpointing(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6)
{
long long v9; // r14
long long *v10; // r13
long long v11; // rax
long long v12; // rdx
long long v13; // rbx
long long v14; // rax
unsigned int v15; // ecx
long long v16; // rbp
long long i; // rbx
unsigned long long v18; // r14
long long v19; // rax
long long j; // r14
long long v21; // rbx
long long k; // rbp
long long v24; // rdi
long long v26; // [rsp+8h] [rbp-60h]
long long v27; // [rsp+10h] [rbp-58h]
long long v28; // [rsp+18h] [rbp-50h]
unsigned long long v29; // [rsp+20h] [rbp-48h]
long long v30; // [rsp+28h] [rbp-40h]
long long v31; // [rsp+30h] [rbp-38h]
ggml_graph_cpy(a2, a4);
ggml_build_backward_expand(a1, a2, a4, 1LL);
if ( a6 <= 0 )
return ggml_graph_cpy(a4, a3);
v28 = a3;
v31 = a4;
v9 = *(_DWORD *)(a2 + 8) + a6 + *(_DWORD *)(a2 + 4);
v10 = (long long *)malloc(24LL);
v11 = ggml_hash_set_new(v9);
v13 = v12;
*v10 = v11;
v10[1] = v12;
v29 = v11;
v14 = calloc(1LL, 8 * v11);
v15 = a6;
v16 = v13;
v27 = v14;
v10[2] = v14;
v30 = v15;
for ( i = 0LL; v30 != i; ++i )
{
v18 = *(_QWORD *)(a5 + 8 * i);
v19 = ggml_hash_find(v29, v16, v18);
if ( v19 == -1 )
{
fflush(stdout);
v24 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
14957LL,
"k != GGML_HASHTABLE_FULL");
goto LABEL_17;
}
if ( *(_QWORD *)(v16 + 8 * v19) )
{
fflush(stdout);
v24 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
14958LL,
"replacements->set.keys[k] == NULL");
LABEL_17:
ggml_print_backtrace();
abort(v24);
}
*(_QWORD *)(v16 + 8 * v19) = v18;
*(_QWORD *)(v27 + 8 * v19) = *(_QWORD *)(a5 + 8 * i);
}
v26 = v16;
ggml_graph_cpy(a2, v28);
for ( j = *(int *)(a2 + 4); j < *(int *)(v31 + 4); ++j )
{
v21 = *(_QWORD *)(*(_QWORD *)(v31 + 16) + 8 * j);
for ( k = 20LL; k != 30; ++k )
*(_QWORD *)(v21 + 8 * k) = ggml_recompute_graph_node(a1, a2, v10, *(_QWORD *)(v21 + 8 * k));
ggml_build_forward_expand(v28, v21);
}
free(v26);
free(v27);
return free(v10);
}
|
ggml_build_backward_gradient_checkpointing:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV EBP,R9D
MOV qword ptr [RSP + 0x8],R8
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
MOV RDI,RSI
MOV RSI,RCX
CALL 0x0016fcf6
PUSH 0x1
POP RCX
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBX
CALL 0x0016fec3
TEST EBP,EBP
JLE 0x0016fc64
MOV qword ptr [RSP + 0x18],R14
MOV qword ptr [RSP + 0x30],RBX
MOV EAX,dword ptr [R15 + 0x4]
ADD EAX,EBP
ADD EAX,dword ptr [R15 + 0x8]
MOVSXD R14,EAX
PUSH 0x18
POP RDI
CALL 0x0010a7e0
MOV R13,RAX
MOV RDI,R14
CALL 0x001702c6
MOV RBX,RDX
MOV qword ptr [R13],RAX
MOV qword ptr [R13 + 0x8],RDX
MOV qword ptr [RSP + 0x20],RAX
LEA RSI,[RAX*0x8]
PUSH 0x1
POP RDI
CALL 0x0010a390
MOV ECX,EBP
MOV RBP,RBX
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [R13 + 0x10],RAX
MOV EAX,ECX
MOV qword ptr [RSP + 0x28],RAX
XOR EBX,EBX
LAB_0016fb86:
CMP qword ptr [RSP + 0x28],RBX
JZ 0x0016fbd8
MOV RAX,qword ptr [RSP + 0x8]
MOV R14,qword ptr [RAX + RBX*0x8]
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,RBP
MOV RDX,R14
CALL 0x0016f96c
CMP RAX,-0x1
JZ 0x0016fc7d
CMP qword ptr [RBP + RAX*0x8],0x0
JNZ 0x0016fcb2
MOV qword ptr [RBP + RAX*0x8],R14
MOV RCX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RCX + RBX*0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV qword ptr [RDX + RAX*0x8],RCX
INC RBX
JMP 0x0016fb86
LAB_0016fbd8:
MOV qword ptr [RSP + 0x8],RBP
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0016fcf6
MOVSXD R14,dword ptr [R15 + 0x4]
LAB_0016fbee:
MOV RCX,qword ptr [RSP + 0x30]
MOVSXD RAX,dword ptr [RCX + 0x4]
CMP R14,RAX
JGE 0x0016fc3a
MOV RAX,qword ptr [RCX + 0x10]
MOV RBX,qword ptr [RAX + R14*0x8]
PUSH 0x14
POP RBP
LAB_0016fc07:
CMP RBP,0x1e
JZ 0x0016fc28
MOV RCX,qword ptr [RBX + RBP*0x8]
MOV RDI,R12
MOV RSI,R15
MOV RDX,R13
CALL 0x0017001c
MOV qword ptr [RBX + RBP*0x8],RAX
INC RBP
JMP 0x0016fc07
LAB_0016fc28:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,RBX
CALL 0x00170258
INC R14
JMP 0x0016fbee
LAB_0016fc3a:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0010a710
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0010a710
MOV RDI,R13
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0010a710
LAB_0016fc64:
MOV RDI,RBX
MOV RSI,R14
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0016fcf6
LAB_0016fc7d:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a2223]
MOV ECX,0x3a6d
JMP 0x0016fce5
LAB_0016fcb2:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a223c]
MOV ECX,0x3a6e
LAB_0016fce5:
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
void ggml_build_backward_gradient_checkpointing
(int8 param_1,long param_2,int8 param_3,long param_4,long param_5,
uint param_6)
{
int iVar1;
int iVar2;
long lVar3;
int1 (*__ptr) [16];
void *__ptr_00;
long lVar4;
int8 uVar5;
void *__ptr_01;
ulong uVar6;
long lVar7;
FILE *__stream;
char *pcVar8;
int1 auVar9 [16];
ggml_graph_cpy(param_2,param_4);
ggml_build_backward_expand(param_1,param_2,param_4,1);
if ((int)param_6 < 1) {
ggml_graph_cpy(param_4,param_3);
return;
}
iVar1 = *(int *)(param_2 + 4);
iVar2 = *(int *)(param_2 + 8);
__ptr = (int1 (*) [16])malloc(0x18);
auVar9 = ggml_hash_set_new((long)(int)(iVar1 + param_6 + iVar2));
__ptr_01 = auVar9._8_8_;
*__ptr = auVar9;
__ptr_00 = calloc(1,auVar9._0_8_ * 8);
*(void **)__ptr[1] = __ptr_00;
uVar6 = 0;
while( true ) {
if (param_6 == uVar6) {
ggml_graph_cpy(param_2,param_3);
for (lVar4 = (long)*(int *)(param_2 + 4); lVar4 < *(int *)(param_4 + 4); lVar4 = lVar4 + 1) {
lVar3 = *(long *)(*(long *)(param_4 + 0x10) + lVar4 * 8);
for (lVar7 = 0x14; lVar7 != 0x1e; lVar7 = lVar7 + 1) {
uVar5 = ggml_recompute_graph_node
(param_1,param_2,__ptr,*(int8 *)(lVar3 + lVar7 * 8));
*(int8 *)(lVar3 + lVar7 * 8) = uVar5;
}
ggml_build_forward_expand(param_3,lVar3);
}
free(__ptr_01);
free(__ptr_00);
free(__ptr);
return;
}
uVar5 = *(int8 *)(param_5 + uVar6 * 8);
lVar4 = ggml_hash_find(auVar9._0_8_,__ptr_01,uVar5);
if (lVar4 == -1) break;
if (*(long *)((long)__ptr_01 + lVar4 * 8) != 0) {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar8 = "replacements->set.keys[k] == NULL";
uVar5 = 0x3a6e;
goto LAB_0016fce5;
}
*(int8 *)((long)__ptr_01 + lVar4 * 8) = uVar5;
*(int8 *)((long)__ptr_00 + lVar4 * 8) = *(int8 *)(param_5 + uVar6 * 8);
uVar6 = uVar6 + 1;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar8 = "k != GGML_HASHTABLE_FULL";
uVar5 = 0x3a6d;
LAB_0016fce5:
fprintf(__stream,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
uVar5,pcVar8);
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
|
|
11,329 |
ggml_build_backward_gradient_checkpointing
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
void ggml_build_backward_gradient_checkpointing(
struct ggml_context * ctx,
struct ggml_cgraph * gf,
struct ggml_cgraph * gb,
struct ggml_cgraph * gb_tmp,
struct ggml_tensor * * checkpoints,
int n_checkpoints) {
ggml_graph_cpy(gf, gb_tmp);
ggml_build_backward_expand(ctx, gf, gb_tmp, true);
if (n_checkpoints <= 0) {
ggml_graph_cpy(gb_tmp, gb);
return;
}
struct hash_map * replacements = ggml_new_hash_map(gf->n_nodes + gf->n_leafs + n_checkpoints);
// insert checkpoints in replacements
for (int i = 0; i < n_checkpoints; ++i) {
size_t k = ggml_hash_find(replacements->set, checkpoints[i]);
GGML_ASSERT(k != GGML_HASHTABLE_FULL); // assert that not full
GGML_ASSERT(replacements->set.keys[k] == NULL); // assert that we don't overwrite
replacements->set.keys[k] = checkpoints[i];
replacements->vals[k] = checkpoints[i];
}
ggml_graph_cpy(gf, gb);
// rewrite gb_tmp->nodes[gf->n_nodes:gb_tmp->n_nodes],
// replacing references to gb_tmp->nodes[0:gf->n_nodes] ( == gf->nodes[0:gf->n_nodes]),
// by recomputing them from checkpoints
for (int i = gf->n_nodes; i<gb_tmp->n_nodes; ++i) {
struct ggml_tensor * node = gb_tmp->nodes[i];
for (int k = 0; k < GGML_MAX_SRC; ++k) {
// insert new tensors recomputing src, reusing already made replacements,
// remember replacements: remember new tensors with mapping from corresponding gf nodes
// recurse for input tensors,
// unless (i.e. terminating when) input tensors are replacements (like checkpoints)
node->src[k] = ggml_recompute_graph_node(ctx, gf, replacements, node->src[k]);
}
// insert rewritten backward node with replacements made into resulting backward graph gb
ggml_build_forward_expand(gb, node);
}
ggml_hash_map_free(replacements);
}
|
O3
|
c
|
ggml_build_backward_gradient_checkpointing:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x95141
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x95239
testl %ebp, %ebp
jle 0x9511e
movq %r13, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl 0x4(%r15), %eax
addl %ebp, %eax
addl 0x8(%r15), %eax
movslq %eax, %r14
movl $0x18, %edi
callq 0xa7b0
movq %rax, %r13
movq %r14, %rdi
callq 0x965eb
movq %rax, %r14
movl %ebp, (%rsp)
movq %rdx, %rbp
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
leaq (,%rax,8), %rsi
movl $0x1, %edi
callq 0xa380
movq %rax, %r9
movq %rax, 0x10(%r13)
movl (%rsp), %esi
xorl %edi, %edi
movq (%rbx,%rdi,8), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r14
movq %rdx, %rax
movq (%rbp,%rax,8), %r8
testq %r8, %r8
je 0x95064
cmpq %rcx, %r8
je 0x95064
incq %rax
cmpq %r14, %rax
movl $0x0, %r8d
cmoveq %r8, %rax
cmpq %rdx, %rax
jne 0x9503b
jmp 0x95137
cmpq $-0x1, %rax
je 0x95137
testq %r8, %r8
jne 0x9513c
movq %rcx, (%rbp,%rax,8)
movq (%rbx,%rdi,8), %rcx
movq %rcx, (%r9,%rax,8)
incq %rdi
cmpq %rsi, %rdi
jne 0x9502c
movq %r9, (%rsp)
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x95141
movslq 0x4(%r15), %r14
movq 0x8(%rsp), %rcx
cmpl 0x4(%rcx), %r14d
jge 0x950f6
movq 0x10(%rcx), %rax
movq (%rax,%r14,8), %rbx
movl $0x14, %ebp
movq (%rbx,%rbp,8), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x9631c
movq %rax, (%rbx,%rbp,8)
incq %rbp
cmpq $0x1e, %rbp
jne 0x950b9
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x965bc
incq %r14
movq 0x8(%rsp), %rcx
movslq 0x4(%rcx), %rax
cmpq %rax, %r14
jl 0x950ac
movq 0x8(%r13), %rdi
callq 0xa6f0
movq (%rsp), %rdi
callq 0xa6f0
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa6f0
movq %r13, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x95141
callq 0xf02b
callq 0xefe6
|
ggml_build_backward_gradient_checkpointing:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, r9d
mov rbx, r8
mov r13, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
mov rdi, rsi
mov rsi, rcx
call ggml_graph_cpy
mov rdi, r12
mov rsi, r15
mov rdx, r13
mov ecx, 1
call ggml_build_backward_expand
test ebp, ebp
jle loc_9511E
mov [rsp+48h+var_40], r13
mov [rsp+48h+var_38], r14
mov eax, [r15+4]
add eax, ebp
add eax, [r15+8]
movsxd r14, eax
mov edi, 18h
call _malloc
mov r13, rax
mov rdi, r14
call ggml_hash_set_new
mov r14, rax
mov dword ptr [rsp+48h+var_48], ebp
mov rbp, rdx
mov [r13+0], rax
mov [r13+8], rdx
lea rsi, ds:0[rax*8]
mov edi, 1
call _calloc
mov r9, rax
mov [r13+10h], rax
mov esi, dword ptr [rsp+48h+var_48]
xor edi, edi
loc_9502C:
mov rcx, [rbx+rdi*8]
mov rax, rcx
xor edx, edx
div r14
mov rax, rdx
loc_9503B:
mov r8, [rbp+rax*8+0]
test r8, r8
jz short loc_95064
cmp r8, rcx
jz short loc_95064
inc rax
cmp rax, r14
mov r8d, 0
cmovz rax, r8
cmp rax, rdx
jnz short loc_9503B
jmp loc_95137
loc_95064:
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_95137
test r8, r8
jnz loc_9513C
mov [rbp+rax*8+0], rcx
mov rcx, [rbx+rdi*8]
mov [r9+rax*8], rcx
inc rdi
cmp rdi, rsi
jnz short loc_9502C
mov [rsp+48h+var_48], r9
mov rdi, r15
mov rsi, [rsp+48h+var_38]
call ggml_graph_cpy
movsxd r14, dword ptr [r15+4]
mov rcx, [rsp+48h+var_40]
cmp r14d, [rcx+4]
jge short loc_950F6
loc_950AC:
mov rax, [rcx+10h]
mov rbx, [rax+r14*8]
mov ebp, 14h
loc_950B9:
mov rcx, [rbx+rbp*8]
mov rdi, r12
mov rsi, r15
mov rdx, r13
call ggml_recompute_graph_node
mov [rbx+rbp*8], rax
inc rbp
cmp rbp, 1Eh
jnz short loc_950B9
mov rdi, [rsp+48h+var_38]
mov rsi, rbx
call ggml_build_forward_expand
inc r14
mov rcx, [rsp+48h+var_40]
movsxd rax, dword ptr [rcx+4]
cmp r14, rax
jl short loc_950AC
loc_950F6:
mov rdi, [r13+8]
call _free
mov rdi, [rsp+48h+var_48]
call _free
mov rdi, r13
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _free
loc_9511E:
mov rdi, r13
mov rsi, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp ggml_graph_cpy
loc_95137:
call ggml_build_backward_gradient_checkpointing_cold_2
loc_9513C:
call ggml_build_backward_gradient_checkpointing_cold_1
|
long long ggml_build_backward_gradient_checkpointing(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6)
{
long long v11; // r14
unsigned long long *v12; // r13
unsigned long long v13; // r14
unsigned long long v14; // rdx
unsigned long long v15; // rbp
long long v16; // r9
long long i; // rdi
unsigned long long v18; // rcx
unsigned long long v19; // rdx
unsigned long long v20; // rax
long long v21; // r8
long long v22; // r14
long long v23; // rcx
long long v24; // rbx
long long j; // rbp
unsigned int v27; // [rsp+0h] [rbp-48h]
long long v28; // [rsp+0h] [rbp-48h]
long long v29; // [rsp+8h] [rbp-40h]
long long v30; // [rsp+10h] [rbp-38h]
ggml_graph_cpy(a2, a4);
ggml_build_backward_expand(a1, a2, a4, 1LL);
if ( a6 <= 0 )
return ggml_graph_cpy(a4, a3);
v29 = a4;
v30 = a3;
v11 = *(_DWORD *)(a2 + 8) + a6 + *(_DWORD *)(a2 + 4);
v12 = (unsigned long long *)malloc(24LL);
v13 = ggml_hash_set_new(v11);
v27 = a6;
v15 = v14;
*v12 = v13;
v12[1] = v14;
v16 = calloc(1LL, 8 * v13);
v12[2] = v16;
for ( i = 0LL; i != v27; *(_QWORD *)(v16 + 8 * v20) = *(_QWORD *)(a5 + 8 * i++) )
{
v18 = *(_QWORD *)(a5 + 8 * i);
v19 = v18 % v13;
v20 = v18 % v13;
while ( 1 )
{
v21 = *(_QWORD *)(v15 + 8 * v20);
if ( !v21 || v21 == v18 )
break;
++v20;
v21 = 0LL;
if ( v20 == v13 )
v20 = 0LL;
if ( v20 == v19 )
goto LABEL_19;
}
if ( v20 == -1LL )
LABEL_19:
ggml_build_backward_gradient_checkpointing_cold_2(i, v27, v19, v18, v21, v16);
if ( v21 )
ggml_build_backward_gradient_checkpointing_cold_1(i, v27, v19, v18, v21, v16);
*(_QWORD *)(v15 + 8 * v20) = v18;
}
v28 = v16;
ggml_graph_cpy(a2, v30);
v22 = *(int *)(a2 + 4);
v23 = v29;
if ( (int)v22 < *(_DWORD *)(v29 + 4) )
{
do
{
v24 = *(_QWORD *)(*(_QWORD *)(v23 + 16) + 8 * v22);
for ( j = 20LL; j != 30; ++j )
*(_QWORD *)(v24 + 8 * j) = ggml_recompute_graph_node(a1, a2, v12, *(_QWORD *)(v24 + 8 * j));
ggml_build_forward_expand(v30, v24);
++v22;
v23 = v29;
}
while ( v22 < *(int *)(v29 + 4) );
}
free(v12[1]);
free(v28);
return free(v12);
}
| |||
11,330 |
sqrt_align_fp2
|
corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/sqrt.c
|
static bool_t sqrt_align_fp2(vec384x out, const vec384x ret,
const vec384x sqrt, const vec384x inp)
{
static const vec384x sqrt_minus_1 = { { 0 }, { ONE_MONT_P } };
static const vec384x sqrt_sqrt_minus_1 = {
/*
* "magic" number is ±2^((p-3)/4)%p, which is "1/sqrt(2)",
* in quotes because 2*"1/sqrt(2)"^2 == -1 mod p, not 1,
* but it pivots into "complex" plane nevertheless...
*/
{ TO_LIMB_T(0x3e2f585da55c9ad1), TO_LIMB_T(0x4294213d86c18183),
TO_LIMB_T(0x382844c88b623732), TO_LIMB_T(0x92ad2afd19103e18),
TO_LIMB_T(0x1d794e4fac7cf0b9), TO_LIMB_T(0x0bd592fc7d825ec8) },
{ TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),
TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),
TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) }
};
static const vec384x sqrt_minus_sqrt_minus_1 = {
{ TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),
TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),
TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) },
{ TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),
TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),
TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) }
};
vec384x coeff, t0, t1;
bool_t is_sqrt, flag;
/*
* Instead of multiple trial squarings we can perform just one
* and see if the result is "rotated by multiple of 90°" in
* relation to |inp|, and "rotate" |ret| accordingly.
*/
sqr_fp2(t0, sqrt);
/* "sqrt(|inp|)"^2 = (a + b*i)^2 = (a^2-b^2) + 2ab*i */
/* (a^2-b^2) + 2ab*i == |inp| ? |ret| is spot on */
sub_fp2(t1, t0, inp);
is_sqrt = vec_is_zero(t1, sizeof(t1));
vec_copy(coeff, BLS12_381_Rx.p2, sizeof(coeff));
/* -(a^2-b^2) - 2ab*i == |inp| ? "rotate |ret| by 90°" */
add_fp2(t1, t0, inp);
vec_select(coeff, sqrt_minus_1, coeff, sizeof(coeff),
flag = vec_is_zero(t1, sizeof(t1)));
is_sqrt |= flag;
/* 2ab - (a^2-b^2)*i == |inp| ? "rotate |ret| by 135°" */
sub_fp(t1[0], t0[0], inp[1]);
add_fp(t1[1], t0[1], inp[0]);
vec_select(coeff, sqrt_sqrt_minus_1, coeff, sizeof(coeff),
flag = vec_is_zero(t1, sizeof(t1)));
is_sqrt |= flag;
/* -2ab + (a^2-b^2)*i == |inp| ? "rotate |ret| by 45°" */
add_fp(t1[0], t0[0], inp[1]);
sub_fp(t1[1], t0[1], inp[0]);
vec_select(coeff, sqrt_minus_sqrt_minus_1, coeff, sizeof(coeff),
flag = vec_is_zero(t1, sizeof(t1)));
is_sqrt |= flag;
/* actual "rotation" */
mul_fp2(out, ret, coeff);
return is_sqrt;
}
|
O2
|
c
|
sqrt_align_fp2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, %r15
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x5ad98
leaq -0x160(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x5acd4
pushq $0x60
popq %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x510f5
movq %rax, %r13
leaq 0x2333f(%rip), %rsi # 0x7fce8
leaq -0x100(%rbp), %rdi
movq %rbx, %rdx
callq 0x51055
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x5acb9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x510f5
movq %rax, %r12
leaq 0x245c5(%rip), %rsi # 0x80fa0
leaq -0x100(%rbp), %rdi
movq %rdi, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x51073
orq %r12, %r13
movq %r13, -0x30(%rbp)
leaq 0x30(%r15), %r12
movq %r14, %rdi
leaq -0xa0(%rbp), %rsi
movq %r12, %rdx
callq 0x5aa6c
leaq -0x130(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %r15, %rdx
callq 0x56a78
movq %r14, %rdi
movq %rbx, %rsi
callq 0x510f5
movq %rax, %r13
leaq 0x245cb(%rip), %rsi # 0x81000
leaq -0x100(%rbp), %rdi
movq %rdi, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x51073
movq %r14, %rdi
leaq -0xa0(%rbp), %rsi
movq %r12, %rdx
callq 0x56a78
leaq -0x130(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %r15, %rdx
callq 0x5aa6c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x510f5
movq %rax, %r14
leaq 0x245dc(%rip), %rsi # 0x81060
leaq -0x100(%rbp), %rdi
movq %rdi, %rdx
movq %rdi, %r15
movq %rbx, %rcx
movq %rax, %r8
callq 0x51073
orq %r14, %r13
orq -0x30(%rbp), %r13
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %r15, %rdx
callq 0x5ad73
movq %r13, %rax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
sqrt_align_fp2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 138h
mov r15, rcx
mov [rbp+var_40], rsi
mov [rbp+var_38], rdi
lea r12, [rbp+var_A0]
mov rdi, r12
mov rsi, rdx
call sqr_fp2
lea r14, [rbp+var_160]
mov rdi, r14
mov rsi, r12
mov rdx, r15
call _sub_fp2
push 60h ; '`'
pop rbx
mov rdi, r14
mov rsi, rbx
call vec_is_zero
mov r13, rax
lea rsi, BLS12_381_Rx
lea rdi, [rbp+var_100]
mov rdx, rbx
call vec_copy
mov rdi, r14
mov rsi, r12
mov rdx, r15
call add_fp2
mov rdi, r14
mov rsi, rbx
call vec_is_zero
mov r12, rax
lea rsi, sqrt_align_fp2_sqrt_minus_1
lea rdi, [rbp+var_100]
mov rdx, rdi
mov rcx, rbx
mov r8, rax
call vec_select
or r13, r12
mov [rbp+var_30], r13
lea r12, [r15+30h]
mov rdi, r14
lea rsi, [rbp+var_A0]
mov rdx, r12
call _sub_fp
lea rdi, [rbp+var_130]
lea rsi, [rbp+var_70]
mov rdx, r15
call add_fp
mov rdi, r14
mov rsi, rbx
call vec_is_zero
mov r13, rax
lea rsi, sqrt_align_fp2_sqrt_sqrt_minus_1
lea rdi, [rbp+var_100]
mov rdx, rdi
mov rcx, rbx
mov r8, rax
call vec_select
mov rdi, r14
lea rsi, [rbp+var_A0]
mov rdx, r12
call add_fp
lea rdi, [rbp+var_130]
lea rsi, [rbp+var_70]
mov rdx, r15
call _sub_fp
mov rdi, r14
mov rsi, rbx
call vec_is_zero
mov r14, rax
lea rsi, sqrt_align_fp2_sqrt_minus_sqrt_minus_1
lea rdi, [rbp+var_100]
mov rdx, rdi
mov r15, rdi
mov rcx, rbx
mov r8, rax
call vec_select
or r13, r14
or r13, [rbp+var_30]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_40]
mov rdx, r15
call mul_fp2
mov rax, r13
add rsp, 138h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long sqrt_align_fp2(long long a1, long long a2, long long a3, long long a4)
{
unsigned long long is_zero; // r13
unsigned long long v6; // r12
unsigned long long v7; // r13
unsigned long long v8; // r14
unsigned long long v9; // r13
_BYTE v11[48]; // [rsp+0h] [rbp-160h] BYREF
_BYTE v12[48]; // [rsp+30h] [rbp-130h] BYREF
_BYTE v13[96]; // [rsp+60h] [rbp-100h] BYREF
_BYTE v14[48]; // [rsp+C0h] [rbp-A0h] BYREF
_BYTE v15[48]; // [rsp+F0h] [rbp-70h] BYREF
long long v16; // [rsp+120h] [rbp-40h]
long long v17; // [rsp+128h] [rbp-38h]
unsigned long long v18; // [rsp+130h] [rbp-30h]
v16 = a2;
v17 = a1;
sqr_fp2((long long)v14, a3);
sub_fp2((long long)v11, (long long)v14, a4);
is_zero = vec_is_zero((long long)v11, 0x60uLL);
vec_copy((long long)v13, (long long)&BLS12_381_Rx, 0x60uLL);
add_fp2((long long)v11, (long long)v14, a4);
v6 = vec_is_zero((long long)v11, 0x60uLL);
vec_select((long long)v13, (long long)&sqrt_align_fp2_sqrt_minus_1, (long long)v13, 0x60uLL, v6);
v18 = v6 | is_zero;
sub_fp((long long)v11, (long long)v14, a4 + 48);
add_fp((long long)v12, (long long)v15, a4);
v7 = vec_is_zero((long long)v11, 0x60uLL);
vec_select((long long)v13, (long long)&sqrt_align_fp2_sqrt_sqrt_minus_1, (long long)v13, 0x60uLL, v7);
add_fp((long long)v11, (long long)v14, a4 + 48);
sub_fp((long long)v12, (long long)v15, a4);
v8 = vec_is_zero((long long)v11, 0x60uLL);
vec_select((long long)v13, (long long)&sqrt_align_fp2_sqrt_minus_sqrt_minus_1, (long long)v13, 0x60uLL, v8);
v9 = v18 | v8 | v7;
mul_fp2(v17, v16, (long long)v13);
return v9;
}
|
sqrt_align_fp2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x138
MOV R15,RCX
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x38],RDI
LEA R12,[RBP + -0xa0]
MOV RDI,R12
MOV RSI,RDX
CALL 0x0015ad98
LEA R14,[RBP + -0x160]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x0015acd4
PUSH 0x60
POP RBX
MOV RDI,R14
MOV RSI,RBX
CALL 0x001510f5
MOV R13,RAX
LEA RSI,[0x17fce8]
LEA RDI,[RBP + -0x100]
MOV RDX,RBX
CALL 0x00151055
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x0015acb9
MOV RDI,R14
MOV RSI,RBX
CALL 0x001510f5
MOV R12,RAX
LEA RSI,[0x180fa0]
LEA RDI,[RBP + -0x100]
MOV RDX,RDI
MOV RCX,RBX
MOV R8,RAX
CALL 0x00151073
OR R13,R12
MOV qword ptr [RBP + -0x30],R13
LEA R12,[R15 + 0x30]
MOV RDI,R14
LEA RSI,[RBP + -0xa0]
MOV RDX,R12
CALL 0x0015aa6c
LEA RDI,[RBP + -0x130]
LEA RSI,[RBP + -0x70]
MOV RDX,R15
CALL 0x00156a78
MOV RDI,R14
MOV RSI,RBX
CALL 0x001510f5
MOV R13,RAX
LEA RSI,[0x181000]
LEA RDI,[RBP + -0x100]
MOV RDX,RDI
MOV RCX,RBX
MOV R8,RAX
CALL 0x00151073
MOV RDI,R14
LEA RSI,[RBP + -0xa0]
MOV RDX,R12
CALL 0x00156a78
LEA RDI,[RBP + -0x130]
LEA RSI,[RBP + -0x70]
MOV RDX,R15
CALL 0x0015aa6c
MOV RDI,R14
MOV RSI,RBX
CALL 0x001510f5
MOV R14,RAX
LEA RSI,[0x181060]
LEA RDI,[RBP + -0x100]
MOV RDX,RDI
MOV R15,RDI
MOV RCX,RBX
MOV R8,RAX
CALL 0x00151073
OR R13,R14
OR R13,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,R15
CALL 0x0015ad73
MOV RAX,R13
ADD RSP,0x138
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong sqrt_align_fp2(int8 param_1,int8 param_2,int8 param_3,long param_4)
{
ulong uVar1;
ulong uVar2;
int1 local_168 [48];
int1 local_138 [48];
int1 local_108 [96];
int1 local_a8 [48];
int1 local_78 [48];
int8 local_48;
int8 local_40;
ulong local_38;
local_48 = param_2;
local_40 = param_1;
sqr_fp2(local_a8,param_3);
sub_fp2(local_168,local_a8,param_4);
uVar1 = vec_is_zero(local_168,0x60);
vec_copy(local_108,BLS12_381_Rx,0x60);
add_fp2(local_168,local_a8,param_4);
uVar2 = vec_is_zero(local_168,0x60);
vec_select(local_108,sqrt_align_fp2_sqrt_minus_1,local_108,0x60,uVar2);
local_38 = uVar1 | uVar2;
sub_fp(local_168,local_a8,param_4 + 0x30);
add_fp(local_138,local_78,param_4);
uVar1 = vec_is_zero(local_168,0x60);
vec_select(local_108,sqrt_align_fp2_sqrt_sqrt_minus_1,local_108,0x60,uVar1);
add_fp(local_168,local_a8,param_4 + 0x30);
sub_fp(local_138,local_78,param_4);
uVar2 = vec_is_zero(local_168,0x60);
vec_select(local_108,sqrt_align_fp2_sqrt_minus_sqrt_minus_1,local_108,0x60,uVar2);
uVar1 = uVar1 | uVar2 | local_38;
mul_fp2(local_40,local_48,local_108);
return uVar1;
}
|
|
11,331 |
mi_unpack_index_tuple
|
eloqsql/storage/myisam/mi_key.c
|
static
int mi_unpack_index_tuple(MI_INFO *info, uint keynr, uchar *record)
{
if (_mi_put_key_in_record(info, keynr, FALSE, record))
{
/* Impossible case; Can only happen if bug in code */
mi_print_error(info->s, HA_ERR_CRASHED);
info->lastpos= HA_OFFSET_ERROR; /* No active record */
my_errno= HA_ERR_CRASHED;
return 1;
}
return 0;
}
|
O3
|
c
|
mi_unpack_index_tuple:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rcx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x7b79a
testl %eax, %eax
je 0x7bcb9
movq (%rbx), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %edi
callq 0x7af4e
movq $-0x1, 0x170(%rbx)
callq 0xa1b22
movl $0x7e, (%rax)
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
mi_unpack_index_tuple:
push rbp
mov rbp, rsp
push r14
push rbx
mov rcx, rdx
mov rbx, rdi
xor r14d, r14d
xor edx, edx
call _mi_put_key_in_record
test eax, eax
jz short loc_7BCB9
mov rax, [rbx]
mov rsi, [rax+268h]
mov edi, 7Eh ; '~'
call mi_report_error
mov qword ptr [rbx+170h], 0FFFFFFFFFFFFFFFFh
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
mov r14d, 1
loc_7BCB9:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
|
long long mi_unpack_index_tuple(_QWORD *a1, unsigned int a2, long long a3)
{
unsigned int v3; // r14d
const char *v4; // rsi
v3 = 0;
if ( (unsigned int)mi_put_key_in_record((long long)a1, a2, 0, a3) )
{
v4 = *(const char **)(*a1 + 616LL);
mi_report_error(126, (long long)v4);
a1[46] = -1LL;
*(_DWORD *)my_thread_var(126LL, v4) = 126;
return 1;
}
return v3;
}
|
mi_unpack_index_tuple:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RCX,RDX
MOV RBX,RDI
XOR R14D,R14D
XOR EDX,EDX
CALL 0x0017b79a
TEST EAX,EAX
JZ 0x0017bcb9
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RAX + 0x268]
MOV EDI,0x7e
CALL 0x0017af4e
MOV qword ptr [RBX + 0x170],-0x1
CALL 0x001a1b22
MOV dword ptr [RAX],0x7e
MOV R14D,0x1
LAB_0017bcb9:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
bool mi_unpack_index_tuple(long *param_1,int8 param_2,int8 param_3)
{
int iVar1;
int4 *puVar2;
iVar1 = _mi_put_key_in_record(param_1,param_2,0,param_3);
if (iVar1 != 0) {
mi_report_error(0x7e,*(int8 *)(*param_1 + 0x268));
param_1[0x2e] = -1;
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7e;
}
return iVar1 != 0;
}
|
|
11,332 |
my_execvpe
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static int my_execvpe(const char *filename, char **argv, char **envp)
{
char *path, *p, *p_next, *p1;
char buf[PATH_MAX];
size_t filename_len, path_len;
BOOL eacces_error;
filename_len = strlen(filename);
if (filename_len == 0) {
errno = ENOENT;
return -1;
}
if (strchr(filename, '/'))
return execve(filename, argv, envp);
path = getenv("PATH");
if (!path)
path = (char *)"/bin:/usr/bin";
eacces_error = FALSE;
p = path;
for(p = path; p != NULL; p = p_next) {
p1 = strchr(p, ':');
if (!p1) {
p_next = NULL;
path_len = strlen(p);
} else {
p_next = p1 + 1;
path_len = p1 - p;
}
/* path too long */
if ((path_len + 1 + filename_len + 1) > PATH_MAX)
continue;
memcpy(buf, p, path_len);
buf[path_len] = '/';
memcpy(buf + path_len + 1, filename, filename_len);
buf[path_len + 1 + filename_len] = '\0';
execve(buf, argv, envp);
switch(errno) {
case EACCES:
eacces_error = TRUE;
break;
case ENOENT:
case ENOTDIR:
break;
default:
return -1;
}
}
if (eacces_error)
errno = EACCES;
return -1;
}
|
O0
|
c
|
my_execvpe:
subq $0x1068, %rsp # imm = 0x1068
movq %rdi, 0x1058(%rsp)
movq %rsi, 0x1050(%rsp)
movq %rdx, 0x1048(%rsp)
movq 0x1058(%rsp), %rdi
callq 0xe240
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1c214
callq 0xe0b0
movl $0x2, (%rax)
movl $0xffffffff, 0x1064(%rsp) # imm = 0xFFFFFFFF
jmp 0x1c42b
movq 0x1058(%rsp), %rdi
movl $0x2f, %esi
callq 0xe270
cmpq $0x0, %rax
je 0x1c255
movq 0x1058(%rsp), %rdi
movq 0x1050(%rsp), %rsi
movq 0x1048(%rsp), %rdx
callq 0xe4c0
movl %eax, 0x1064(%rsp)
jmp 0x1c42b
leaq 0xec85a(%rip), %rdi # 0x108ab6
callq 0xe040
movq %rax, 0x1040(%rsp)
cmpq $0x0, 0x1040(%rsp)
jne 0x1c283
leaq 0xec840(%rip), %rax # 0x108abb
movq %rax, 0x1040(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x1040(%rsp), %rax
movq %rax, 0x1038(%rsp)
movq 0x1040(%rsp), %rax
movq %rax, 0x1038(%rsp)
cmpq $0x0, 0x1038(%rsp)
je 0x1c40e
movq 0x1038(%rsp), %rdi
movl $0x3a, %esi
callq 0xe270
movq %rax, 0x1028(%rsp)
cmpq $0x0, 0x1028(%rsp)
jne 0x1c2ff
movq $0x0, 0x1030(%rsp)
movq 0x1038(%rsp), %rdi
callq 0xe240
movq %rax, 0x10(%rsp)
jmp 0x1c32b
movq 0x1028(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1030(%rsp)
movq 0x1028(%rsp), %rax
movq 0x1038(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
addq 0x18(%rsp), %rax
addq $0x1, %rax
cmpq $0x1000, %rax # imm = 0x1000
jbe 0x1c34a
jmp 0x1c3f9
movq 0x1038(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xe5a0
movq 0x10(%rsp), %rax
movb $0x2f, 0x20(%rsp,%rax)
movq 0x10(%rsp), %rax
leaq 0x21(%rsp,%rax), %rdi
movq 0x1058(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xe5a0
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
addq %rcx, %rax
movb $0x0, 0x21(%rsp,%rax)
movq 0x1050(%rsp), %rsi
movq 0x1048(%rsp), %rdx
callq 0xe4c0
callq 0xe0b0
movl (%rax), %eax
movl %eax, 0x8(%rsp)
subl $0x2, %eax
je 0x1c3e8
jmp 0x1c3c8
movl 0x8(%rsp), %eax
subl $0xd, %eax
je 0x1c3de
jmp 0x1c3d3
movl 0x8(%rsp), %eax
subl $0x14, %eax
je 0x1c3e8
jmp 0x1c3ea
movl $0x1, 0xc(%rsp)
jmp 0x1c3f7
jmp 0x1c3f7
movl $0xffffffff, 0x1064(%rsp) # imm = 0xFFFFFFFF
jmp 0x1c42b
jmp 0x1c3f9
movq 0x1030(%rsp), %rax
movq %rax, 0x1038(%rsp)
jmp 0x1c2ab
cmpl $0x0, 0xc(%rsp)
je 0x1c420
callq 0xe0b0
movl $0xd, (%rax)
movl $0xffffffff, 0x1064(%rsp) # imm = 0xFFFFFFFF
movl 0x1064(%rsp), %eax
addq $0x1068, %rsp # imm = 0x1068
retq
nopw (%rax,%rax)
|
my_execvpe:
sub rsp, 1068h
mov [rsp+1068h+var_10], rdi
mov [rsp+1068h+var_18], rsi
mov [rsp+1068h+var_20], rdx
mov rdi, [rsp+1068h+var_10]
call _strlen
mov [rsp+1068h+var_1050], rax
cmp [rsp+1068h+var_1050], 0
jnz short loc_1C214
call ___errno_location
mov dword ptr [rax], 2
mov [rsp+1068h+var_4], 0FFFFFFFFh
jmp loc_1C42B
loc_1C214:
mov rdi, [rsp+1068h+var_10]
mov esi, 2Fh ; '/'
call _strchr
cmp rax, 0
jz short loc_1C255
mov rdi, [rsp+1068h+var_10]
mov rsi, [rsp+1068h+var_18]
mov rdx, [rsp+1068h+var_20]
call _execve
mov [rsp+1068h+var_4], eax
jmp loc_1C42B
loc_1C255:
lea rdi, aPath; "PATH"
call _getenv
mov [rsp+1068h+var_28], rax
cmp [rsp+1068h+var_28], 0
jnz short loc_1C283
lea rax, aBinUsrBin; "/bin:/usr/bin"
mov [rsp+1068h+var_28], rax
loc_1C283:
mov [rsp+1068h+var_105C], 0
mov rax, [rsp+1068h+var_28]
mov [rsp+1068h+var_30], rax
mov rax, [rsp+1068h+var_28]
mov [rsp+1068h+var_30], rax
loc_1C2AB:
cmp [rsp+1068h+var_30], 0
jz loc_1C40E
mov rdi, [rsp+1068h+var_30]
mov esi, 3Ah ; ':'
call _strchr
mov [rsp+1068h+var_40], rax
cmp [rsp+1068h+var_40], 0
jnz short loc_1C2FF
mov [rsp+1068h+var_38], 0
mov rdi, [rsp+1068h+var_30]
call _strlen
mov [rsp+1068h+var_1058], rax
jmp short loc_1C32B
loc_1C2FF:
mov rax, [rsp+1068h+var_40]
add rax, 1
mov [rsp+1068h+var_38], rax
mov rax, [rsp+1068h+var_40]
mov rcx, [rsp+1068h+var_30]
sub rax, rcx
mov [rsp+1068h+var_1058], rax
loc_1C32B:
mov rax, [rsp+1068h+var_1058]
add rax, 1
add rax, [rsp+1068h+var_1050]
add rax, 1
cmp rax, 1000h
jbe short loc_1C34A
jmp loc_1C3F9
loc_1C34A:
mov rsi, [rsp+1068h+var_30]
mov rdx, [rsp+1068h+var_1058]
lea rdi, [rsp+1068h+var_1048]
mov [rsp+1068h+var_1068], rdi
call _memcpy
mov rax, [rsp+1068h+var_1058]
mov [rsp+rax+1068h+var_1048], 2Fh ; '/'
mov rax, [rsp+1068h+var_1058]
lea rdi, [rsp+rax+1068h+var_1047]
mov rsi, [rsp+1068h+var_10]
mov rdx, [rsp+1068h+var_1050]
call _memcpy
mov rdi, [rsp+1068h+var_1068]
mov rax, [rsp+1068h+var_1058]
mov rcx, [rsp+1068h+var_1050]
add rax, rcx
mov [rsp+rax+1068h+var_1047], 0
mov rsi, [rsp+1068h+var_18]
mov rdx, [rsp+1068h+var_20]
call _execve
call ___errno_location
mov eax, [rax]
mov [rsp+1068h+var_1060], eax
sub eax, 2
jz short loc_1C3E8
jmp short $+2
loc_1C3C8:
mov eax, [rsp+1068h+var_1060]
sub eax, 0Dh
jz short loc_1C3DE
jmp short $+2
loc_1C3D3:
mov eax, [rsp+1068h+var_1060]
sub eax, 14h
jz short loc_1C3E8
jmp short loc_1C3EA
loc_1C3DE:
mov [rsp+1068h+var_105C], 1
jmp short loc_1C3F7
loc_1C3E8:
jmp short loc_1C3F7
loc_1C3EA:
mov [rsp+1068h+var_4], 0FFFFFFFFh
jmp short loc_1C42B
loc_1C3F7:
jmp short $+2
loc_1C3F9:
mov rax, [rsp+1068h+var_38]
mov [rsp+1068h+var_30], rax
jmp loc_1C2AB
loc_1C40E:
cmp [rsp+1068h+var_105C], 0
jz short loc_1C420
call ___errno_location
mov dword ptr [rax], 0Dh
loc_1C420:
mov [rsp+1068h+var_4], 0FFFFFFFFh
loc_1C42B:
mov eax, [rsp+1068h+var_4]
add rsp, 1068h
retn
|
long long my_execvpe(long long a1, long long a2, long long a3)
{
int v4; // [rsp+8h] [rbp-1060h]
int v5; // [rsp+Ch] [rbp-105Ch]
long long v6; // [rsp+10h] [rbp-1058h]
long long v7; // [rsp+18h] [rbp-1050h]
_BYTE v8[4104]; // [rsp+20h] [rbp-1048h] BYREF
long long v9; // [rsp+1028h] [rbp-40h]
long long v10; // [rsp+1030h] [rbp-38h]
const char *i; // [rsp+1038h] [rbp-30h]
const char *v12; // [rsp+1040h] [rbp-28h]
long long v13; // [rsp+1048h] [rbp-20h]
long long v14; // [rsp+1050h] [rbp-18h]
long long v15; // [rsp+1058h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v7 = strlen(a1);
if ( v7 )
{
if ( strchr(v15, 47LL) )
{
return (unsigned int)execve(v15, v14, v13);
}
else
{
v12 = (const char *)getenv("PATH");
if ( !v12 )
v12 = "/bin:/usr/bin";
v5 = 0;
for ( i = v12; i; i = (const char *)v10 )
{
v9 = strchr(i, 58LL);
if ( v9 )
{
v10 = v9 + 1;
v6 = v9 - (_QWORD)i;
}
else
{
v10 = 0LL;
v6 = strlen(i);
}
if ( (unsigned long long)(v7 + v6 + 1 + 1) <= 0x1000 )
{
memcpy(v8, i, v6);
v8[v6] = 47;
memcpy(&v8[v6 + 1], v15, v7);
v8[v7 + 1 + v6] = 0;
execve(v8, v14, v13);
v4 = *(_DWORD *)__errno_location();
if ( v4 != 2 )
{
if ( v4 == 13 )
{
v5 = 1;
}
else if ( v4 != 20 )
{
return (unsigned int)-1;
}
}
}
}
if ( v5 )
*(_DWORD *)__errno_location() = 13;
return (unsigned int)-1;
}
}
else
{
*(_DWORD *)__errno_location() = 2;
return (unsigned int)-1;
}
}
|
my_execvpe:
SUB RSP,0x1068
MOV qword ptr [RSP + 0x1058],RDI
MOV qword ptr [RSP + 0x1050],RSI
MOV qword ptr [RSP + 0x1048],RDX
MOV RDI,qword ptr [RSP + 0x1058]
CALL 0x0010e240
MOV qword ptr [RSP + 0x18],RAX
CMP qword ptr [RSP + 0x18],0x0
JNZ 0x0011c214
CALL 0x0010e0b0
MOV dword ptr [RAX],0x2
MOV dword ptr [RSP + 0x1064],0xffffffff
JMP 0x0011c42b
LAB_0011c214:
MOV RDI,qword ptr [RSP + 0x1058]
MOV ESI,0x2f
CALL 0x0010e270
CMP RAX,0x0
JZ 0x0011c255
MOV RDI,qword ptr [RSP + 0x1058]
MOV RSI,qword ptr [RSP + 0x1050]
MOV RDX,qword ptr [RSP + 0x1048]
CALL 0x0010e4c0
MOV dword ptr [RSP + 0x1064],EAX
JMP 0x0011c42b
LAB_0011c255:
LEA RDI,[0x208ab6]
CALL 0x0010e040
MOV qword ptr [RSP + 0x1040],RAX
CMP qword ptr [RSP + 0x1040],0x0
JNZ 0x0011c283
LEA RAX,[0x208abb]
MOV qword ptr [RSP + 0x1040],RAX
LAB_0011c283:
MOV dword ptr [RSP + 0xc],0x0
MOV RAX,qword ptr [RSP + 0x1040]
MOV qword ptr [RSP + 0x1038],RAX
MOV RAX,qword ptr [RSP + 0x1040]
MOV qword ptr [RSP + 0x1038],RAX
LAB_0011c2ab:
CMP qword ptr [RSP + 0x1038],0x0
JZ 0x0011c40e
MOV RDI,qword ptr [RSP + 0x1038]
MOV ESI,0x3a
CALL 0x0010e270
MOV qword ptr [RSP + 0x1028],RAX
CMP qword ptr [RSP + 0x1028],0x0
JNZ 0x0011c2ff
MOV qword ptr [RSP + 0x1030],0x0
MOV RDI,qword ptr [RSP + 0x1038]
CALL 0x0010e240
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0011c32b
LAB_0011c2ff:
MOV RAX,qword ptr [RSP + 0x1028]
ADD RAX,0x1
MOV qword ptr [RSP + 0x1030],RAX
MOV RAX,qword ptr [RSP + 0x1028]
MOV RCX,qword ptr [RSP + 0x1038]
SUB RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
LAB_0011c32b:
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x1
ADD RAX,qword ptr [RSP + 0x18]
ADD RAX,0x1
CMP RAX,0x1000
JBE 0x0011c34a
JMP 0x0011c3f9
LAB_0011c34a:
MOV RSI,qword ptr [RSP + 0x1038]
MOV RDX,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x20]
MOV qword ptr [RSP],RDI
CALL 0x0010e5a0
MOV RAX,qword ptr [RSP + 0x10]
MOV byte ptr [RSP + RAX*0x1 + 0x20],0x2f
MOV RAX,qword ptr [RSP + 0x10]
LEA RDI,[RSP + RAX*0x1 + 0x21]
MOV RSI,qword ptr [RSP + 0x1058]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0010e5a0
MOV RDI,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
ADD RAX,RCX
MOV byte ptr [RSP + RAX*0x1 + 0x21],0x0
MOV RSI,qword ptr [RSP + 0x1050]
MOV RDX,qword ptr [RSP + 0x1048]
CALL 0x0010e4c0
CALL 0x0010e0b0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x8],EAX
SUB EAX,0x2
JZ 0x0011c3e8
JMP 0x0011c3c8
LAB_0011c3c8:
MOV EAX,dword ptr [RSP + 0x8]
SUB EAX,0xd
JZ 0x0011c3de
JMP 0x0011c3d3
LAB_0011c3d3:
MOV EAX,dword ptr [RSP + 0x8]
SUB EAX,0x14
JZ 0x0011c3e8
JMP 0x0011c3ea
LAB_0011c3de:
MOV dword ptr [RSP + 0xc],0x1
JMP 0x0011c3f7
LAB_0011c3e8:
JMP 0x0011c3f7
LAB_0011c3ea:
MOV dword ptr [RSP + 0x1064],0xffffffff
JMP 0x0011c42b
LAB_0011c3f7:
JMP 0x0011c3f9
LAB_0011c3f9:
MOV RAX,qword ptr [RSP + 0x1030]
MOV qword ptr [RSP + 0x1038],RAX
JMP 0x0011c2ab
LAB_0011c40e:
CMP dword ptr [RSP + 0xc],0x0
JZ 0x0011c420
CALL 0x0010e0b0
MOV dword ptr [RAX],0xd
LAB_0011c420:
MOV dword ptr [RSP + 0x1064],0xffffffff
LAB_0011c42b:
MOV EAX,dword ptr [RSP + 0x1064]
ADD RSP,0x1068
RET
|
int my_execvpe(char *param_1,char **param_2,char **param_3)
{
int iVar1;
bool bVar2;
size_t __n;
int *piVar3;
char *pcVar4;
size_t local_1058;
char local_1048 [4104];
char *local_40;
char *local_38;
char *local_30;
char *local_28;
char **local_20;
char **local_18;
char *local_10;
int local_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
__n = strlen(param_1);
if (__n == 0) {
piVar3 = __errno_location();
*piVar3 = 2;
local_4 = -1;
}
else {
pcVar4 = strchr(local_10,0x2f);
if (pcVar4 == (char *)0x0) {
local_28 = getenv("PATH");
if (local_28 == (char *)0x0) {
local_28 = "/bin:/usr/bin";
}
bVar2 = false;
local_30 = local_28;
while (local_30 != (char *)0x0) {
local_40 = strchr(local_30,0x3a);
if (local_40 == (char *)0x0) {
local_38 = (char *)0x0;
local_1058 = strlen(local_30);
}
else {
local_38 = local_40 + 1;
local_1058 = (long)local_40 - (long)local_30;
}
if (local_1058 + __n + 2 < 0x1001) {
memcpy(local_1048,local_30,local_1058);
local_1048[local_1058] = '/';
memcpy(local_1048 + local_1058 + 1,local_10,__n);
local_1048[local_1058 + __n + 1] = '\0';
execve(local_1048,local_18,local_20);
piVar3 = __errno_location();
iVar1 = *piVar3;
if (iVar1 != 2) {
if (iVar1 == 0xd) {
bVar2 = true;
}
else if (iVar1 != 0x14) {
return -1;
}
}
}
local_30 = local_38;
}
if (bVar2) {
piVar3 = __errno_location();
*piVar3 = 0xd;
}
local_4 = -1;
}
else {
local_4 = execve(local_10,local_18,local_20);
}
}
return local_4;
}
|
|
11,333 |
my_execvpe
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static int my_execvpe(const char *filename, char **argv, char **envp)
{
char *path, *p, *p_next, *p1;
char buf[PATH_MAX];
size_t filename_len, path_len;
BOOL eacces_error;
filename_len = strlen(filename);
if (filename_len == 0) {
errno = ENOENT;
return -1;
}
if (strchr(filename, '/'))
return execve(filename, argv, envp);
path = getenv("PATH");
if (!path)
path = (char *)"/bin:/usr/bin";
eacces_error = FALSE;
p = path;
for(p = path; p != NULL; p = p_next) {
p1 = strchr(p, ':');
if (!p1) {
p_next = NULL;
path_len = strlen(p);
} else {
p_next = p1 + 1;
path_len = p1 - p;
}
/* path too long */
if ((path_len + 1 + filename_len + 1) > PATH_MAX)
continue;
memcpy(buf, p, path_len);
buf[path_len] = '/';
memcpy(buf + path_len + 1, filename, filename_len);
buf[path_len + 1 + filename_len] = '\0';
execve(buf, argv, envp);
switch(errno) {
case EACCES:
eacces_error = TRUE;
break;
case ENOENT:
case ENOTDIR:
break;
default:
return -1;
}
}
if (eacces_error)
errno = EACCES;
return -1;
}
|
O3
|
c
|
my_execvpe:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1038, %rsp # imm = 0x1038
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
callq 0xe240
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1ab9f
movq %rbx, %rdi
movl $0x2f, %esi
callq 0xe270
testq %rax, %rax
je 0x1abaf
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x1038, %rsp # imm = 0x1038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe4c0
callq 0xe0b0
movl $0x2, (%rax)
jmp 0x1acab
movq %rbx, 0x28(%rsp)
leaq 0x82e0c(%rip), %rdi # 0x9d9c7
callq 0xe040
testq %rax, %rax
leaq 0x82e02(%rip), %r14 # 0x9d9cc
cmovneq %rax, %r14
movq 0x10(%rsp), %r12
incq %r12
movb $0x1, %al
movl %eax, 0xc(%rsp)
movq %r14, %rbp
movq %r14, %rdi
movl $0x3a, %esi
callq 0xe270
testq %rax, %rax
je 0x1abfd
movq %rax, %r13
leaq 0x1(%rax), %r14
subq %rbp, %r13
jmp 0x1ac0b
movq %rbp, %rdi
callq 0xe240
movq %rax, %r13
xorl %r14d, %r14d
leaq (%r12,%r13), %rax
addq $-0x1000, %rax # imm = 0xF000
cmpq $-0x1001, %rax # imm = 0xEFFF
jb 0x1ac7c
leaq (%r12,%r13), %rbx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0xe5a0
movb $0x2f, 0x30(%rsp,%r13)
leaq 0x31(%rsp), %rax
addq %rax, %r13
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xe5a0
movb $0x0, 0x30(%rsp,%rbx)
movq %r15, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xe4c0
callq 0xe0b0
movl (%rax), %eax
cmpl $0x2, %eax
je 0x1ac7c
cmpl $0x14, %eax
jne 0x1ac87
testq %r14, %r14
jne 0x1abdc
jmp 0x1ac99
cmpl $0xd, %eax
jne 0x1acab
xorl %eax, %eax
testq %r14, %r14
jne 0x1abd8
jmp 0x1aca0
testb $0x1, 0xc(%rsp)
jne 0x1acab
callq 0xe0b0
movl $0xd, (%rax)
addq $0x1038, %rsp # imm = 0x1038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_execvpe:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1038h
mov [rsp+1068h+var_1048], rdx
mov [rsp+1068h+var_1050], rsi
mov rbx, rdi
call _strlen
mov [rsp+1068h+var_1058], rax
test rax, rax
jz short loc_1AB9F
mov rdi, rbx
mov esi, 2Fh ; '/'
call _strchr
test rax, rax
jz short loc_1ABAF
mov rdi, rbx
mov rsi, [rsp+1068h+var_1050]
mov rdx, [rsp+1068h+var_1048]
add rsp, 1038h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _execve
loc_1AB9F:
call ___errno_location
mov dword ptr [rax], 2
jmp loc_1ACAB
loc_1ABAF:
mov [rsp+1068h+var_1040], rbx
lea rdi, aPath; "PATH"
call _getenv
test rax, rax
lea r14, aBinUsrBin; "/bin:/usr/bin"
cmovnz r14, rax
mov r12, [rsp+1068h+var_1058]
inc r12
mov al, 1
loc_1ABD8:
mov [rsp+1068h+var_105C], eax
loc_1ABDC:
mov rbp, r14
mov rdi, r14
mov esi, 3Ah ; ':'
call _strchr
test rax, rax
jz short loc_1ABFD
mov r13, rax
lea r14, [rax+1]
sub r13, rbp
jmp short loc_1AC0B
loc_1ABFD:
mov rdi, rbp
call _strlen
mov r13, rax
xor r14d, r14d
loc_1AC0B:
lea rax, [r12+r13]
add rax, 0FFFFFFFFFFFFF000h
cmp rax, 0FFFFFFFFFFFFEFFFh
jb short loc_1AC7C
lea rbx, [r12+r13]
lea r15, [rsp+1068h+var_1038]
mov rdi, r15
mov rsi, rbp
mov rdx, r13
call _memcpy
mov [rsp+r13+1068h+var_1038], 2Fh ; '/'
lea rax, [rsp+1068h+var_1037]
add r13, rax
mov rdi, r13
mov rsi, [rsp+1068h+var_1040]
mov rdx, [rsp+1068h+var_1058]
call _memcpy
mov [rsp+rbx+1068h+var_1038], 0
mov rdi, r15
mov rsi, [rsp+1068h+var_1050]
mov rdx, [rsp+1068h+var_1048]
call _execve
call ___errno_location
mov eax, [rax]
cmp eax, 2
jz short loc_1AC7C
cmp eax, 14h
jnz short loc_1AC87
loc_1AC7C:
test r14, r14
jnz loc_1ABDC
jmp short loc_1AC99
loc_1AC87:
cmp eax, 0Dh
jnz short loc_1ACAB
xor eax, eax
test r14, r14
jnz loc_1ABD8
jmp short loc_1ACA0
loc_1AC99:
test byte ptr [rsp+1068h+var_105C], 1
jnz short loc_1ACAB
loc_1ACA0:
call ___errno_location
mov dword ptr [rax], 0Dh
loc_1ACAB:
add rsp, 1038h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long my_execvpe(long long a1, long long a2, long long a3)
{
unsigned long long result; // rax
long long v5; // rax
const char *v6; // r14
long long v7; // r12
char v8; // al
const char *v9; // rbp
const char *v10; // rdi
long long v11; // rax
long long v12; // r13
char v13; // [rsp+Ch] [rbp-105Ch]
long long v14; // [rsp+10h] [rbp-1058h]
_BYTE v16[4152]; // [rsp+30h] [rbp-1038h] BYREF
v14 = strlen(a1);
if ( v14 )
{
if ( strchr(a1, 47LL) )
{
return execve(a1, a2, a3);
}
else
{
v5 = getenv("PATH");
v6 = "/bin:/usr/bin";
if ( v5 )
v6 = (const char *)v5;
v7 = v14 + 1;
v8 = 1;
while ( 2 )
{
v13 = v8;
while ( 1 )
{
v9 = v6;
v10 = v6;
v11 = strchr(v6, 58LL);
if ( v11 )
{
v6 = (const char *)(v11 + 1);
v12 = v11 - (_QWORD)v9;
}
else
{
v10 = v6;
v12 = strlen(v6);
v6 = 0LL;
}
result = v7 + v12 - 4096;
if ( result >= 0xFFFFFFFFFFFFEFFFLL )
{
memcpy(v16, v9, v12);
v16[v12] = 47;
memcpy(&v16[v12 + 1], a1, v14);
v16[v7 + v12] = 0;
v10 = v16;
execve(v16, a2, a3);
result = *(unsigned int *)__errno_location(v16);
if ( (_DWORD)result != 2 && (_DWORD)result != 20 )
break;
}
if ( !v6 )
{
if ( (v13 & 1) != 0 )
return result;
goto LABEL_21;
}
}
if ( (_DWORD)result != 13 )
return result;
v8 = 0;
if ( v6 )
continue;
break;
}
LABEL_21:
result = __errno_location(v10);
*(_DWORD *)result = 13;
}
}
else
{
result = __errno_location(a1);
*(_DWORD *)result = 2;
}
return result;
}
|
my_execvpe:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1038
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x18],RSI
MOV RBX,RDI
CALL 0x0010e240
MOV qword ptr [RSP + 0x10],RAX
TEST RAX,RAX
JZ 0x0011ab9f
MOV RDI,RBX
MOV ESI,0x2f
CALL 0x0010e270
TEST RAX,RAX
JZ 0x0011abaf
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
ADD RSP,0x1038
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0010e4c0
LAB_0011ab9f:
CALL 0x0010e0b0
MOV dword ptr [RAX],0x2
JMP 0x0011acab
LAB_0011abaf:
MOV qword ptr [RSP + 0x28],RBX
LEA RDI,[0x19d9c7]
CALL 0x0010e040
TEST RAX,RAX
LEA R14,[0x19d9cc]
CMOVNZ R14,RAX
MOV R12,qword ptr [RSP + 0x10]
INC R12
MOV AL,0x1
LAB_0011abd8:
MOV dword ptr [RSP + 0xc],EAX
LAB_0011abdc:
MOV RBP,R14
MOV RDI,R14
MOV ESI,0x3a
CALL 0x0010e270
TEST RAX,RAX
JZ 0x0011abfd
MOV R13,RAX
LEA R14,[RAX + 0x1]
SUB R13,RBP
JMP 0x0011ac0b
LAB_0011abfd:
MOV RDI,RBP
CALL 0x0010e240
MOV R13,RAX
XOR R14D,R14D
LAB_0011ac0b:
LEA RAX,[R12 + R13*0x1]
ADD RAX,-0x1000
CMP RAX,-0x1001
JC 0x0011ac7c
LEA RBX,[R12 + R13*0x1]
LEA R15,[RSP + 0x30]
MOV RDI,R15
MOV RSI,RBP
MOV RDX,R13
CALL 0x0010e5a0
MOV byte ptr [RSP + R13*0x1 + 0x30],0x2f
LEA RAX,[RSP + 0x31]
ADD R13,RAX
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0010e5a0
MOV byte ptr [RSP + RBX*0x1 + 0x30],0x0
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0010e4c0
CALL 0x0010e0b0
MOV EAX,dword ptr [RAX]
CMP EAX,0x2
JZ 0x0011ac7c
CMP EAX,0x14
JNZ 0x0011ac87
LAB_0011ac7c:
TEST R14,R14
JNZ 0x0011abdc
JMP 0x0011ac99
LAB_0011ac87:
CMP EAX,0xd
JNZ 0x0011acab
XOR EAX,EAX
TEST R14,R14
JNZ 0x0011abd8
JMP 0x0011aca0
LAB_0011ac99:
TEST byte ptr [RSP + 0xc],0x1
JNZ 0x0011acab
LAB_0011aca0:
CALL 0x0010e0b0
MOV dword ptr [RAX],0xd
LAB_0011acab:
ADD RSP,0x1038
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_execvpe(char *param_1,char **param_2,char **param_3)
{
int iVar1;
bool bVar2;
size_t __n;
char *pcVar3;
char *pcVar4;
int *piVar5;
size_t __n_00;
char *pcVar6;
char local_1038 [4104];
__n = strlen(param_1);
if (__n == 0) {
piVar5 = __errno_location();
*piVar5 = 2;
}
else {
pcVar3 = strchr(param_1,0x2f);
if (pcVar3 != (char *)0x0) {
execve(param_1,param_2,param_3);
return;
}
pcVar4 = getenv("PATH");
pcVar3 = "/bin:/usr/bin";
if (pcVar4 != (char *)0x0) {
pcVar3 = pcVar4;
}
bVar2 = true;
do {
while( true ) {
pcVar4 = strchr(pcVar3,0x3a);
if (pcVar4 == (char *)0x0) {
__n_00 = strlen(pcVar3);
pcVar6 = (char *)0x0;
}
else {
pcVar6 = pcVar4 + 1;
__n_00 = (long)pcVar4 - (long)pcVar3;
}
if (0xffffffffffffeffe < (__n + 1 + __n_00) - 0x1000) break;
LAB_0011ac7c:
pcVar3 = pcVar6;
if (pcVar6 == (char *)0x0) {
if (bVar2) {
return;
}
goto LAB_0011aca0;
}
}
memcpy(local_1038,pcVar3,__n_00);
local_1038[__n_00] = '/';
memcpy(local_1038 + __n_00 + 1,param_1,__n);
local_1038[__n + 1 + __n_00] = '\0';
execve(local_1038,param_2,param_3);
piVar5 = __errno_location();
iVar1 = *piVar5;
if ((iVar1 == 2) || (iVar1 == 0x14)) goto LAB_0011ac7c;
if (iVar1 != 0xd) {
return;
}
bVar2 = false;
pcVar3 = pcVar6;
} while (pcVar6 != (char *)0x0);
LAB_0011aca0:
piVar5 = __errno_location();
*piVar5 = 0xd;
}
return;
}
|
|
11,334 |
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;
}
|
O0
|
c
|
mysql_free_result:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x48daa
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x48d62
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
cmpl $0x2, 0x488(%rax)
jne 0x48d62
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x78(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movl $0x0, 0x488(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x48020
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x48d89
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
callq 0x56820
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x48da1
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x381b0
movq -0x8(%rbp), %rdi
callq 0x381b0
addq $0x10, %rsp
popq %rbp
retq
|
mysql_free_result:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
cmp [rbp+var_8], 0
jz loc_48DAA
mov rax, [rbp+var_8]
cmp qword ptr [rax+78h], 0
jz short loc_48D62
mov rax, [rbp+var_8]
mov rax, [rax+78h]
cmp dword ptr [rax+488h], 2
jnz short loc_48D62
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov rax, [rax+4D0h]
mov rax, [rax+18h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+78h]
call rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov dword ptr [rax+488h], 0
loc_48D62:
mov rax, [rbp+var_8]
mov rdi, [rax+18h]
call free_rows
mov rax, [rbp+var_8]
cmp qword ptr [rax+10h], 0
jz short loc_48D89
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
xor esi, esi
call ma_free_root
loc_48D89:
mov rax, [rbp+var_8]
cmp qword ptr [rax+60h], 0
jz short loc_48DA1
mov rax, [rbp+var_8]
mov rdi, [rax+60h]
call _free
loc_48DA1:
mov rdi, [rbp+var_8]
call _free
loc_48DAA:
add rsp, 10h
pop rbp
retn
|
long long mysql_free_result(_QWORD *a1)
{
long long result; // rax
if ( a1 )
{
if ( a1[15] && *(_DWORD *)(a1[15] + 1160LL) == 2 )
{
(*(void ( **)(_QWORD))(*(_QWORD *)(a1[15] + 1232LL) + 24LL))(a1[15]);
*(_DWORD *)(a1[15] + 1160LL) = 0;
}
free_rows(a1[3]);
if ( a1[2] )
ma_free_root(a1 + 5, 0LL);
if ( a1[12] )
free(a1[12]);
return free(a1);
}
return result;
}
|
mysql_free_result:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00148daa
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x78],0x0
JZ 0x00148d62
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
CMP dword ptr [RAX + 0x488],0x2
JNZ 0x00148d62
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x78]
CALL RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV dword ptr [RAX + 0x488],0x0
LAB_00148d62:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x00148020
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x00148d89
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
XOR ESI,ESI
CALL 0x00156820
LAB_00148d89:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x00148da1
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x60]
CALL 0x001381b0
LAB_00148da1:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001381b0
LAB_00148daa:
ADD RSP,0x10
POP RBP
RET
|
void mysql_free_result(void *param_1)
{
if (param_1 != (void *)0x0) {
if ((*(long *)((long)param_1 + 0x78) != 0) &&
(*(int *)(*(long *)((long)param_1 + 0x78) + 0x488) == 2)) {
(**(code **)(*(long *)(*(long *)((long)param_1 + 0x78) + 0x4d0) + 0x18))
(*(int8 *)((long)param_1 + 0x78));
*(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 (*(long *)((long)param_1 + 0x60) != 0) {
free(*(void **)((long)param_1 + 0x60));
}
free(param_1);
}
return;
}
|
|
11,335 |
ma_cmp_static_record
|
eloqsql/storage/maria/ma_statrec.c
|
my_bool _ma_cmp_static_record(register MARIA_HA *info,
register const uchar *old)
{
DBUG_ENTER("_ma_cmp_static_record");
if (info->opt_flag & WRITE_CACHE_USED)
{
if (flush_io_cache(&info->rec_cache))
{
DBUG_RETURN(1);
}
info->rec_cache.seek_not_done=1; /* We have done a seek */
}
if ((info->opt_flag & READ_CHECK_USED))
{ /* If check isn't disabled */
info->rec_cache.seek_not_done=1; /* We have done a seek */
if (info->s->file_read(info, info->rec_buff, info->s->base.reclength,
info->cur_row.lastpos, MYF(MY_NABP)))
DBUG_RETURN(1);
if (memcmp(info->rec_buff, old, (uint) info->s->base.reclength))
{
DBUG_DUMP("read",old,info->s->base.reclength);
DBUG_DUMP("disk",info->rec_buff,info->s->base.reclength);
my_errno=HA_ERR_RECORD_CHANGED; /* Record have changed */
DBUG_RETURN(1);
}
}
DBUG_RETURN(0);
}
|
O0
|
c
|
ma_cmp_static_record:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x61c(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x48ac5
movq -0x10(%rbp), %rdi
addq $0x4b8, %rdi # imm = 0x4B8
movl $0x1, %esi
callq 0xe8710
cmpl $0x0, %eax
je 0x48ab7
jmp 0x48aae
movb $0x1, -0x1(%rbp)
jmp 0x48b81
movq -0x10(%rbp), %rax
movl $0x1, 0x598(%rax)
movq -0x10(%rbp), %rax
movl 0x61c(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x48b7b
movq -0x10(%rbp), %rax
movl $0x1, 0x598(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x6e0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x3a0(%rcx), %rsi
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x398(%rcx), %rdx
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rcx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
je 0x48b35
jmp 0x48b2f
movb $0x1, -0x1(%rbp)
jmp 0x48b81
movq -0x10(%rbp), %rax
movq 0x3a0(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x398(%rax), %rax
movl %eax, %eax
movl %eax, %edx
callq 0x297d0
cmpl $0x0, %eax
je 0x48b79
jmp 0x48b62
jmp 0x48b64
jmp 0x48b66
jmp 0x48b68
callq 0xfdd30
movl $0x7b, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x48b81
jmp 0x48b7b
jmp 0x48b7d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ma_cmp_static_record:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov eax, [rax+61Ch]
and eax, 10h
cmp eax, 0
jz short loc_48AC5
mov rdi, [rbp+var_10]
add rdi, 4B8h
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_48AB7
jmp short $+2
loc_48AAE:
mov [rbp+var_1], 1
jmp loc_48B81
loc_48AB7:
mov rax, [rbp+var_10]
mov dword ptr [rax+598h], 1
loc_48AC5:
mov rax, [rbp+var_10]
mov eax, [rax+61Ch]
and eax, 4
cmp eax, 0
jz loc_48B7B
mov rax, [rbp+var_10]
mov dword ptr [rax+598h], 1
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+6E0h]
mov rdi, [rbp+var_10]
mov rcx, [rbp+var_10]
mov rsi, [rcx+3A0h]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov rdx, [rcx+398h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+98h]
mov r8d, 4
call rax
cmp rax, 0
jz short loc_48B35
jmp short $+2
loc_48B2F:
mov [rbp+var_1], 1
jmp short loc_48B81
loc_48B35:
mov rax, [rbp+var_10]
mov rdi, [rax+3A0h]
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+398h]
mov eax, eax
mov edx, eax
call _memcmp
cmp eax, 0
jz short loc_48B79
jmp short $+2
loc_48B62:
jmp short $+2
loc_48B64:
jmp short $+2
loc_48B66:
jmp short $+2
loc_48B68:
call _my_thread_var
mov dword ptr [rax], 7Bh ; '{'
mov [rbp+var_1], 1
jmp short loc_48B81
loc_48B79:
jmp short $+2
loc_48B7B:
jmp short $+2
loc_48B7D:
mov [rbp+var_1], 0
loc_48B81:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char ma_cmp_static_record(long long a1, const char *a2)
{
long long v2; // rdi
if ( (*(_DWORD *)(a1 + 1564) & 0x10) == 0 )
{
LABEL_5:
if ( (*(_DWORD *)(a1 + 1564) & 4) != 0 )
{
*(_DWORD *)(a1 + 1432) = 1;
if ( (*(long long ( **)(long long, _QWORD, _QWORD, _QWORD, long long))(*(_QWORD *)a1 + 1760LL))(
a1,
*(_QWORD *)(a1 + 928),
*(_QWORD *)(*(_QWORD *)a1 + 920LL),
*(_QWORD *)(a1 + 152),
4LL) )
{
return 1;
}
v2 = *(_QWORD *)(a1 + 928);
if ( (unsigned int)memcmp(v2, a2, (unsigned int)*(_QWORD *)(*(_QWORD *)a1 + 920LL)) )
{
*(_DWORD *)my_thread_var(v2, a2) = 123;
return 1;
}
}
return 0;
}
if ( !(unsigned int)my_b_flush_io_cache(a1 + 1208, 1LL) )
{
*(_DWORD *)(a1 + 1432) = 1;
goto LABEL_5;
}
return 1;
}
|
_ma_cmp_static_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x61c]
AND EAX,0x10
CMP EAX,0x0
JZ 0x00148ac5
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x4b8
MOV ESI,0x1
CALL 0x001e8710
CMP EAX,0x0
JZ 0x00148ab7
JMP 0x00148aae
LAB_00148aae:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00148b81
LAB_00148ab7:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x598],0x1
LAB_00148ac5:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x61c]
AND EAX,0x4
CMP EAX,0x0
JZ 0x00148b7b
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x598],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x6e0]
MOV RDI,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x3a0]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV RDX,qword ptr [RCX + 0x398]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x98]
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
JZ 0x00148b35
JMP 0x00148b2f
LAB_00148b2f:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00148b81
LAB_00148b35:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x3a0]
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x398]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x001297d0
CMP EAX,0x0
JZ 0x00148b79
JMP 0x00148b62
LAB_00148b62:
JMP 0x00148b64
LAB_00148b64:
JMP 0x00148b66
LAB_00148b66:
JMP 0x00148b68
LAB_00148b68:
CALL 0x001fdd30
MOV dword ptr [RAX],0x7b
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00148b81
LAB_00148b79:
JMP 0x00148b7b
LAB_00148b7b:
JMP 0x00148b7d
LAB_00148b7d:
MOV byte ptr [RBP + -0x1],0x0
LAB_00148b81:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 _ma_cmp_static_record(long *param_1,void *param_2)
{
int iVar1;
long lVar2;
int4 *puVar3;
if ((*(uint *)((long)param_1 + 0x61c) & 0x10) != 0) {
iVar1 = my_b_flush_io_cache(param_1 + 0x97,1);
if (iVar1 != 0) {
return 1;
}
*(int4 *)(param_1 + 0xb3) = 1;
}
if ((*(uint *)((long)param_1 + 0x61c) & 4) != 0) {
*(int4 *)(param_1 + 0xb3) = 1;
lVar2 = (**(code **)(*param_1 + 0x6e0))
(param_1,param_1[0x74],*(int8 *)(*param_1 + 0x398),param_1[0x13],4);
if (lVar2 != 0) {
return 1;
}
iVar1 = memcmp((void *)param_1[0x74],param_2,*(ulong *)(*param_1 + 0x398) & 0xffffffff);
if (iVar1 != 0) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x7b;
return 1;
}
}
return 0;
}
|
|
11,336 |
ma_ft_make_key
|
eloqsql/storage/maria/ma_ft_update.c
|
MARIA_KEY *_ma_ft_make_key(MARIA_HA *info, MARIA_KEY *key, uint keynr,
uchar *keybuf,
FT_WORD *wptr, my_off_t filepos)
{
uchar buf[HA_FT_MAXBYTELEN+16];
float weight=(float) ((filepos==HA_OFFSET_ERROR) ? 0 : wptr->weight);
DBUG_ENTER("_ma_ft_make_key");
mi_float4store(buf,weight);
int2store(buf+HA_FT_WLEN,wptr->len);
memcpy(buf+HA_FT_WLEN+2,wptr->pos,wptr->len);
/* Can't be spatial so it's ok to call _ma_make_key directly here */
DBUG_RETURN(_ma_make_key(info, key, keynr, keybuf, buf, filepos, 0));
}
|
O0
|
c
|
ma_ft_make_key:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x128(%rbp)
movq %rsi, -0x130(%rbp)
movl %edx, -0x134(%rbp)
movq %rcx, -0x140(%rbp)
movq %r8, -0x148(%rbp)
movq %r9, -0x150(%rbp)
cmpq $-0x1, -0x150(%rbp)
jne 0x76408
xorps %xmm0, %xmm0
movsd %xmm0, -0x168(%rbp)
jmp 0x7641c
movq -0x148(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x168(%rbp)
movsd -0x168(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x154(%rbp)
movb -0x151(%rbp), %al
movb %al, -0x120(%rbp)
movb -0x152(%rbp), %al
movb %al, -0x11f(%rbp)
movb -0x153(%rbp), %al
movb %al, -0x11e(%rbp)
movb -0x154(%rbp), %al
movb %al, -0x11d(%rbp)
leaq -0x120(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x160(%rbp)
movq -0x148(%rbp), %rax
movl 0x8(%rax), %eax
movw %ax, %cx
movq -0x160(%rbp), %rax
movw %cx, (%rax)
leaq -0x120(%rbp), %rdi
addq $0x4, %rdi
addq $0x2, %rdi
movq -0x148(%rbp), %rax
movq (%rax), %rsi
movq -0x148(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x128(%rbp), %rdi
movq -0x130(%rbp), %rsi
movl -0x134(%rbp), %edx
movq -0x140(%rbp), %rcx
leaq -0x120(%rbp), %r8
movq -0x150(%rbp), %r9
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x45070
movq %rax, -0x170(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x76514
movq -0x170(%rbp), %rax
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
callq 0x2a250
nopl (%rax)
|
_ma_ft_make_key:
push rbp
mov rbp, rsp
sub rsp, 180h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_128], rdi
mov [rbp+var_130], rsi
mov [rbp+var_134], edx
mov [rbp+var_140], rcx
mov [rbp+var_148], r8
mov [rbp+var_150], r9
cmp [rbp+var_150], 0FFFFFFFFFFFFFFFFh
jnz short loc_76408
xorps xmm0, xmm0
movsd [rbp+var_168], xmm0
jmp short loc_7641C
loc_76408:
mov rax, [rbp+var_148]
movsd xmm0, qword ptr [rax+10h]
movsd [rbp+var_168], xmm0
loc_7641C:
movsd xmm0, [rbp+var_168]
cvtsd2ss xmm0, xmm0
movss [rbp+var_154], xmm0
mov al, byte ptr [rbp+var_154+3]
mov [rbp+var_120], al
mov al, byte ptr [rbp+var_154+2]
mov [rbp+var_11F], al
mov al, byte ptr [rbp+var_154+1]
mov [rbp+var_11E], al
mov al, byte ptr [rbp+var_154]
mov [rbp+var_11D], al
lea rax, [rbp+var_120]
add rax, 4
mov [rbp+var_160], rax
mov rax, [rbp+var_148]
mov eax, [rax+8]
mov cx, ax
mov rax, [rbp+var_160]
mov [rax], cx
lea rdi, [rbp+var_120]
add rdi, 4
add rdi, 2
mov rax, [rbp+var_148]
mov rsi, [rax]
mov rax, [rbp+var_148]
mov eax, [rax+8]
mov edx, eax
call _memcpy
mov rdi, [rbp+var_128]
mov rsi, [rbp+var_130]
mov edx, [rbp+var_134]
mov rcx, [rbp+var_140]
lea r8, [rbp+var_120]
mov r9, [rbp+var_150]
xor eax, eax
mov [rsp+180h+var_180], 0
call _ma_make_key
mov [rbp+var_170], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_76514
mov rax, [rbp+var_170]
add rsp, 180h
pop rbp
retn
loc_76514:
call ___stack_chk_fail
|
long long ma_ft_make_key(_DWORD *a1, long long a2, unsigned int a3, _BYTE *a4, long long a5, long long a6)
{
float v6; // xmm0_4
double v8; // [rsp+18h] [rbp-168h]
_BYTE v12[4]; // [rsp+60h] [rbp-120h] BYREF
__int16 v13; // [rsp+64h] [rbp-11Ch]
_BYTE v14[282]; // [rsp+66h] [rbp-11Ah] BYREF
*(_QWORD *)&v14[274] = __readfsqword(0x28u);
if ( a6 == -1 )
v8 = 0.0;
else
v8 = *(double *)(a5 + 16);
v6 = v8;
v12[0] = HIBYTE(v6);
v12[1] = BYTE2(v6);
v12[2] = BYTE1(v6);
v12[3] = LOBYTE(v6);
v13 = *(_DWORD *)(a5 + 8);
memcpy(v14, *(_QWORD *)a5, *(unsigned int *)(a5 + 8));
return ma_make_key(a1, a2, a3, a4, (long long)v12, a6, 0LL);
}
|
_ma_ft_make_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x180
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x128],RDI
MOV qword ptr [RBP + -0x130],RSI
MOV dword ptr [RBP + -0x134],EDX
MOV qword ptr [RBP + -0x140],RCX
MOV qword ptr [RBP + -0x148],R8
MOV qword ptr [RBP + -0x150],R9
CMP qword ptr [RBP + -0x150],-0x1
JNZ 0x00176408
XORPS XMM0,XMM0
MOVSD qword ptr [RBP + -0x168],XMM0
JMP 0x0017641c
LAB_00176408:
MOV RAX,qword ptr [RBP + -0x148]
MOVSD XMM0,qword ptr [RAX + 0x10]
MOVSD qword ptr [RBP + -0x168],XMM0
LAB_0017641c:
MOVSD XMM0,qword ptr [RBP + -0x168]
CVTSD2SS XMM0,XMM0
MOVSS dword ptr [RBP + -0x154],XMM0
MOV AL,byte ptr [RBP + -0x151]
MOV byte ptr [RBP + -0x120],AL
MOV AL,byte ptr [RBP + -0x152]
MOV byte ptr [RBP + -0x11f],AL
MOV AL,byte ptr [RBP + -0x153]
MOV byte ptr [RBP + -0x11e],AL
MOV AL,byte ptr [RBP + -0x154]
MOV byte ptr [RBP + -0x11d],AL
LEA RAX,[RBP + -0x120]
ADD RAX,0x4
MOV qword ptr [RBP + -0x160],RAX
MOV RAX,qword ptr [RBP + -0x148]
MOV EAX,dword ptr [RAX + 0x8]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x160]
MOV word ptr [RAX],CX
LEA RDI,[RBP + -0x120]
ADD RDI,0x4
ADD RDI,0x2
MOV RAX,qword ptr [RBP + -0x148]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x148]
MOV EAX,dword ptr [RAX + 0x8]
MOV EDX,EAX
CALL 0x0012a0b0
MOV RDI,qword ptr [RBP + -0x128]
MOV RSI,qword ptr [RBP + -0x130]
MOV EDX,dword ptr [RBP + -0x134]
MOV RCX,qword ptr [RBP + -0x140]
LEA R8,[RBP + -0x120]
MOV R9,qword ptr [RBP + -0x150]
XOR EAX,EAX
MOV qword ptr [RSP],0x0
CALL 0x00145070
MOV qword ptr [RBP + -0x170],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00176514
MOV RAX,qword ptr [RBP + -0x170]
ADD RSP,0x180
POP RBP
RET
LAB_00176514:
CALL 0x0012a250
|
int8
_ma_ft_make_key(int8 param_1,int8 param_2,int4 param_3,int8 param_4,
int8 *param_5,long param_6)
{
int8 uVar1;
long in_FS_OFFSET;
float fVar2;
double local_170;
int1 local_15c;
int1 uStack_15b;
int1 uStack_15a;
int1 uStack_159;
int1 local_128;
int1 local_127;
int1 local_126;
int1 local_125;
int2 local_124;
int1 auStack_122 [274];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_6 == -1) {
local_170 = 0.0;
}
else {
local_170 = (double)param_5[2];
}
fVar2 = (float)local_170;
uStack_159 = (int1)((uint)fVar2 >> 0x18);
local_128 = uStack_159;
uStack_15a = (int1)((uint)fVar2 >> 0x10);
local_127 = uStack_15a;
uStack_15b = (int1)((uint)fVar2 >> 8);
local_126 = uStack_15b;
local_15c = SUB41(fVar2,0);
local_125 = local_15c;
local_124 = (int2)*(int4 *)(param_5 + 1);
memcpy(auStack_122,(void *)*param_5,(ulong)*(uint *)(param_5 + 1));
uVar1 = _ma_make_key(param_1,param_2,param_3,param_4,&local_128,param_6,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return uVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
11,337 |
js_promise_finally
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_promise_finally(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue onFinally = argv[0];
JSValue ctor, ret;
JSValue then_funcs[2];
JSValue func_data[2];
int i;
ctor = JS_SpeciesConstructor(ctx, this_val, JS_UNDEFINED);
if (JS_IsException(ctor))
return ctor;
if (!JS_IsFunction(ctx, onFinally)) {
then_funcs[0] = js_dup(onFinally);
then_funcs[1] = js_dup(onFinally);
} else {
func_data[0] = ctor;
func_data[1] = onFinally;
for(i = 0; i < 2; i++) {
then_funcs[i] = JS_NewCFunctionData(ctx, js_promise_then_finally_func, 1, i, 2, func_data);
if (JS_IsException(then_funcs[i])) {
if (i == 1)
JS_FreeValue(ctx, then_funcs[0]);
JS_FreeValue(ctx, ctor);
return JS_EXCEPTION;
}
}
}
JS_FreeValue(ctx, ctor);
ret = JS_Invoke(ctx, this_val, JS_ATOM_then, 2, then_funcs);
JS_FreeValue(ctx, then_funcs[0]);
JS_FreeValue(ctx, then_funcs[1]);
return ret;
}
|
O0
|
c
|
js_promise_finally:
subq $0x118, %rsp # imm = 0x118
movq %rsi, 0xf8(%rsp)
movq %rdx, 0x100(%rsp)
movq %rdi, 0xf0(%rsp)
movl %ecx, 0xec(%rsp)
movq %r8, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0xd0(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xd8(%rsp)
movq 0xf0(%rsp), %rdi
movl $0x0, 0x48(%rsp)
movq $0x3, 0x50(%rsp)
movq 0xf8(%rsp), %rsi
movq 0x100(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
callq 0x74810
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x930e8
movq 0xc0(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x110(%rsp)
jmp 0x93391
movq 0xf0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
callq 0x2e510
cmpl $0x0, %eax
jne 0x93181
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x216d0
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x216d0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0xa8(%rsp)
jmp 0x932c6
movq 0xc0(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x88(%rsp)
movl $0x0, 0x6c(%rsp)
cmpl $0x2, 0x6c(%rsp)
jge 0x932c4
movslq 0x6c(%rsp), %rcx
leaq 0x90(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0xf0(%rsp), %rdi
movl 0x6c(%rsp), %ecx
leaq 0x70(%rsp), %r9
leaq 0x1b2(%rip), %rsi # 0x933b0
movl $0x1, %edx
movl $0x2, %r8d
callq 0x2a7b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movslq 0x6c(%rsp), %rcx
leaq 0x90(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x932b2
cmpl $0x1, 0x6c(%rsp)
jne 0x93279
movq 0xf0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x23c90
movq 0xf0(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
callq 0x23c90
movl $0x0, 0x108(%rsp)
movq $0x6, 0x110(%rsp)
jmp 0x93391
jmp 0x932b4
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x931c3
jmp 0x932c6
movq 0xf0(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
callq 0x23c90
movq 0xf0(%rsp), %rdi
leaq 0x90(%rsp), %r9
movq 0xf8(%rsp), %rsi
movq 0x100(%rsp), %rdx
movl $0x80, %ecx
movl $0x2, %r8d
callq 0x485c0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x23c90
movq 0xf0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x23c90
movq 0xb0(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x108(%rsp), %rax
movq 0x110(%rsp), %rdx
addq $0x118, %rsp # imm = 0x118
retq
nopl (%rax)
|
js_promise_finally:
sub rsp, 118h
mov [rsp+118h+var_20], rsi
mov [rsp+118h+var_18], rdx
mov [rsp+118h+var_28], rdi
mov [rsp+118h+var_2C], ecx
mov [rsp+118h+var_38], r8
mov rax, [rsp+118h+var_38]
mov rcx, [rax]
mov [rsp+118h+var_48], rcx
mov rax, [rax+8]
mov [rsp+118h+var_40], rax
mov rdi, [rsp+118h+var_28]
mov dword ptr [rsp+118h+var_D0], 0
mov [rsp+118h+var_C8], 3
mov rsi, [rsp+118h+var_20]
mov rdx, [rsp+118h+var_18]
mov rcx, [rsp+118h+var_D0]
mov r8, [rsp+118h+var_C8]
call JS_SpeciesConstructor
mov [rsp+118h+var_C0], rax
mov [rsp+118h+var_B8], rdx
mov rax, [rsp+118h+var_C0]
mov [rsp+118h+var_58], rax
mov rax, [rsp+118h+var_B8]
mov [rsp+118h+var_50], rax
mov rdi, [rsp+118h+var_58]
mov rsi, [rsp+118h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_930E8
mov rax, [rsp+118h+var_58]
mov [rsp+118h+var_10], rax
mov rax, [rsp+118h+var_50]
mov [rsp+118h+var_8], rax
jmp loc_93391
loc_930E8:
mov rdi, [rsp+118h+var_28]
mov rsi, [rsp+118h+var_48]
mov rdx, [rsp+118h+var_40]
call JS_IsFunction
cmp eax, 0
jnz short loc_93181
mov rdi, [rsp+118h+var_48]
mov rsi, [rsp+118h+var_40]
call js_dup
mov [rsp+118h+var_E0], rax
mov [rsp+118h+var_D8], rdx
mov rax, [rsp+118h+var_E0]
mov [rsp+118h+var_88], rax
mov rax, [rsp+118h+var_D8]
mov [rsp+118h+var_80], rax
mov rdi, [rsp+118h+var_48]
mov rsi, [rsp+118h+var_40]
call js_dup
mov [rsp+118h+var_F0], rax
mov [rsp+118h+var_E8], rdx
mov rax, [rsp+118h+var_F0]
mov [rsp+118h+var_78], rax
mov rax, [rsp+118h+var_E8]
mov [rsp+118h+var_70], rax
jmp loc_932C6
loc_93181:
mov rax, [rsp+118h+var_58]
mov [rsp+118h+var_A8], rax
mov rax, [rsp+118h+var_50]
mov [rsp+118h+var_A0], rax
mov rax, [rsp+118h+var_48]
mov [rsp+118h+var_98], rax
mov rax, [rsp+118h+var_40]
mov [rsp+118h+var_90], rax
mov [rsp+118h+var_AC], 0
loc_931C3:
cmp [rsp+118h+var_AC], 2
jge loc_932C4
movsxd rcx, [rsp+118h+var_AC]
lea rax, [rsp+118h+var_88]
shl rcx, 4
add rax, rcx
mov [rsp+118h+var_118], rax
mov rdi, [rsp+118h+var_28]
mov ecx, [rsp+118h+var_AC]
lea r9, [rsp+118h+var_A8]
lea rsi, js_promise_then_finally_func
mov edx, 1
mov r8d, 2
call JS_NewCFunctionData
mov rcx, rax
mov rax, [rsp+118h+var_118]
mov [rsp+118h+var_100], rcx
mov [rsp+118h+var_F8], rdx
mov rcx, [rsp+118h+var_100]
mov [rax], rcx
mov rcx, [rsp+118h+var_F8]
mov [rax+8], rcx
movsxd rcx, [rsp+118h+var_AC]
lea rax, [rsp+118h+var_88]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rsi, [rax+8]
call JS_IsException_1
cmp eax, 0
jz short loc_932B2
cmp [rsp+118h+var_AC], 1
jnz short loc_93279
mov rdi, [rsp+118h+var_28]
mov rsi, [rsp+118h+var_88]
mov rdx, [rsp+118h+var_80]
call JS_FreeValue
loc_93279:
mov rdi, [rsp+118h+var_28]
mov rsi, [rsp+118h+var_58]
mov rdx, [rsp+118h+var_50]
call JS_FreeValue
mov dword ptr [rsp+118h+var_10], 0
mov [rsp+118h+var_8], 6
jmp loc_93391
loc_932B2:
jmp short $+2
loc_932B4:
mov eax, [rsp+118h+var_AC]
add eax, 1
mov [rsp+118h+var_AC], eax
jmp loc_931C3
loc_932C4:
jmp short $+2
loc_932C6:
mov rdi, [rsp+118h+var_28]
mov rsi, [rsp+118h+var_58]
mov rdx, [rsp+118h+var_50]
call JS_FreeValue
mov rdi, [rsp+118h+var_28]
lea r9, [rsp+118h+var_88]
mov rsi, [rsp+118h+var_20]
mov rdx, [rsp+118h+var_18]
mov ecx, 80h
mov r8d, 2
call JS_Invoke
mov [rsp+118h+var_110], rax
mov [rsp+118h+var_108], rdx
mov rax, [rsp+118h+var_110]
mov [rsp+118h+var_68], rax
mov rax, [rsp+118h+var_108]
mov [rsp+118h+var_60], rax
mov rdi, [rsp+118h+var_28]
mov rsi, [rsp+118h+var_88]
mov rdx, [rsp+118h+var_80]
call JS_FreeValue
mov rdi, [rsp+118h+var_28]
mov rsi, [rsp+118h+var_78]
mov rdx, [rsp+118h+var_70]
call JS_FreeValue
mov rax, [rsp+118h+var_68]
mov [rsp+118h+var_10], rax
mov rax, [rsp+118h+var_60]
mov [rsp+118h+var_8], rax
loc_93391:
mov rax, [rsp+118h+var_10]
mov rdx, [rsp+118h+var_8]
add rsp, 118h
retn
|
_DWORD * js_promise_finally(
long long a1,
long long a2,
long long a3,
int a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
long long v14; // rdx
long long v15; // rdx
long long v16; // rdx
long long v17; // rdx
long long *v19; // [rsp+0h] [rbp-118h]
_DWORD *v20; // [rsp+48h] [rbp-D0h]
int i; // [rsp+6Ch] [rbp-ACh]
_QWORD v22[4]; // [rsp+70h] [rbp-A8h] BYREF
_DWORD *v23; // [rsp+90h] [rbp-88h] BYREF
long long v24; // [rsp+98h] [rbp-80h]
_DWORD *v25; // [rsp+A0h] [rbp-78h]
long long v26; // [rsp+A8h] [rbp-70h]
long long v27; // [rsp+B0h] [rbp-68h]
long long v28; // [rsp+B8h] [rbp-60h]
_DWORD *v29; // [rsp+C0h] [rbp-58h]
long long v30; // [rsp+C8h] [rbp-50h]
_DWORD *v31; // [rsp+D0h] [rbp-48h]
long long v32; // [rsp+D8h] [rbp-40h]
long long v33; // [rsp+E0h] [rbp-38h]
int v34; // [rsp+ECh] [rbp-2Ch]
long long v35; // [rsp+F0h] [rbp-28h]
long long v36; // [rsp+F8h] [rbp-20h]
long long v37; // [rsp+100h] [rbp-18h]
_DWORD *v38; // [rsp+108h] [rbp-10h]
long long v39; // [rsp+110h] [rbp-8h]
v36 = a2;
v37 = a3;
v35 = a1;
v34 = a4;
v33 = a5;
v31 = *(_DWORD **)a5;
v32 = *(_QWORD *)(a5 + 8);
LODWORD(v20) = 0;
v29 = JS_SpeciesConstructor(a1, a2, a3, v20, 3u, a6, a7, a8, a9, a10, a11, a12, a13);
v30 = v13;
if ( JS_IsException_1((long long)v29, v13) )
{
v38 = v29;
v39 = v30;
}
else
{
if ( (unsigned int)JS_IsFunction(v35, (long long)v31, v32) )
{
v22[0] = v29;
v22[1] = v30;
v22[2] = v31;
v22[3] = v32;
for ( i = 0; i < 2; ++i )
{
v19 = (long long *)&(&v23)[2 * i];
*v19 = JS_NewCFunctionData(v35, (long long)js_promise_then_finally_func, 1u, i, 2, (long long)v22);
v19[1] = v16;
if ( JS_IsException_1(*v19, v19[1]) )
{
if ( i == 1 )
JS_FreeValue(v35, (long long)v23, v24);
JS_FreeValue(v35, (long long)v29, v30);
LODWORD(v38) = 0;
v39 = 6LL;
return v38;
}
}
}
else
{
v23 = js_dup(v31, v32);
v24 = v14;
v25 = js_dup(v31, v32);
v26 = v15;
}
JS_FreeValue(v35, (long long)v29, v30);
v27 = JS_Invoke(v35, v36, v37, 128, 2, (long long)&v23);
v28 = v17;
JS_FreeValue(v35, (long long)v23, v24);
JS_FreeValue(v35, (long long)v25, v26);
v38 = (_DWORD *)v27;
v39 = v28;
}
return v38;
}
|
js_promise_finally:
SUB RSP,0x118
MOV qword ptr [RSP + 0xf8],RSI
MOV qword ptr [RSP + 0x100],RDX
MOV qword ptr [RSP + 0xf0],RDI
MOV dword ptr [RSP + 0xec],ECX
MOV qword ptr [RSP + 0xe0],R8
MOV RAX,qword ptr [RSP + 0xe0]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0xd0],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0xd8],RAX
MOV RDI,qword ptr [RSP + 0xf0]
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x3
MOV RSI,qword ptr [RSP + 0xf8]
MOV RDX,qword ptr [RSP + 0x100]
MOV RCX,qword ptr [RSP + 0x48]
MOV R8,qword ptr [RSP + 0x50]
CALL 0x00174810
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xc0],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xc8],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001930e8
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x108],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x110],RAX
JMP 0x00193391
LAB_001930e8:
MOV RDI,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0xd0]
MOV RDX,qword ptr [RSP + 0xd8]
CALL 0x0012e510
CMP EAX,0x0
JNZ 0x00193181
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xd8]
CALL 0x001216d0
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xd8]
CALL 0x001216d0
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xa8],RAX
JMP 0x001932c6
LAB_00193181:
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RSP + 0x88],RAX
MOV dword ptr [RSP + 0x6c],0x0
LAB_001931c3:
CMP dword ptr [RSP + 0x6c],0x2
JGE 0x001932c4
MOVSXD RCX,dword ptr [RSP + 0x6c]
LEA RAX,[RSP + 0x90]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0xf0]
MOV ECX,dword ptr [RSP + 0x6c]
LEA R9,[RSP + 0x70]
LEA RSI,[0x1933b0]
MOV EDX,0x1
MOV R8D,0x2
CALL 0x0012a7b0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x20],RDX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x8],RCX
MOVSXD RCX,dword ptr [RSP + 0x6c]
LEA RAX,[RSP + 0x90]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001932b2
CMP dword ptr [RSP + 0x6c],0x1
JNZ 0x00193279
MOV RDI,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00123c90
LAB_00193279:
MOV RDI,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
CALL 0x00123c90
MOV dword ptr [RSP + 0x108],0x0
MOV qword ptr [RSP + 0x110],0x6
JMP 0x00193391
LAB_001932b2:
JMP 0x001932b4
LAB_001932b4:
MOV EAX,dword ptr [RSP + 0x6c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x6c],EAX
JMP 0x001931c3
LAB_001932c4:
JMP 0x001932c6
LAB_001932c6:
MOV RDI,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0xf0]
LEA R9,[RSP + 0x90]
MOV RSI,qword ptr [RSP + 0xf8]
MOV RDX,qword ptr [RSP + 0x100]
MOV ECX,0x80
MOV R8D,0x2
CALL 0x001485c0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0xb8],RAX
MOV RDI,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00123c90
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x108],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x110],RAX
LAB_00193391:
MOV RAX,qword ptr [RSP + 0x108]
MOV RDX,qword ptr [RSP + 0x110]
ADD RSP,0x118
RET
|
int1 [16]
js_promise_finally(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int iVar1;
int1 auVar2 [16];
uint uStack_cc;
int local_ac;
int1 local_a8 [16];
int8 local_98;
int8 local_90;
int1 local_88 [16];
int1 local_78 [16];
int1 local_68 [16];
int1 local_58 [16];
int8 local_48;
int8 local_40;
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_48 = *param_5;
local_40 = param_5[1];
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_58 = JS_SpeciesConstructor(param_1,param_2,param_3,(ulong)uStack_cc << 0x20,3);
iVar1 = JS_IsException(local_58._0_8_,local_58._8_8_);
if (iVar1 == 0) {
iVar1 = JS_IsFunction(local_28,local_48,local_40);
if (iVar1 == 0) {
local_88 = js_dup(local_48,local_40);
local_78 = js_dup(local_48,local_40);
}
else {
local_98 = local_48;
local_90 = local_40;
local_ac = 0;
local_a8 = local_58;
while( true ) {
if (1 < local_ac) break;
auVar2 = JS_NewCFunctionData(local_28,js_promise_then_finally_func,1,local_ac,2,local_a8);
*(long *)(local_88 + (long)local_ac * 0x10) = auVar2._0_8_;
*(long *)(local_88 + (long)local_ac * 0x10 + 8) = auVar2._8_8_;
iVar1 = JS_IsException(*(int8 *)(local_88 + (long)local_ac * 0x10),
*(int8 *)(local_88 + (long)local_ac * 0x10 + 8));
if (iVar1 != 0) {
if (local_ac == 1) {
JS_FreeValue(local_28,local_88._0_8_,local_88._8_8_);
}
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
local_10 = 0;
local_8 = 6;
goto LAB_00193391;
}
local_ac = local_ac + 1;
}
}
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
local_68 = JS_Invoke(local_28,local_20,local_18,0x80,2,local_88);
JS_FreeValue(local_28,local_88._0_8_,local_88._8_8_);
JS_FreeValue(local_28,local_78._0_8_,local_78._8_8_);
local_10 = local_68._0_4_;
uStack_c = local_68._4_4_;
local_8 = local_68._8_8_;
}
else {
local_10 = local_58._0_4_;
uStack_c = local_58._4_4_;
local_8 = local_58._8_8_;
}
LAB_00193391:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
|
|
11,338 |
js_promise_finally
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_promise_finally(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue onFinally = argv[0];
JSValue ctor, ret;
JSValue then_funcs[2];
JSValue func_data[2];
int i;
ctor = JS_SpeciesConstructor(ctx, this_val, JS_UNDEFINED);
if (JS_IsException(ctor))
return ctor;
if (!JS_IsFunction(ctx, onFinally)) {
then_funcs[0] = js_dup(onFinally);
then_funcs[1] = js_dup(onFinally);
} else {
func_data[0] = ctor;
func_data[1] = onFinally;
for(i = 0; i < 2; i++) {
then_funcs[i] = JS_NewCFunctionData(ctx, js_promise_then_finally_func, 1, i, 2, func_data);
if (JS_IsException(then_funcs[i])) {
if (i == 1)
JS_FreeValue(ctx, then_funcs[0]);
JS_FreeValue(ctx, ctor);
return JS_EXCEPTION;
}
}
}
JS_FreeValue(ctx, ctor);
ret = JS_Invoke(ctx, this_val, JS_ATOM_then, 2, then_funcs);
JS_FreeValue(ctx, then_funcs[0]);
JS_FreeValue(ctx, then_funcs[1]);
return ret;
}
|
O1
|
c
|
js_promise_finally:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r13
movq %rdi, %r15
movq (%r8), %r12
movq 0x8(%r8), %rbp
movl $0x3, %r8d
movq %rsi, 0x38(%rsp)
xorl %ecx, %ecx
callq 0x440b7
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
jne 0x535be
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r14, %rcx
andq %rax, %rcx
jmp 0x53713
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x22dbe
testl %eax, %eax
movq %r14, 0x8(%rsp)
movq %r13, 0x30(%rsp)
je 0x53639
leaq 0x40(%rsp), %r13
movq %r14, (%r13)
movq %rbx, 0x8(%r13)
movq %r12, 0x10(%r13)
movq %rbp, 0x18(%r13)
leaq 0x18(%rsp), %r14
xorl %r12d, %r12d
leaq 0x12d(%rip), %rbp # 0x5372b
movq %r15, %rdi
movq %rbp, %rsi
movl $0x1, %edx
movl %r12d, %ecx
movl $0x2, %r8d
movq %r13, %r9
callq 0x210ea
movq %rax, -0x8(%r14)
movq %rdx, (%r14)
cmpl $0x6, %edx
je 0x536df
incq %r12
addq $0x10, %r14
cmpq $0x1, %r12
je 0x535fe
jmp 0x5366f
movq %r12, 0x10(%rsp)
cmpl $-0x9, %ebp
jb 0x5364a
movq 0x10(%rsp), %rax
incl (%rax)
movq %r12, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
movq %r12, 0x40(%rsp)
cmpl $-0x9, %ebp
jb 0x53665
movq 0x40(%rsp), %rax
incl (%rax)
movq %r12, 0x20(%rsp)
movq %rbp, 0x28(%rsp)
movq 0x18(%r15), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x1d8c6
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl $0x80, %ecx
movl $0x2, %r8d
movq %r12, %r9
callq 0x2fc94
movq %rax, %r14
movq %rdx, %rbx
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq 0x18(%r15), %rdi
callq 0x1d8c6
movq 0x10(%r12), %rsi
movq 0x18(%r12), %rdx
movq 0x18(%r15), %rdi
callq 0x1d8c6
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %r14, %rcx
jmp 0x53713
cmpq $0x1, %r12
jne 0x536f8
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x18(%r15), %rdi
callq 0x1d8c6
movq 0x18(%r15), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x1d8c6
movl $0x6, %ebx
xorl %r14d, %r14d
xorl %ecx, %ecx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_promise_finally:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r13, rdx
mov r15, rdi
mov r12, [r8]
mov rbp, [r8+8]
mov r8d, 3
mov [rsp+98h+var_60], rsi
xor ecx, ecx
call JS_SpeciesConstructor
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jnz short loc_535BE
mov rax, 0FFFFFFFF00000000h
mov rcx, r14
and rcx, rax
jmp loc_53713
loc_535BE:
mov rdi, r15
mov rsi, r12
mov rdx, rbp
call JS_IsFunction
test eax, eax
mov [rsp+98h+var_90], r14
mov [rsp+98h+var_68], r13
jz short loc_53639
lea r13, [rsp+98h+var_58]
mov [r13+0], r14
mov [r13+8], rbx
mov [r13+10h], r12
mov [r13+18h], rbp
lea r14, [rsp+98h+var_80]
xor r12d, r12d
lea rbp, js_promise_then_finally_func
loc_535FE:
mov rdi, r15
mov rsi, rbp
mov edx, 1
mov ecx, r12d
mov r8d, 2
mov r9, r13
call JS_NewCFunctionData
mov [r14-8], rax
mov [r14], rdx
cmp edx, 6
jz loc_536DF
inc r12
add r14, 10h
cmp r12, 1
jz short loc_535FE
jmp short loc_5366F
loc_53639:
mov [rsp+98h+var_88], r12
cmp ebp, 0FFFFFFF7h
jb short loc_5364A
mov rax, [rsp+98h+var_88]
inc dword ptr [rax]
loc_5364A:
mov [rsp+98h+var_88], r12
mov [rsp+98h+var_80], rbp
mov [rsp+98h+var_58], r12
cmp ebp, 0FFFFFFF7h
jb short loc_53665
mov rax, [rsp+98h+var_58]
inc dword ptr [rax]
loc_53665:
mov [rsp+98h+var_78], r12
mov [rsp+98h+var_70], rbp
loc_5366F:
mov rdi, [r15+18h]
mov rsi, [rsp+98h+var_90]
mov rdx, rbx
call JS_FreeValueRT
lea r12, [rsp+98h+var_88]
mov rdi, r15
mov rsi, [rsp+98h+var_60]
mov rdx, [rsp+98h+var_68]
mov ecx, 80h
mov r8d, 2
mov r9, r12
call JS_Invoke
mov r14, rax
mov rbx, rdx
mov rsi, [r12]
mov rdx, [r12+8]
mov rdi, [r15+18h]
call JS_FreeValueRT
mov rsi, [r12+10h]
mov rdx, [r12+18h]
mov rdi, [r15+18h]
call JS_FreeValueRT
mov rcx, 0FFFFFFFF00000000h
and rcx, r14
jmp short loc_53713
loc_536DF:
cmp r12, 1
jnz short loc_536F8
mov rsi, [rsp+98h+var_88]
mov rdx, [rsp+98h+var_80]
mov rdi, [r15+18h]
call JS_FreeValueRT
loc_536F8:
mov rdi, [r15+18h]
mov rsi, [rsp+98h+var_90]
mov rdx, rbx
call JS_FreeValueRT
mov ebx, 6
xor r14d, r14d
xor ecx, ecx
loc_53713:
mov eax, r14d
or rax, rcx
mov rdx, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long js_promise_finally(
long long *a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14)
{
_DWORD *v15; // r12
long long v16; // rbp
unsigned long long v17; // r14
long long v18; // rdx
long long v19; // rbx
unsigned long long v20; // rcx
long long *v21; // r14
long long v22; // r12
long long v23; // rdx
_DWORD *v25; // [rsp+8h] [rbp-90h]
_DWORD *v26; // [rsp+10h] [rbp-88h] BYREF
long long v27; // [rsp+18h] [rbp-80h] BYREF
_DWORD *v28; // [rsp+20h] [rbp-78h]
long long v29; // [rsp+28h] [rbp-70h]
long long v30; // [rsp+30h] [rbp-68h]
long long v31; // [rsp+38h] [rbp-60h]
_QWORD v32[11]; // [rsp+40h] [rbp-58h] BYREF
v15 = *(_DWORD **)a13;
v16 = *(_QWORD *)(a13 + 8);
v31 = a2;
v17 = (unsigned long long)JS_SpeciesConstructor((long long)a1, a2, a3, 0LL, 3LL, a14, a4, a5, a6, a7, a8, a9, a10, a11);
v19 = v18;
if ( (_DWORD)v18 == 6 )
{
v20 = v17 & 0xFFFFFFFF00000000LL;
}
else
{
v25 = (_DWORD *)v17;
v30 = a3;
if ( (unsigned int)JS_IsFunction((long long)a1, (long long)v15, v16) )
{
v32[0] = v17;
v32[1] = v19;
v32[2] = v15;
v32[3] = v16;
v21 = &v27;
v22 = 0LL;
while ( 1 )
{
*(v21 - 1) = JS_NewCFunctionData(a1, (long long)js_promise_then_finally_func, 1u, v22, 2, (long long)v32);
*v21 = v23;
if ( (_DWORD)v23 == 6 )
break;
++v22;
v21 += 2;
if ( v22 != 1 )
goto LABEL_13;
}
if ( v22 == 1 )
JS_FreeValueRT(a1[3], v26, v27);
JS_FreeValueRT(a1[3], v25, v19);
LODWORD(v17) = 0;
v20 = 0LL;
}
else
{
v26 = v15;
if ( (unsigned int)v16 >= 0xFFFFFFF7 )
++*v26;
v26 = v15;
v27 = v16;
v32[0] = v15;
if ( (unsigned int)v16 >= 0xFFFFFFF7 )
++*(_DWORD *)v32[0];
v28 = v15;
v29 = v16;
LABEL_13:
JS_FreeValueRT(a1[3], v25, v19);
v17 = (unsigned long long)JS_Invoke((long long)a1, v31, v30, 0x80u, 2, (long long)&v26);
JS_FreeValueRT(a1[3], v26, v27);
JS_FreeValueRT(a1[3], v28, v29);
v20 = v17 & 0xFFFFFFFF00000000LL;
}
}
return v20 | (unsigned int)v17;
}
| |||
11,339 |
js_promise_finally
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_promise_finally(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue onFinally = argv[0];
JSValue ctor, ret;
JSValue then_funcs[2];
JSValue func_data[2];
int i;
ctor = JS_SpeciesConstructor(ctx, this_val, JS_UNDEFINED);
if (JS_IsException(ctor))
return ctor;
if (!JS_IsFunction(ctx, onFinally)) {
then_funcs[0] = js_dup(onFinally);
then_funcs[1] = js_dup(onFinally);
} else {
func_data[0] = ctor;
func_data[1] = onFinally;
for(i = 0; i < 2; i++) {
then_funcs[i] = JS_NewCFunctionData(ctx, js_promise_then_finally_func, 1, i, 2, func_data);
if (JS_IsException(then_funcs[i])) {
if (i == 1)
JS_FreeValue(ctx, then_funcs[0]);
JS_FreeValue(ctx, ctor);
return JS_EXCEPTION;
}
}
}
JS_FreeValue(ctx, ctor);
ret = JS_Invoke(ctx, this_val, JS_ATOM_then, 2, then_funcs);
JS_FreeValue(ctx, then_funcs[0]);
JS_FreeValue(ctx, then_funcs[1]);
return ret;
}
|
O2
|
c
|
js_promise_finally:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r13
movq %rdi, %r15
movq (%r8), %r12
movq 0x8(%r8), %rbp
pushq $0x3
popq %r8
movq %rsi, 0x38(%rsp)
xorl %ecx, %ecx
callq 0x3bad8
movq %rax, %rbx
movq %rdx, %r14
cmpl $0x6, %r14d
jne 0x478a1
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbx, %rcx
andq %rax, %rcx
jmp 0x479e9
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1ce7d
testl %eax, %eax
movq %r14, 0x8(%rsp)
movq %rbx, (%rsp)
movq %r13, 0x30(%rsp)
je 0x47920
leaq 0x40(%rsp), %r13
movq %rbx, (%r13)
movq %r14, 0x8(%r13)
movq %r12, 0x10(%r13)
movq %rbp, 0x18(%r13)
leaq 0x18(%rsp), %rbp
xorl %r12d, %r12d
pushq $0x1
popq %r14
pushq $0x2
popq %rbx
cmpq $0x2, %r12
je 0x47980
movq %r15, %rdi
leaq 0x107(%rip), %rsi # 0x47a00
movl %r14d, %edx
movl %r12d, %ecx
movl %ebx, %r8d
movq %r13, %r9
callq 0x1b3ba
movq %rax, -0x8(%rbp)
movq %rdx, (%rbp)
cmpl $0x6, %edx
je 0x47939
incq %r12
addq $0x10, %rbp
jmp 0x478e5
cmpl $-0xa, %ebp
jbe 0x4796c
incl (%r12)
movq %r12, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
incl (%r12)
jmp 0x47976
cmpq $0x1, %r12
jne 0x47951
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0x1801e
movq %r15, %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1801e
pushq $0x6
popq %r14
xorl %ebx, %ebx
xorl %ecx, %ecx
jmp 0x479e9
movq %r12, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %rbp, 0x28(%rsp)
movq %r15, %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1801e
pushq $0x2
popq %r8
leaq 0x10(%rsp), %rbx
movq %r15, %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl $0x80, %ecx
movq %rbx, %r9
callq 0x2840b
movq %rax, %r12
movq %rdx, %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x1801e
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r12, %rbx
movq %r15, %rdi
callq 0x1801e
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %r12, %rcx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_promise_finally:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r13, rdx
mov r15, rdi
mov r12, [r8]
mov rbp, [r8+8]
push 3
pop r8
mov [rsp+98h+var_60], rsi
xor ecx, ecx
call JS_SpeciesConstructor
mov rbx, rax
mov r14, rdx
cmp r14d, 6
jnz short loc_478A1
mov rax, 0FFFFFFFF00000000h
mov rcx, rbx
and rcx, rax
jmp loc_479E9
loc_478A1:
mov rdi, r15
mov rsi, r12
mov rdx, rbp
call JS_IsFunction
test eax, eax
mov [rsp+98h+var_90], r14
mov [rsp+98h+var_98], rbx
mov [rsp+98h+var_68], r13
jz short loc_47920
lea r13, [rsp+98h+var_58]
mov [r13+0], rbx
mov [r13+8], r14
mov [r13+10h], r12
mov [r13+18h], rbp
lea rbp, [rsp+98h+var_80]
xor r12d, r12d
push 1
pop r14
push 2
pop rbx
loc_478E5:
cmp r12, 2
jz loc_47980
mov rdi, r15
lea rsi, js_promise_then_finally_func
mov edx, r14d
mov ecx, r12d
mov r8d, ebx
mov r9, r13
call JS_NewCFunctionData
mov [rbp-8], rax
mov [rbp+0], rdx
cmp edx, 6
jz short loc_47939
inc r12
add rbp, 10h
jmp short loc_478E5
loc_47920:
cmp ebp, 0FFFFFFF6h
jbe short loc_4796C
inc dword ptr [r12]
mov [rsp+98h+var_88], r12
mov [rsp+98h+var_80], rbp
inc dword ptr [r12]
jmp short loc_47976
loc_47939:
cmp r12, 1
jnz short loc_47951
mov rsi, [rsp+98h+var_88]
mov rdx, [rsp+98h+var_80]
mov rdi, r15
call JS_FreeValue
loc_47951:
mov rdi, r15
mov rsi, [rsp+98h+var_98]
mov rdx, [rsp+98h+var_90]
call JS_FreeValue
push 6
pop r14
xor ebx, ebx
xor ecx, ecx
jmp short loc_479E9
loc_4796C:
mov [rsp+98h+var_88], r12
mov [rsp+98h+var_80], rbp
loc_47976:
mov [rsp+98h+var_78], r12
mov [rsp+98h+var_70], rbp
loc_47980:
mov rdi, r15
mov rsi, [rsp+98h+var_98]
mov rdx, [rsp+98h+var_90]
call JS_FreeValue
push 2
pop r8
lea rbx, [rsp+98h+var_88]
mov rdi, r15
mov rsi, [rsp+98h+var_60]
mov rdx, [rsp+98h+var_68]
mov ecx, 80h
mov r9, rbx
call JS_Invoke
mov r12, rax
mov r14, rdx
mov rsi, [rbx]
mov rdx, [rbx+8]
mov rdi, r15
call JS_FreeValue
mov rsi, [rbx+10h]
mov rdx, [rbx+18h]
mov rbx, r12
mov rdi, r15
call JS_FreeValue
mov rcx, 0FFFFFFFF00000000h
and rcx, r12
loc_479E9:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long js_promise_finally(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14)
{
_DWORD *v15; // r12
long long v16; // rbp
long long v17; // rbx
long long v18; // rdx
long long v19; // r14
unsigned long long v20; // rcx
long long *v21; // rbp
long long i; // r12
long long v23; // rdx
long long v24; // r12
_DWORD *v26; // [rsp+10h] [rbp-88h] BYREF
long long v27; // [rsp+18h] [rbp-80h] BYREF
_DWORD *v28; // [rsp+20h] [rbp-78h]
long long v29; // [rsp+28h] [rbp-70h]
long long v30; // [rsp+30h] [rbp-68h]
long long v31; // [rsp+38h] [rbp-60h]
_QWORD v32[11]; // [rsp+40h] [rbp-58h] BYREF
v15 = *(_DWORD **)a13;
v16 = *(_QWORD *)(a13 + 8);
v31 = a2;
v17 = (long long)JS_SpeciesConstructor(a1, a2, a3, 0LL, 3LL, a14, a4, a5, a6, a7, a8, a9, a10, a11);
v19 = v18;
if ( (_DWORD)v18 == 6 )
{
v20 = v17 & 0xFFFFFFFF00000000LL;
}
else
{
v30 = a3;
if ( (unsigned int)JS_IsFunction(a1, (long long)v15, v16) )
{
v32[0] = v17;
v32[1] = v19;
v32[2] = v15;
v32[3] = v16;
v21 = &v27;
for ( i = 0LL; i != 2; ++i )
{
*(v21 - 1) = JS_NewCFunctionData(a1, (long long)js_promise_then_finally_func, 1u, i, 2u, (long long)v32);
*v21 = v23;
if ( (_DWORD)v23 == 6 )
{
if ( i == 1 )
JS_FreeValue(a1, (long long)v26, v27);
JS_FreeValue(a1, v17, v19);
LODWORD(v17) = 0;
v20 = 0LL;
return v20 | (unsigned int)v17;
}
v21 += 2;
}
}
else
{
if ( (unsigned int)v16 <= 0xFFFFFFF6 )
{
v26 = v15;
v27 = v16;
}
else
{
++*v15;
v26 = v15;
v27 = v16;
++*v15;
}
v28 = v15;
v29 = v16;
}
JS_FreeValue(a1, v17, v19);
v24 = JS_Invoke(a1, v31, v30, 128, 2, (long long)&v26);
JS_FreeValue(a1, (long long)v26, v27);
LODWORD(v17) = v24;
JS_FreeValue(a1, (long long)v28, v29);
v20 = v24 & 0xFFFFFFFF00000000LL;
}
return v20 | (unsigned int)v17;
}
|
js_promise_finally:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R13,RDX
MOV R15,RDI
MOV R12,qword ptr [R8]
MOV RBP,qword ptr [R8 + 0x8]
PUSH 0x3
POP R8
MOV qword ptr [RSP + 0x38],RSI
XOR ECX,ECX
CALL 0x0013bad8
MOV RBX,RAX
MOV R14,RDX
CMP R14D,0x6
JNZ 0x001478a1
MOV RAX,-0x100000000
MOV RCX,RBX
AND RCX,RAX
JMP 0x001479e9
LAB_001478a1:
MOV RDI,R15
MOV RSI,R12
MOV RDX,RBP
CALL 0x0011ce7d
TEST EAX,EAX
MOV qword ptr [RSP + 0x8],R14
MOV qword ptr [RSP],RBX
MOV qword ptr [RSP + 0x30],R13
JZ 0x00147920
LEA R13,[RSP + 0x40]
MOV qword ptr [R13],RBX
MOV qword ptr [R13 + 0x8],R14
MOV qword ptr [R13 + 0x10],R12
MOV qword ptr [R13 + 0x18],RBP
LEA RBP,[RSP + 0x18]
XOR R12D,R12D
PUSH 0x1
POP R14
PUSH 0x2
POP RBX
LAB_001478e5:
CMP R12,0x2
JZ 0x00147980
MOV RDI,R15
LEA RSI,[0x147a00]
MOV EDX,R14D
MOV ECX,R12D
MOV R8D,EBX
MOV R9,R13
CALL 0x0011b3ba
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP],RDX
CMP EDX,0x6
JZ 0x00147939
INC R12
ADD RBP,0x10
JMP 0x001478e5
LAB_00147920:
CMP EBP,-0xa
JBE 0x0014796c
INC dword ptr [R12]
MOV qword ptr [RSP + 0x10],R12
MOV qword ptr [RSP + 0x18],RBP
INC dword ptr [R12]
JMP 0x00147976
LAB_00147939:
CMP R12,0x1
JNZ 0x00147951
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
MOV RDI,R15
CALL 0x0011801e
LAB_00147951:
MOV RDI,R15
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0011801e
PUSH 0x6
POP R14
XOR EBX,EBX
XOR ECX,ECX
JMP 0x001479e9
LAB_0014796c:
MOV qword ptr [RSP + 0x10],R12
MOV qword ptr [RSP + 0x18],RBP
LAB_00147976:
MOV qword ptr [RSP + 0x20],R12
MOV qword ptr [RSP + 0x28],RBP
LAB_00147980:
MOV RDI,R15
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0011801e
PUSH 0x2
POP R8
LEA RBX,[RSP + 0x10]
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x30]
MOV ECX,0x80
MOV R9,RBX
CALL 0x0012840b
MOV R12,RAX
MOV R14,RDX
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
MOV RDI,R15
CALL 0x0011801e
MOV RSI,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x18]
MOV RBX,R12
MOV RDI,R15
CALL 0x0011801e
MOV RCX,-0x100000000
AND RCX,R12
LAB_001479e9:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_promise_finally(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int *piVar1;
int8 uVar2;
int iVar3;
ulong uVar4;
int **ppiVar5;
ulong uVar6;
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
int *local_88 [5];
int8 local_60;
int1 local_58 [16];
int *local_48;
int8 local_40;
piVar1 = (int *)*param_5;
uVar2 = param_5[1];
local_60 = param_2;
auVar7 = JS_SpeciesConstructor();
uVar4 = auVar7._0_8_;
if (auVar7._8_4_ == 6) {
uVar4 = uVar4 & 0xffffffff00000000;
}
else {
iVar3 = JS_IsFunction(param_1,piVar1,uVar2);
auVar8._8_8_ = local_58._8_8_;
auVar8._0_8_ = local_58._0_8_;
local_88[4] = (int *)param_3;
if (iVar3 == 0) {
local_88[0] = piVar1;
local_88[1] = (int *)uVar2;
local_88[2] = piVar1;
local_88[3] = (int *)uVar2;
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
*piVar1 = *piVar1 + 1;
local_58 = auVar8;
}
}
else {
ppiVar5 = local_88 + 1;
local_48 = piVar1;
local_40 = uVar2;
local_58 = auVar7;
for (uVar6 = 0; uVar6 != 2; uVar6 = uVar6 + 1) {
auVar8 = JS_NewCFunctionData(param_1,js_promise_then_finally_func,1,uVar6 & 0xffffffff,2,
local_58);
ppiVar5[-1] = auVar8._0_8_;
*ppiVar5 = auVar8._8_8_;
if (auVar8._8_4_ == 6) {
if (uVar6 == 1) {
JS_FreeValue(param_1,local_88[0],local_88[1]);
}
JS_FreeValue(param_1,uVar4,auVar7._8_8_);
auVar7 = ZEXT816(6) << 0x40;
uVar4 = 0;
goto LAB_001479e9;
}
ppiVar5 = ppiVar5 + 2;
}
}
JS_FreeValue(param_1,uVar4,auVar7._8_8_);
auVar7 = JS_Invoke(param_1,local_60,local_88[4],0x80,2,local_88);
JS_FreeValue(param_1,local_88[0],local_88[1]);
JS_FreeValue(param_1,local_88[2],local_88[3]);
uVar4 = auVar7._0_8_ & 0xffffffff00000000;
}
LAB_001479e9:
auVar9._0_8_ = auVar7._0_8_ & 0xffffffff | uVar4;
auVar9._8_8_ = auVar7._8_8_;
return auVar9;
}
|
|
11,340 |
ma_skip_pack_key
|
eloqsql/storage/maria/ma_search.c
|
uchar *_ma_skip_pack_key(MARIA_KEY *key, uint page_flag,
uint nod_flag, uchar *page)
{
reg1 HA_KEYSEG *keyseg;
for (keyseg= key->keyinfo->seg ; keyseg->type ; keyseg++)
{
if (keyseg->flag & HA_PACK_KEY)
{
/* key with length, packed to previous key */
uint packed= *page & 128, length;
if (keyseg->length >= 127)
{
length= mi_uint2korr(page) & 32767;
page+= 2;
}
else
length= *page++ & 127;
if (packed)
{
if (length == 0) /* Same key */
continue;
get_key_length(length,page);
page+= length;
continue;
}
if ((keyseg->flag & HA_NULL_PART) && length)
{
/*
Keys that can have null use length+1 as the length for date as the
number 0 is reserved for keys that have a NULL value
*/
length--;
}
page+= length;
}
else
{
if (keyseg->flag & HA_NULL_PART)
if (!*page++)
continue;
if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
{
uint length;
get_key_length(length,page);
page+=length;
}
else
page+= keyseg->length;
}
}
page+= keyseg->length;
if ((page_flag & KEYPAGE_FLAG_HAS_TRANSID) && key_has_transid(page-1))
page+= transid_packed_length(page);
return page + nod_flag;
}
|
O3
|
c
|
ma_skip_pack_key:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movq 0xc0(%rax), %rax
cmpb $0x0, 0x18(%rax)
je 0x578a1
movzwl 0x12(%rax), %edi
testb $0x2, %dil
jne 0x57811
testb $0x10, %dil
je 0x57805
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
je 0x5788e
testb $0x29, %dil
jne 0x57863
movzwl 0x14(%rax), %edi
jmp 0x5788b
movzbl (%rcx), %r9d
cmpw $0x7f, 0x14(%rax)
jb 0x57835
movzbl 0x1(%rcx), %r10d
movl %r9d, %r8d
andl $0x7f, %r8d
shll $0x8, %r8d
orl %r10d, %r8d
addq $0x2, %rcx
jmp 0x5783f
incq %rcx
movl %r9d, %r8d
andl $0x7f, %r8d
testb %r9b, %r9b
js 0x5785e
shrb $0x4, %dil
testl %r8d, %r8d
setne %r9b
andb %dil, %r9b
movzbl %r9b, %edi
subl %edi, %r8d
addq %r8, %rcx
jmp 0x5788e
testl %r8d, %r8d
je 0x5788e
movzbl (%rcx), %edi
cmpq $0xff, %rdi
je 0x57877
movl $0x1, %r8d
jmp 0x57888
movzwl 0x1(%rcx), %edi
rolw $0x8, %di
movzwl %di, %edi
movl $0x3, %r8d
addq %r8, %rcx
addq %rdi, %rcx
leaq 0x20(%rax), %rdi
cmpb $0x0, 0x38(%rax)
movq %rdi, %rax
jne 0x577e8
jmp 0x578a4
movq %rax, %rdi
movzwl 0x14(%rdi), %edi
addq %rcx, %rdi
testb $0x2, %sil
je 0x578d1
testb $0x1, -0x1(%rdi)
je 0x578d1
movzbl (%rdi), %eax
leal -0xf8(%rax), %ecx
cmpl $0xf3, %eax
movl $0x1, %eax
cmovaeq %rcx, %rax
addq %rax, %rdi
movl %edx, %eax
addq %rdi, %rax
popq %rbp
retq
|
_ma_skip_pack_key:
push rbp
mov rbp, rsp
mov rax, [rdi+8]
mov rax, [rax+0C0h]
cmp byte ptr [rax+18h], 0
jz loc_578A1
loc_577E8:
movzx edi, word ptr [rax+12h]
test dil, 2
jnz short loc_57811
test dil, 10h
jz short loc_57805
cmp byte ptr [rcx], 0
lea rcx, [rcx+1]
jz loc_5788E
loc_57805:
test dil, 29h
jnz short loc_57863
movzx edi, word ptr [rax+14h]
jmp short loc_5788B
loc_57811:
movzx r9d, byte ptr [rcx]
cmp word ptr [rax+14h], 7Fh
jb short loc_57835
movzx r10d, byte ptr [rcx+1]
mov r8d, r9d
and r8d, 7Fh
shl r8d, 8
or r8d, r10d
add rcx, 2
jmp short loc_5783F
loc_57835:
inc rcx
mov r8d, r9d
and r8d, 7Fh
loc_5783F:
test r9b, r9b
js short loc_5785E
shr dil, 4
test r8d, r8d
setnz r9b
and r9b, dil
movzx edi, r9b
sub r8d, edi
add rcx, r8
jmp short loc_5788E
loc_5785E:
test r8d, r8d
jz short loc_5788E
loc_57863:
movzx edi, byte ptr [rcx]
cmp rdi, 0FFh
jz short loc_57877
mov r8d, 1
jmp short loc_57888
loc_57877:
movzx edi, word ptr [rcx+1]
rol di, 8
movzx edi, di
mov r8d, 3
loc_57888:
add rcx, r8
loc_5788B:
add rcx, rdi
loc_5788E:
lea rdi, [rax+20h]
cmp byte ptr [rax+38h], 0
mov rax, rdi
jnz loc_577E8
jmp short loc_578A4
loc_578A1:
mov rdi, rax
loc_578A4:
movzx edi, word ptr [rdi+14h]
add rdi, rcx
test sil, 2
jz short loc_578D1
test byte ptr [rdi-1], 1
jz short loc_578D1
movzx eax, byte ptr [rdi]
lea ecx, [rax-0F8h]
cmp eax, 0F3h
mov eax, 1
cmovnb rax, rcx
add rdi, rax
loc_578D1:
mov eax, edx
add rax, rdi
pop rbp
retn
|
unsigned __int8 * ma_skip_pack_key(long long a1, char a2, int a3, unsigned __int8 *a4)
{
long long v4; // rax
__int16 v5; // di
bool v6; // zf
long long v7; // rdi
char v8; // r9
int v9; // r8d
long long v10; // r8
long long v11; // rdi
unsigned __int8 *v12; // rdi
unsigned int v13; // eax
long long v14; // rcx
bool v15; // cf
long long v16; // rax
v4 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 192LL);
if ( *(_BYTE *)(v4 + 24) )
{
while ( 1 )
{
v5 = *(_WORD *)(v4 + 18);
if ( (v5 & 2) == 0 )
break;
v8 = *a4;
if ( *(_WORD *)(v4 + 20) < 0x7Fu )
{
++a4;
v9 = v8 & 0x7F;
}
else
{
v9 = a4[1] | ((v8 & 0x7F) << 8);
a4 += 2;
}
if ( v8 < 0 )
{
if ( v9 )
goto LABEL_13;
}
else
{
a4 += v9 - (unsigned int)(((unsigned __int8)v5 >> 4) & (v9 != 0));
}
LABEL_18:
v11 = v4 + 32;
v6 = *(_BYTE *)(v4 + 56) == 0;
v4 += 32LL;
if ( v6 )
goto LABEL_21;
}
if ( (v5 & 0x10) != 0 )
{
v6 = *a4++ == 0;
if ( v6 )
goto LABEL_18;
}
if ( (v5 & 0x29) != 0 )
{
LABEL_13:
v7 = *a4;
if ( v7 == 255 )
{
v7 = (unsigned __int16)__ROL2__(*(_WORD *)(a4 + 1), 8);
v10 = 3LL;
}
else
{
v10 = 1LL;
}
a4 += v10;
}
else
{
v7 = *(unsigned __int16 *)(v4 + 20);
}
a4 += v7;
goto LABEL_18;
}
v11 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 192LL);
LABEL_21:
v12 = &a4[*(unsigned __int16 *)(v11 + 20)];
if ( (a2 & 2) != 0 && (*(v12 - 1) & 1) != 0 )
{
v13 = *v12;
v14 = v13 - 248;
v15 = v13 < 0xF3;
v16 = 1LL;
if ( !v15 )
v16 = v14;
v12 += v16;
}
return &v12[a3];
}
|
_ma_skip_pack_key:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RAX + 0xc0]
CMP byte ptr [RAX + 0x18],0x0
JZ 0x001578a1
LAB_001577e8:
MOVZX EDI,word ptr [RAX + 0x12]
TEST DIL,0x2
JNZ 0x00157811
TEST DIL,0x10
JZ 0x00157805
CMP byte ptr [RCX],0x0
LEA RCX,[RCX + 0x1]
JZ 0x0015788e
LAB_00157805:
TEST DIL,0x29
JNZ 0x00157863
MOVZX EDI,word ptr [RAX + 0x14]
JMP 0x0015788b
LAB_00157811:
MOVZX R9D,byte ptr [RCX]
CMP word ptr [RAX + 0x14],0x7f
JC 0x00157835
MOVZX R10D,byte ptr [RCX + 0x1]
MOV R8D,R9D
AND R8D,0x7f
SHL R8D,0x8
OR R8D,R10D
ADD RCX,0x2
JMP 0x0015783f
LAB_00157835:
INC RCX
MOV R8D,R9D
AND R8D,0x7f
LAB_0015783f:
TEST R9B,R9B
JS 0x0015785e
SHR DIL,0x4
TEST R8D,R8D
SETNZ R9B
AND R9B,DIL
MOVZX EDI,R9B
SUB R8D,EDI
ADD RCX,R8
JMP 0x0015788e
LAB_0015785e:
TEST R8D,R8D
JZ 0x0015788e
LAB_00157863:
MOVZX EDI,byte ptr [RCX]
CMP RDI,0xff
JZ 0x00157877
MOV R8D,0x1
JMP 0x00157888
LAB_00157877:
MOVZX EDI,word ptr [RCX + 0x1]
ROL DI,0x8
MOVZX EDI,DI
MOV R8D,0x3
LAB_00157888:
ADD RCX,R8
LAB_0015788b:
ADD RCX,RDI
LAB_0015788e:
LEA RDI,[RAX + 0x20]
CMP byte ptr [RAX + 0x38],0x0
MOV RAX,RDI
JNZ 0x001577e8
JMP 0x001578a4
LAB_001578a1:
MOV RDI,RAX
LAB_001578a4:
MOVZX EDI,word ptr [RDI + 0x14]
ADD RDI,RCX
TEST SIL,0x2
JZ 0x001578d1
TEST byte ptr [RDI + -0x1],0x1
JZ 0x001578d1
MOVZX EAX,byte ptr [RDI]
LEA ECX,[RAX + -0xf8]
CMP EAX,0xf3
MOV EAX,0x1
CMOVNC RAX,RCX
ADD RDI,RAX
LAB_001578d1:
MOV EAX,EDX
ADD RAX,RDI
POP RBP
RET
|
byte * _ma_skip_pack_key(long param_1,byte param_2,uint param_3,byte *param_4)
{
char cVar1;
byte bVar2;
ushort uVar3;
long lVar4;
ulong uVar5;
uint uVar6;
long lVar7;
lVar4 = *(long *)(*(long *)(param_1 + 8) + 0xc0);
cVar1 = *(char *)(lVar4 + 0x18);
do {
if (cVar1 == '\0') {
param_4 = param_4 + *(ushort *)(lVar4 + 0x14);
if (((param_2 & 2) != 0) && ((param_4[-1] & 1) != 0)) {
uVar5 = 1;
if (0xf2 < *param_4) {
uVar5 = (ulong)(*param_4 - 0xf8);
}
param_4 = param_4 + uVar5;
}
return param_4 + param_3;
}
uVar3 = *(ushort *)(lVar4 + 0x12);
if ((uVar3 & 2) == 0) {
if (((uVar3 & 0x10) == 0) || (bVar2 = *param_4, param_4 = param_4 + 1, bVar2 != 0)) {
if ((uVar3 & 0x29) == 0) {
uVar5 = (ulong)*(ushort *)(lVar4 + 0x14);
}
else {
LAB_00157863:
uVar5 = (ulong)*param_4;
if (uVar5 == 0xff) {
uVar5 = (ulong)(ushort)(*(ushort *)(param_4 + 1) << 8 | *(ushort *)(param_4 + 1) >> 8);
lVar7 = 3;
}
else {
lVar7 = 1;
}
param_4 = param_4 + lVar7;
}
param_4 = param_4 + uVar5;
}
}
else {
bVar2 = *param_4;
if (*(ushort *)(lVar4 + 0x14) < 0x7f) {
param_4 = param_4 + 1;
uVar6 = bVar2 & 0x7f;
}
else {
uVar6 = (bVar2 & 0x7f) << 8 | (uint)param_4[1];
param_4 = param_4 + 2;
}
if ((char)bVar2 < '\0') {
if (uVar6 != 0) goto LAB_00157863;
}
else {
param_4 = param_4 + (uVar6 - (uVar6 != 0 & (byte)uVar3 >> 4));
}
}
cVar1 = *(char *)(lVar4 + 0x38);
lVar4 = lVar4 + 0x20;
} while( true );
}
|
|
11,341 |
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>>>::count(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&) const
|
monkey531[P]llama/common/./json.hpp
|
size_type count(const key_type& key) const
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return 1;
}
}
return 0;
}
|
O0
|
cpp
|
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>>>::count(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&) const:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xa5420
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0xa5450
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xdde90
testb $0x1, %al
jne 0xdde36
jmp 0xdde7d
movq 0x8(%rsp), %rax
addq $0x18, %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0xdded0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0xcf9a0
testb $0x1, %al
jne 0xdde64
jmp 0xdde6f
movq $0x1, 0x30(%rsp)
jmp 0xdde86
jmp 0xdde71
leaq 0x18(%rsp), %rdi
callq 0xddee0
jmp 0xdde12
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
|
_ZNK8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE5countERSJ_:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov rdi, [rsp+38h+var_10]
mov [rsp+38h+var_30], rdi
call _ZNKSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE5beginEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::begin(void)
mov [rsp+38h+var_20], rax
loc_DDE12:
mov rdi, [rsp+38h+var_30]
call _ZNKSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE3endEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::end(void)
mov [rsp+38h+var_28], rax
lea rdi, [rsp+38h+var_20]
lea rsi, [rsp+38h+var_28]
call _ZN9__gnu_cxxneIPKSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbRKNS_17__normal_iteratorIT_T0_EESU_; __gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> const*,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> const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&,__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&)
test al, 1
jnz short loc_DDE36
jmp short loc_DDE7D
loc_DDE36:
mov rax, [rsp+38h+var_30]
add rax, 18h
mov [rsp+38h+var_38], rax
lea rdi, [rsp+38h+var_20]
call _ZNK9__gnu_cxx17__normal_iteratorIPKSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator->(void)
mov rdi, [rsp+38h+var_38]
mov rsi, rax
mov rdx, [rsp+38h+var_18]
call _ZNKSt8equal_toIvEclIRKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEESI_EEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSJ_OSK_
test al, 1
jnz short loc_DDE64
jmp short loc_DDE6F
loc_DDE64:
mov [rsp+38h+var_8], 1
jmp short loc_DDE86
loc_DDE6F:
jmp short $+2
loc_DDE71:
lea rdi, [rsp+38h+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPKSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator++(void)
jmp short loc_DDE12
loc_DDE7D:
mov [rsp+38h+var_8], 0
loc_DDE86:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
|
long long 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>>>::count(
long long a1,
long long a2)
{
long long v2; // rsi
long long v4; // [rsp+10h] [rbp-28h] BYREF
long long i; // [rsp+18h] [rbp-20h] BYREF
long long v6; // [rsp+20h] [rbp-18h]
long long v7; // [rsp+28h] [rbp-10h]
v7 = a1;
v6 = a2;
for ( i = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::begin(a1);
;
__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator++(&i) )
{
v4 = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::end(a1);
if ( (__gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>(
&i,
&v4) & 1) == 0 )
break;
v2 = __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator->(&i);
if ( (std::equal_to<void>::operator()<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&,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&>(
a1 + 24,
v2,
v6) & 1) != 0 )
return 1LL;
}
return 0LL;
}
|
count:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV RDI,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001a5420
MOV qword ptr [RSP + 0x18],RAX
LAB_001dde12:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001a5450
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x10]
CALL 0x001dde90
TEST AL,0x1
JNZ 0x001dde36
JMP 0x001dde7d
LAB_001dde36:
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x18
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x18]
CALL 0x001dded0
MOV RDI,qword ptr [RSP]
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x001cf9a0
TEST AL,0x1
JNZ 0x001dde64
JMP 0x001dde6f
LAB_001dde64:
MOV qword ptr [RSP + 0x30],0x1
JMP 0x001dde86
LAB_001dde6f:
JMP 0x001dde71
LAB_001dde71:
LEA RDI,[RSP + 0x18]
CALL 0x001ddee0
JMP 0x001dde12
LAB_001dde7d:
MOV qword ptr [RSP + 0x30],0x0
LAB_001dde86:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
/* 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> >
>::count(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&) const */
int8 __thiscall
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>>>
::count(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>>>
*this,basic_json *param_1)
{
bool bVar1;
basic_json *pbVar2;
ulong uVar3;
int8 local_28;
int8 local_20;
basic_json *local_18;
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>>>
*local_10;
local_18 = param_1;
local_10 = this;
local_20 = std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::begin((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this);
while( true ) {
local_28 = std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::end((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this);
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_20,(__normal_iterator *)&local_28);
if (!bVar1) {
return 0;
}
pbVar2 = (basic_json *)
__gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator->((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_20);
uVar3 = std::equal_to<void>::operator()((equal_to<void> *)(this + 0x18),pbVar2,local_18);
if ((uVar3 & 1) != 0) break;
__gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator++((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>const*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_20);
}
return 1;
}
|
|
11,342 |
PFS_user_allocator::free_array(PFS_user_array*)
|
eloqsql/storage/perfschema/pfs_buffer_container.cc
|
void PFS_user_allocator::free_array(PFS_user_array *array)
{
size_t size= array->m_max;
size_t waits_sizing= size * wait_class_max;
size_t stages_sizing= size * stage_class_max;
size_t statements_sizing= size * statement_class_max;
size_t transactions_sizing= size * transaction_class_max;
size_t memory_sizing= size * memory_class_max;
PFS_FREE_ARRAY(& builtin_memory_user,
size, sizeof(PFS_user), array->m_ptr);
array->m_ptr= NULL;
PFS_FREE_ARRAY(& builtin_memory_user_waits,
waits_sizing, sizeof(PFS_single_stat),
array->m_instr_class_waits_array);
array->m_instr_class_waits_array= NULL;
PFS_FREE_ARRAY(& builtin_memory_user_stages,
stages_sizing, sizeof(PFS_stage_stat),
array->m_instr_class_stages_array);
array->m_instr_class_stages_array= NULL;
PFS_FREE_ARRAY(& builtin_memory_user_statements,
statements_sizing, sizeof(PFS_statement_stat),
array->m_instr_class_statements_array);
array->m_instr_class_statements_array= NULL;
PFS_FREE_ARRAY(& builtin_memory_user_transactions,
transactions_sizing, sizeof(PFS_transaction_stat),
array->m_instr_class_transactions_array);
array->m_instr_class_transactions_array= NULL;
PFS_FREE_ARRAY(& builtin_memory_user_memory,
memory_sizing, sizeof(PFS_memory_stat),
array->m_instr_class_memory_array);
array->m_instr_class_memory_array= NULL;
}
|
O0
|
cpp
|
PFS_user_allocator::free_array(PFS_user_array*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3dd759(%rip), %rcx # 0x40a8e0
movl (%rcx), %ecx
imulq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3dcef4(%rip), %rcx # 0x40a090
imulq (%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3dcef1(%rip), %rcx # 0x40a0a0
imulq (%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3dcf0e(%rip), %rcx # 0x40a0d0
imulq (%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3dceeb(%rip), %rcx # 0x40a0c0
imulq (%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
leaq 0x3da3d0(%rip), %rdi # 0x4075c0
movl $0x9c0, %edx # imm = 0x9C0
callq 0x29bc0
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
leaq 0x3da4e7(%rip), %rdi # 0x407700
movl $0x20, %edx
callq 0x29bc0
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
leaq 0x3da5fe(%rip), %rdi # 0x407840
movl $0x20, %edx
callq 0x29bc0
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
leaq 0x3da715(%rip), %rdi # 0x407980
movl $0xb8, %edx
callq 0x29bc0
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rcx
leaq 0x3da82c(%rip), %rdi # 0x407ac0
movl $0x58, %edx
callq 0x29bc0
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
leaq 0x3da940(%rip), %rdi # 0x407c00
movl $0x48, %edx
callq 0x29bc0
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
|
_ZN18PFS_user_allocator10free_arrayEP14PFS_user_array:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax+50h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
lea rcx, wait_class_max
mov ecx, [rcx]
imul rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
lea rcx, stage_class_max
imul rax, [rcx]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
lea rcx, statement_class_max
imul rax, [rcx]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
lea rcx, transaction_class_max
imul rax, [rcx]
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
lea rcx, memory_class_max
imul rax, [rcx]
mov [rbp+var_40], rax
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rcx, [rax+48h]
lea rdi, builtin_memory_user
mov edx, 9C0h
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+48h], 0
mov rsi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rcx, [rax+60h]
lea rdi, builtin_memory_user_waits
mov edx, 20h ; ' '
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+60h], 0
mov rsi, [rbp+var_28]
mov rax, [rbp+var_10]
mov rcx, [rax+68h]
lea rdi, builtin_memory_user_stages
mov edx, 20h ; ' '
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+68h], 0
mov rsi, [rbp+var_30]
mov rax, [rbp+var_10]
mov rcx, [rax+70h]
lea rdi, builtin_memory_user_statements
mov edx, 0B8h
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+70h], 0
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rcx, [rax+78h]
lea rdi, builtin_memory_user_transactions
mov edx, 58h ; 'X'
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+78h], 0
mov rsi, [rbp+var_40]
mov rax, [rbp+var_10]
mov rcx, [rax+80h]
lea rdi, builtin_memory_user_memory
mov edx, 48h ; 'H'
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+80h], 0
add rsp, 40h
pop rbp
retn
|
PFS_user_array * PFS_user_allocator::free_array(PFS_user_allocator *this, PFS_user_array *a2)
{
PFS_user_array *result; // rax
long long v3; // [rsp+0h] [rbp-40h]
long long v4; // [rsp+8h] [rbp-38h]
long long v5; // [rsp+10h] [rbp-30h]
long long v6; // [rsp+18h] [rbp-28h]
long long v7; // [rsp+20h] [rbp-20h]
long long v8; // [rsp+28h] [rbp-18h]
v8 = *((_QWORD *)a2 + 10);
v7 = (unsigned int)wait_class_max * v8;
v6 = stage_class_max * v8;
v5 = statement_class_max * v8;
v4 = transaction_class_max * v8;
v3 = memory_class_max * v8;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user, v8, 2496LL, *((void **)a2 + 9));
*((_QWORD *)a2 + 9) = 0LL;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user_waits, v7, 32LL, *((void **)a2 + 12));
*((_QWORD *)a2 + 12) = 0LL;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user_stages, v6, 32LL, *((void **)a2 + 13));
*((_QWORD *)a2 + 13) = 0LL;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user_statements, v5, 184LL, *((void **)a2 + 14));
*((_QWORD *)a2 + 14) = 0LL;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user_transactions, v4, 88LL, *((void **)a2 + 15));
*((_QWORD *)a2 + 15) = 0LL;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user_memory, v3, 72LL, *((void **)a2 + 16));
result = a2;
*((_QWORD *)a2 + 16) = 0LL;
return result;
}
|
free_array:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x50a8e0]
MOV ECX,dword ptr [RCX]
IMUL RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x50a090]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x50a0a0]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x50a0d0]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x50a0c0]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x40],RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x48]
LEA RDI,[0x5075c0]
MOV EDX,0x9c0
CALL 0x00129bc0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],0x0
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x60]
LEA RDI,[0x507700]
MOV EDX,0x20
CALL 0x00129bc0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x60],0x0
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x68]
LEA RDI,[0x507840]
MOV EDX,0x20
CALL 0x00129bc0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x68],0x0
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x70]
LEA RDI,[0x507980]
MOV EDX,0xb8
CALL 0x00129bc0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x70],0x0
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x78]
LEA RDI,[0x507ac0]
MOV EDX,0x58
CALL 0x00129bc0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x78],0x0
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x80]
LEA RDI,[0x507c00]
MOV EDX,0x48
CALL 0x00129bc0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x80],0x0
ADD RSP,0x40
POP RBP
RET
|
/* PFS_user_allocator::free_array(PFS_user_array*) */
void __thiscall PFS_user_allocator::free_array(PFS_user_allocator *this,PFS_user_array *param_1)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
uVar1 = *(ulong *)(param_1 + 0x50);
uVar6 = (ulong)wait_class_max;
uVar2 = uVar1 * stage_class_max;
uVar3 = uVar1 * statement_class_max;
uVar4 = uVar1 * transaction_class_max;
uVar5 = uVar1 * memory_class_max;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user,uVar1,0x9c0,
*(void **)(param_1 + 0x48));
*(int8 *)(param_1 + 0x48) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user_waits,uVar1 * uVar6,0x20,
*(void **)(param_1 + 0x60));
*(int8 *)(param_1 + 0x60) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user_stages,uVar2,0x20,
*(void **)(param_1 + 0x68));
*(int8 *)(param_1 + 0x68) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user_statements,uVar3,0xb8,
*(void **)(param_1 + 0x70));
*(int8 *)(param_1 + 0x70) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user_transactions,uVar4,0x58,
*(void **)(param_1 + 0x78));
*(int8 *)(param_1 + 0x78) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user_memory,uVar5,0x48,
*(void **)(param_1 + 0x80));
*(int8 *)(param_1 + 0x80) = 0;
return;
}
|
|
11,343 |
my_caseup_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static size_t my_caseup_ucs2(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_ucs2_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
{
my_toupper_ucs2(uni_plane, &wc);
if (res != my_uni_ucs2(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O3
|
c
|
my_caseup_ucs2:
movq %rdx, %rax
cmpq $0x2, %rdx
jl 0xe4f4b
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rax), %rdx
addq %rcx, %r8
movq 0x78(%rdi), %rdi
addq $0x2, %rcx
movzbl (%rsi), %r9d
movzbl 0x1(%rsi), %r10d
movq 0x8(%rdi), %r11
movq (%r11,%r9,8), %r11
testq %r11, %r11
je 0xe4f12
leaq (%r10,%r10,2), %r9
movl (%r11,%r9,4), %r9d
jmp 0xe4f19
shll $0x8, %r9d
orq %r10, %r9
cmpq %r8, %rcx
ja 0xe4f4a
cmpl $0xffff, %r9d # imm = 0xFFFF
ja 0xe4f4a
rolw $0x8, %r9w
movw %r9w, -0x2(%rcx)
leaq 0x2(%rsi), %r9
cmpq %rdx, %r9
jae 0xe4f4a
addq $0x4, %rsi
addq $0x2, %rcx
cmpq %rdx, %rsi
movq %r9, %rsi
jbe 0xe4ef2
popq %rbp
retq
|
my_caseup_ucs2:
mov rax, rdx
cmp rdx, 2
jl short locret_E4F4B
push rbp
mov rbp, rsp
lea rdx, [rsi+rax]
add r8, rcx
mov rdi, [rdi+78h]
add rcx, 2
loc_E4EF2:
movzx r9d, byte ptr [rsi]
movzx r10d, byte ptr [rsi+1]
mov r11, [rdi+8]
mov r11, [r11+r9*8]
test r11, r11
jz short loc_E4F12
lea r9, [r10+r10*2]
mov r9d, [r11+r9*4]
jmp short loc_E4F19
loc_E4F12:
shl r9d, 8
or r9, r10
loc_E4F19:
cmp rcx, r8
ja short loc_E4F4A
cmp r9d, 0FFFFh
ja short loc_E4F4A
rol r9w, 8
mov [rcx-2], r9w
lea r9, [rsi+2]
cmp r9, rdx
jnb short loc_E4F4A
add rsi, 4
add rcx, 2
cmp rsi, rdx
mov rsi, r9
jbe short loc_E4EF2
loc_E4F4A:
pop rbp
locret_E4F4B:
retn
|
long long my_caseup_ucs2(long long a1, unsigned __int8 *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
unsigned long long v6; // rdx
unsigned long long v7; // r8
long long v8; // rdi
unsigned long long v9; // rcx
long long v10; // r9
long long v11; // r10
long long v12; // r11
unsigned int v13; // r9d
bool v14; // cc
result = a3;
if ( a3 >= 2 )
{
v6 = (unsigned long long)&a2[a3];
v7 = a4 + a5;
v8 = *(_QWORD *)(a1 + 120);
v9 = a4 + 2;
do
{
v10 = *a2;
v11 = a2[1];
v12 = *(_QWORD *)(*(_QWORD *)(v8 + 8) + 8 * v10);
if ( v12 )
v13 = *(_DWORD *)(v12 + 12 * v11);
else
v13 = v11 | ((_DWORD)v10 << 8);
if ( v9 > v7 )
break;
if ( v13 > 0xFFFF )
break;
*(_WORD *)(v9 - 2) = __ROL2__(v13, 8);
if ( (unsigned long long)(a2 + 2) >= v6 )
break;
v9 += 2LL;
v14 = (unsigned long long)(a2 + 4) <= v6;
a2 += 2;
}
while ( v14 );
}
return result;
}
|
my_caseup_ucs2:
MOV RAX,RDX
CMP RDX,0x2
JL 0x001e4f4b
PUSH RBP
MOV RBP,RSP
LEA RDX,[RSI + RAX*0x1]
ADD R8,RCX
MOV RDI,qword ptr [RDI + 0x78]
ADD RCX,0x2
LAB_001e4ef2:
MOVZX R9D,byte ptr [RSI]
MOVZX R10D,byte ptr [RSI + 0x1]
MOV R11,qword ptr [RDI + 0x8]
MOV R11,qword ptr [R11 + R9*0x8]
TEST R11,R11
JZ 0x001e4f12
LEA R9,[R10 + R10*0x2]
MOV R9D,dword ptr [R11 + R9*0x4]
JMP 0x001e4f19
LAB_001e4f12:
SHL R9D,0x8
OR R9,R10
LAB_001e4f19:
CMP RCX,R8
JA 0x001e4f4a
CMP R9D,0xffff
JA 0x001e4f4a
ROL R9W,0x8
MOV word ptr [RCX + -0x2],R9W
LEA R9,[RSI + 0x2]
CMP R9,RDX
JNC 0x001e4f4a
ADD RSI,0x4
ADD RCX,0x2
CMP RSI,RDX
MOV RSI,R9
JBE 0x001e4ef2
LAB_001e4f4a:
POP RBP
LAB_001e4f4b:
RET
|
void my_caseup_ucs2(long param_1,byte *param_2,long param_3,long param_4,long param_5)
{
long lVar1;
long lVar2;
ulong uVar3;
byte *pbVar4;
byte *pbVar5;
uint uVar6;
if (1 < param_3) {
lVar1 = *(long *)(param_1 + 0x78);
uVar3 = param_4 + 2;
pbVar4 = param_2;
while( true ) {
lVar2 = *(long *)(*(long *)(lVar1 + 8) + (ulong)*pbVar4 * 8);
if (lVar2 == 0) {
uVar6 = (uint)CONCAT11(*pbVar4,pbVar4[1]);
}
else {
uVar6 = *(uint *)(lVar2 + (ulong)pbVar4[1] * 0xc);
}
if (((ulong)(param_5 + param_4) < uVar3) || (0xffff < uVar6)) break;
*(ushort *)(uVar3 - 2) = (ushort)uVar6 << 8 | (ushort)uVar6 >> 8;
if (param_2 + param_3 <= pbVar4 + 2) {
return;
}
pbVar5 = pbVar4 + 4;
uVar3 = uVar3 + 2;
pbVar4 = pbVar4 + 2;
if (param_2 + param_3 < pbVar5) {
return;
}
}
}
return;
}
|
|
11,344 |
ma_save_session_track_info
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
void ma_save_session_track_info(void *ptr, enum enum_mariadb_status_info type, ...)
{
MYSQL *mysql= (MYSQL *)ptr;
enum enum_session_state_type track_type;
va_list ap;
DBUG_ASSERT(mysql != NULL);
/* We only handle SESSION_TRACK_TYPE here */
if (type != SESSION_TRACK_TYPE)
return;
va_start(ap, type);
track_type= va_arg(ap, enum enum_session_state_type);
switch (track_type) {
case SESSION_TRACK_SCHEMA:
case SESSION_TRACK_STATE_CHANGE:
case SESSION_TRACK_TRANSACTION_CHARACTERISTICS:
case SESSION_TRACK_TRANSACTION_STATE:
case SESSION_TRACK_GTIDS:
case SESSION_TRACK_SYSTEM_VARIABLES:
{
LIST *session_item;
MYSQL_LEX_STRING *str;
char *tmp;
MARIADB_CONST_STRING *data1= va_arg(ap, MARIADB_CONST_STRING *);
if (!(session_item= ma_multi_malloc(0,
&session_item, sizeof(LIST),
&str, sizeof(MYSQL_LEX_STRING),
&tmp, data1->length,
NULL)))
goto mem_error;
str->str= tmp;
memcpy(str->str, data1->str, data1->length);
str->length= data1->length;
session_item->data= str;
mysql->extension->session_state[track_type].list= list_add(mysql->extension->session_state[track_type].list,
session_item);
if (track_type == SESSION_TRACK_SYSTEM_VARIABLES)
{
MARIADB_CONST_STRING *data2= va_arg(ap, MARIADB_CONST_STRING *);
if (!(session_item= ma_multi_malloc(0,
&session_item, sizeof(LIST),
&str, sizeof(MYSQL_LEX_STRING),
&tmp, data2->length,
NULL)))
goto mem_error;
str->str= tmp;
memcpy(str->str, data2->str, data2->length);
str->length= data2->length;
session_item->data= str;
mysql->extension->session_state[track_type].list= list_add(mysql->extension->session_state[track_type].list,
session_item);
}
}
break;
}
return;
mem_error:
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return;
}
|
O0
|
c
|
ma_save_session_track_info:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
testb %al, %al
je 0x3e634
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %r9, -0xf8(%rbp)
movq %r8, -0x100(%rbp)
movq %rcx, -0x108(%rbp)
movq %rdx, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
je 0x3e66a
jmp 0x3e9db
leaq -0x40(%rbp), %rax
leaq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x130(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x124(%rbp)
cmpl $0x28, %eax
ja 0x3e6c9
movq -0x130(%rbp), %rcx
movl -0x124(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x138(%rbp)
jmp 0x3e6e6
movq -0x130(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x5, %eax
ja 0x3e972
jmp 0x3e700
leaq -0x40(%rbp), %rax
movq %rax, -0x148(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x13c(%rbp)
cmpl $0x28, %eax
ja 0x3e73b
movq -0x148(%rbp), %rcx
movl -0x13c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x150(%rbp)
jmp 0x3e758
movq -0x148(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x150(%rbp)
movq -0x150(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq -0x48(%rbp), %rsi
movl $0x18, %edx
leaq -0x50(%rbp), %rcx
movl $0x10, %r8d
leaq -0x58(%rbp), %r9
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, %al
callq 0x450e0
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x3e7ad
jmp 0x3e974
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x60(%rbp), %rax
movq (%rax), %rsi
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x35090
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x4f0(%rax), %rax
addq $0x8, %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x48(%rbp), %rsi
callq 0x43030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x4f0(%rax), %rax
addq $0x8, %rax
movl -0x1c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
cmpl $0x0, -0x1c(%rbp)
jne 0x3e970
leaq -0x40(%rbp), %rax
movq %rax, -0x160(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x154(%rbp)
cmpl $0x28, %eax
ja 0x3e878
movq -0x160(%rbp), %rcx
movl -0x154(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x168(%rbp)
jmp 0x3e895
movq -0x160(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x168(%rbp)
movq -0x168(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq -0x48(%rbp), %rsi
movl $0x18, %edx
leaq -0x50(%rbp), %rcx
movl $0x10, %r8d
leaq -0x58(%rbp), %r9
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, %al
callq 0x450e0
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x3e8ea
jmp 0x3e974
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x68(%rbp), %rax
movq (%rax), %rsi
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x35090
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x4f0(%rax), %rax
addq $0x8, %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x48(%rbp), %rsi
callq 0x43030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x4f0(%rax), %rax
addq $0x8, %rax
movl -0x1c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x3e972
jmp 0x3e9db
jmp 0x3e976
movq -0x18(%rbp), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x1e443a(%rip), %rax # 0x222dd0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x35120
movq -0x18(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rdi
addq $0x97, %rdi
leaq 0x1e4420(%rip), %rax # 0x222de0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x35120
movq -0x18(%rbp), %rax
movb $0x0, 0x296(%rax)
jmp 0x3e9db
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_save_session_track_info:
push rbp
mov rbp, rsp
sub rsp, 180h
test al, al
jz short loc_3E634
movaps [rbp+var_F0], xmm0
movaps [rbp+var_E0], xmm1
movaps [rbp+var_D0], xmm2
movaps [rbp+var_C0], xmm3
movaps [rbp+var_B0], xmm4
movaps [rbp+var_A0], xmm5
movaps [rbp+var_90], xmm6
movaps [rbp+var_80], xmm7
loc_3E634:
mov [rbp+var_F8], r9
mov [rbp+var_100], r8
mov [rbp+var_108], rcx
mov [rbp+var_110], rdx
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
cmp [rbp+var_C], 1
jz short loc_3E66A
jmp loc_3E9DB
loc_3E66A:
lea rax, [rbp+var_40]
lea rcx, [rbp+var_120]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
lea rax, [rbp+var_40]
mov [rbp+var_130], rax
mov eax, [rbp+var_40]
mov [rbp+var_124], eax
cmp eax, 28h ; '('
ja short loc_3E6C9
mov rcx, [rbp+var_130]
mov edx, [rbp+var_124]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_138], rax
jmp short loc_3E6E6
loc_3E6C9:
mov rcx, [rbp+var_130]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_138], rax
loc_3E6E6:
mov rax, [rbp+var_138]
mov eax, [rax]
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
sub eax, 5
ja loc_3E972
jmp short $+2
loc_3E700:
lea rax, [rbp+var_40]
mov [rbp+var_148], rax
mov eax, [rbp+var_40]
mov [rbp+var_13C], eax
cmp eax, 28h ; '('
ja short loc_3E73B
mov rcx, [rbp+var_148]
mov edx, [rbp+var_13C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_150], rax
jmp short loc_3E758
loc_3E73B:
mov rcx, [rbp+var_148]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_150], rax
loc_3E758:
mov rax, [rbp+var_150]
mov rax, [rax]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov rax, [rax+8]
xor edi, edi
lea rsi, [rbp+var_48]
mov edx, 18h
lea rcx, [rbp+var_50]
mov r8d, 10h
lea r9, [rbp+var_58]
xor r10d, r10d
mov [rsp+180h+var_180], rax
mov [rsp+180h+var_178], 0
mov al, 0
call ma_multi_malloc
mov [rbp+var_48], rax
cmp rax, 0
jnz short loc_3E7AD
jmp loc_3E974
loc_3E7AD:
mov rcx, [rbp+var_58]
mov rax, [rbp+var_50]
mov [rax], rcx
mov rax, [rbp+var_50]
mov rdi, [rax]
mov rax, [rbp+var_60]
mov rsi, [rax]
mov rax, [rbp+var_60]
mov rdx, [rax+8]
call _memcpy
mov rax, [rbp+var_60]
mov rcx, [rax+8]
mov rax, [rbp+var_50]
mov [rax+8], rcx
mov rcx, [rbp+var_50]
mov rax, [rbp+var_48]
mov [rax+10h], rcx
mov rax, [rbp+var_18]
mov rax, [rax+4F0h]
add rax, 8
mov ecx, [rbp+var_1C]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rsi, [rbp+var_48]
call list_add
mov rcx, rax
mov rax, [rbp+var_18]
mov rax, [rax+4F0h]
add rax, 8
mov edx, [rbp+var_1C]
shl rdx, 4
add rax, rdx
mov [rax], rcx
cmp [rbp+var_1C], 0
jnz loc_3E970
lea rax, [rbp+var_40]
mov [rbp+var_160], rax
mov eax, [rbp+var_40]
mov [rbp+var_154], eax
cmp eax, 28h ; '('
ja short loc_3E878
mov rcx, [rbp+var_160]
mov edx, [rbp+var_154]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_168], rax
jmp short loc_3E895
loc_3E878:
mov rcx, [rbp+var_160]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_168], rax
loc_3E895:
mov rax, [rbp+var_168]
mov rax, [rax]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
mov rax, [rax+8]
xor edi, edi
lea rsi, [rbp+var_48]
mov edx, 18h
lea rcx, [rbp+var_50]
mov r8d, 10h
lea r9, [rbp+var_58]
xor r10d, r10d
mov [rsp+180h+var_180], rax
mov [rsp+180h+var_178], 0
mov al, 0
call ma_multi_malloc
mov [rbp+var_48], rax
cmp rax, 0
jnz short loc_3E8EA
jmp loc_3E974
loc_3E8EA:
mov rcx, [rbp+var_58]
mov rax, [rbp+var_50]
mov [rax], rcx
mov rax, [rbp+var_50]
mov rdi, [rax]
mov rax, [rbp+var_68]
mov rsi, [rax]
mov rax, [rbp+var_68]
mov rdx, [rax+8]
call _memcpy
mov rax, [rbp+var_68]
mov rcx, [rax+8]
mov rax, [rbp+var_50]
mov [rax+8], rcx
mov rcx, [rbp+var_50]
mov rax, [rbp+var_48]
mov [rax+10h], rcx
mov rax, [rbp+var_18]
mov rax, [rax+4F0h]
add rax, 8
mov ecx, [rbp+var_1C]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rsi, [rbp+var_48]
call list_add
mov rcx, rax
mov rax, [rbp+var_18]
mov rax, [rax+4F0h]
add rax, 8
mov edx, [rbp+var_1C]
shl rdx, 4
add rax, rdx
mov [rax], rcx
loc_3E970:
jmp short $+2
loc_3E972:
jmp short loc_3E9DB
loc_3E974:
jmp short $+2
loc_3E976:
mov rax, [rbp+var_18]
mov dword ptr [rax+90h], 7D8h
mov rdi, [rbp+var_18]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_18]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+296h], 0
jmp short $+2
loc_3E9DB:
add rsp, 180h
pop rbp
retn
|
long long ma_save_session_track_info(long long a1, int a2, unsigned int a3, ...)
{
long long result; // rax
char *v4; // rax
long long v5; // rcx
char *overflow_arg_area; // rax
long long v7; // rcx
_QWORD *v8; // [rsp+118h] [rbp-68h]
_QWORD *v9; // [rsp+120h] [rbp-60h]
long long v10; // [rsp+128h] [rbp-58h] BYREF
_QWORD *v11; // [rsp+130h] [rbp-50h] BYREF
long long v12; // [rsp+138h] [rbp-48h] BYREF
va_list va; // [rsp+140h] [rbp-40h] BYREF
unsigned int v14; // [rsp+164h] [rbp-1Ch]
long long v15; // [rsp+168h] [rbp-18h]
int v16; // [rsp+174h] [rbp-Ch]
long long v17; // [rsp+178h] [rbp-8h]
v17 = a1;
v16 = a2;
result = a1;
v15 = a1;
if ( a2 == 1 )
{
va_start(va, a3);
v14 = a3;
result = a3 - 5;
if ( a3 <= 5 )
{
v4 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
v9 = *(_QWORD **)v4;
v12 = ma_multi_malloc(
0,
(unsigned int)&v12,
24,
(unsigned int)&v11,
16,
(unsigned int)&v10,
*(_QWORD *)(*(_QWORD *)v4 + 8LL),
0LL);
if ( !v12 )
goto LABEL_11;
*v11 = v10;
memcpy(*v11, *v9, v9[1]);
v11[1] = v9[1];
*(_QWORD *)(v12 + 16) = v11;
v5 = list_add(*(_QWORD *)(16LL * v14 + *(_QWORD *)(v15 + 1264) + 8LL), v12);
result = 16LL * v14 + *(_QWORD *)(v15 + 1264) + 8LL;
*(_QWORD *)result = v5;
if ( v14 )
return result;
if ( va[0].gp_offset > 0x28 )
{
overflow_arg_area = (char *)va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
overflow_arg_area = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
v8 = *(_QWORD **)overflow_arg_area;
v12 = ma_multi_malloc(
0,
(unsigned int)&v12,
24,
(unsigned int)&v11,
16,
(unsigned int)&v10,
*(_QWORD *)(*(_QWORD *)overflow_arg_area + 8LL),
0LL);
if ( !v12 )
{
LABEL_11:
*(_DWORD *)(v15 + 144) = 2008;
strncpy(v15 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v15 + 668) = 0;
strncpy(v15 + 151, client_errors[8], 511LL);
result = v15;
*(_BYTE *)(v15 + 662) = 0;
return result;
}
*v11 = v10;
memcpy(*v11, *v8, v8[1]);
v11[1] = v8[1];
*(_QWORD *)(v12 + 16) = v11;
v7 = list_add(*(_QWORD *)(16LL * v14 + *(_QWORD *)(v15 + 1264) + 8LL), v12);
result = 16LL * v14 + *(_QWORD *)(v15 + 1264) + 8LL;
*(_QWORD *)result = v7;
}
}
return result;
}
|
ma_save_session_track_info:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x180
TEST AL,AL
JZ 0x0013e634
MOVAPS xmmword ptr [RBP + -0xf0],XMM0
MOVAPS xmmword ptr [RBP + -0xe0],XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM2
MOVAPS xmmword ptr [RBP + -0xc0],XMM3
MOVAPS xmmword ptr [RBP + -0xb0],XMM4
MOVAPS xmmword ptr [RBP + -0xa0],XMM5
MOVAPS xmmword ptr [RBP + -0x90],XMM6
MOVAPS xmmword ptr [RBP + -0x80],XMM7
LAB_0013e634:
MOV qword ptr [RBP + -0xf8],R9
MOV qword ptr [RBP + -0x100],R8
MOV qword ptr [RBP + -0x108],RCX
MOV qword ptr [RBP + -0x110],RDX
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP dword ptr [RBP + -0xc],0x1
JZ 0x0013e66a
JMP 0x0013e9db
LAB_0013e66a:
LEA RAX,[RBP + -0x40]
LEA RCX,[RBP + -0x120]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x130],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x124],EAX
CMP EAX,0x28
JA 0x0013e6c9
MOV RCX,qword ptr [RBP + -0x130]
MOV EDX,dword ptr [RBP + -0x124]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x138],RAX
JMP 0x0013e6e6
LAB_0013e6c9:
MOV RCX,qword ptr [RBP + -0x130]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x138],RAX
LAB_0013e6e6:
MOV RAX,qword ptr [RBP + -0x138]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x5
JA 0x0013e972
JMP 0x0013e700
LAB_0013e700:
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x148],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x13c],EAX
CMP EAX,0x28
JA 0x0013e73b
MOV RCX,qword ptr [RBP + -0x148]
MOV EDX,dword ptr [RBP + -0x13c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x150],RAX
JMP 0x0013e758
LAB_0013e73b:
MOV RCX,qword ptr [RBP + -0x148]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x150],RAX
LAB_0013e758:
MOV RAX,qword ptr [RBP + -0x150]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x8]
XOR EDI,EDI
LEA RSI,[RBP + -0x48]
MOV EDX,0x18
LEA RCX,[RBP + -0x50]
MOV R8D,0x10
LEA R9,[RBP + -0x58]
XOR R10D,R10D
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
MOV AL,0x0
CALL 0x001450e0
MOV qword ptr [RBP + -0x48],RAX
CMP RAX,0x0
JNZ 0x0013e7ad
JMP 0x0013e974
LAB_0013e7ad:
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00135090
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x4f0]
ADD RAX,0x8
MOV ECX,dword ptr [RBP + -0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00143030
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x4f0]
ADD RAX,0x8
MOV EDX,dword ptr [RBP + -0x1c]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x0013e970
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x160],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x154],EAX
CMP EAX,0x28
JA 0x0013e878
MOV RCX,qword ptr [RBP + -0x160]
MOV EDX,dword ptr [RBP + -0x154]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x168],RAX
JMP 0x0013e895
LAB_0013e878:
MOV RCX,qword ptr [RBP + -0x160]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x168],RAX
LAB_0013e895:
MOV RAX,qword ptr [RBP + -0x168]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x8]
XOR EDI,EDI
LEA RSI,[RBP + -0x48]
MOV EDX,0x18
LEA RCX,[RBP + -0x50]
MOV R8D,0x10
LEA R9,[RBP + -0x58]
XOR R10D,R10D
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
MOV AL,0x0
CALL 0x001450e0
MOV qword ptr [RBP + -0x48],RAX
CMP RAX,0x0
JNZ 0x0013e8ea
JMP 0x0013e974
LAB_0013e8ea:
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00135090
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x4f0]
ADD RAX,0x8
MOV ECX,dword ptr [RBP + -0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00143030
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x4f0]
ADD RAX,0x8
MOV EDX,dword ptr [RBP + -0x1c]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
LAB_0013e970:
JMP 0x0013e972
LAB_0013e972:
JMP 0x0013e9db
LAB_0013e974:
JMP 0x0013e976
LAB_0013e976:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x297
LEA RAX,[0x322dd0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00135120
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x97
LEA RAX,[0x322de0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00135120
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x296],0x0
JMP 0x0013e9db
LAB_0013e9db:
ADD RSP,0x180
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x0013e6c9) */
/* WARNING: Removing unreachable block (ram,0x0013e73b) */
/* WARNING: Heritage AFTER dead removal. Example location: s0xfffffffffffffee8 : 0x0013e6ed */
/* WARNING: Restarted to delay deadcode elimination for space: stack */
void ma_save_session_track_info
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long param_9,int param_10,int8 param_11,int8 param_12,int8 param_13
,int8 param_14)
{
int8 *puVar1;
char in_AL;
int8 uVar2;
long *local_170;
int1 local_128 [16];
int8 local_118;
int8 *local_110;
int8 local_108;
int8 local_100;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 *local_70;
int8 *local_68;
int8 local_60;
int8 *local_58;
long local_50;
uint local_48;
int4 local_44;
long *local_40;
int1 *local_38;
uint local_24;
long local_20;
int local_14;
long local_10;
if (in_AL != '\0') {
local_f8 = param_1;
local_e8 = param_2;
local_d8 = param_3;
local_c8 = param_4;
local_b8 = param_5;
local_a8 = param_6;
local_98 = param_7;
local_88 = param_8;
}
if (param_10 == 1) {
local_38 = local_128;
local_40 = (long *)&stack0x00000008;
local_44 = 0x30;
local_24 = (uint)local_118;
if ((uint)local_118 < 6) {
local_48 = 0x20;
local_68 = local_110;
puVar1 = local_110 + 1;
local_118 = param_11;
local_110 = (int8 *)param_12;
local_108 = param_13;
local_100 = param_14;
local_20 = param_9;
local_14 = param_10;
local_10 = param_9;
local_50 = ma_multi_malloc(0,&local_50,0x18,&local_58,0x10,&local_60,*puVar1,0);
if (local_50 != 0) {
*local_58 = local_60;
memcpy((void *)*local_58,(void *)*local_68,local_68[1]);
local_58[1] = local_68[1];
*(int8 **)(local_50 + 0x10) = local_58;
uVar2 = list_add(*(int8 *)(*(long *)(local_20 + 0x4f0) + 8 + (ulong)local_24 * 0x10),
local_50);
*(int8 *)(*(long *)(local_20 + 0x4f0) + 8 + (ulong)local_24 * 0x10) = uVar2;
if (local_24 != 0) {
return;
}
if (local_48 < 0x29) {
local_170 = (long *)(local_38 + (int)local_48);
local_48 = local_48 + 8;
}
else {
local_170 = local_40;
local_40 = local_40 + 1;
}
local_70 = (int8 *)*local_170;
local_50 = ma_multi_malloc(0,&local_50,0x18,&local_58,0x10,&local_60,local_70[1],0);
if (local_50 != 0) {
*local_58 = local_60;
memcpy((void *)*local_58,(void *)*local_70,local_70[1]);
local_58[1] = local_70[1];
*(int8 **)(local_50 + 0x10) = local_58;
uVar2 = list_add(*(int8 *)(*(long *)(local_20 + 0x4f0) + 8 + (ulong)local_24 * 0x10)
,local_50);
*(int8 *)(*(long *)(local_20 + 0x4f0) + 8 + (ulong)local_24 * 0x10) = uVar2;
return;
}
}
local_50 = 0;
*(int4 *)(local_20 + 0x90) = 0x7d8;
strncpy((char *)(local_20 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_20 + 0x29c) = 0;
strncpy((char *)(local_20 + 0x97),PTR_s_Client_run_out_of_memory_00322e20,0x1ff);
*(int1 *)(local_20 + 0x296) = 0;
}
}
return;
}
|
|
11,345 |
build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&, common_grammar_options const&)
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
std::string build_grammar(const std::function<void(const common_grammar_builder &)> & cb, const common_grammar_options & options) {
SchemaConverter converter([&](const std::string &) { return json(); }, options.dotall, options.compact_spaces);
common_grammar_builder builder {
/* .add_rule = */ [&](const std::string & name, const std::string & rule) {
return converter._add_rule(name, rule);
},
/* .add_schema = */ [&](const std::string & name, const nlohmann::ordered_json & schema) {
return converter.visit(schema, name == "root" ? "" : name);
},
/* .resolve_refs = */ [&](nlohmann::ordered_json & schema) {
converter.resolve_refs(schema, "");
}
};
cb(builder);
converter.check_errors();
return converter.format_grammar();
}
|
O3
|
cpp
|
build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&, common_grammar_options const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x2f4(%rip), %rax # 0xc909a
movq %rax, 0x18(%rsi)
leaq 0x315(%rip), %rax # 0xc90c6
movq %rax, 0x10(%rsi)
movzbl (%rdx), %eax
movzbl 0x1(%rdx), %ecx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movl %eax, %edx
callq 0xcc368
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xc8de2
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %r15, (%rsp)
leaq 0x2ea(%rip), %rcx # 0xc90de
movq %rcx, 0x18(%rsp)
leaq 0x2f0(%rip), %rcx # 0xc90f0
movq %rcx, 0x10(%rsp)
movq %rax, 0x28(%rsp)
movq %r15, 0x20(%rsp)
leaq 0x300(%rip), %rcx # 0xc9116
movq %rcx, 0x38(%rsp)
leaq 0x3a6(%rip), %rcx # 0xc91c8
movq %rcx, 0x30(%rsp)
movq %rax, 0x48(%rsp)
movq %r15, 0x40(%rsp)
leaq 0x2e86(%rip), %rcx # 0xcbcbe
movq %rcx, 0x58(%rsp)
leaq 0x2ee4(%rip), %rcx # 0xcbd28
movq %rcx, 0x50(%rsp)
cmpq %rax, 0x10(%r14)
je 0xc8f29
movq %rsp, %rsi
movq %r14, %rdi
callq *0x18(%r14)
leaq 0x68(%rsp), %rdi
callq 0xcc56a
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0xcc732
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0xc8e8d
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xc8ea6
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xc8ebd
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x148(%rsp), %rdi
callq 0x2d06a
leaq 0x130(%rsp), %rdi
callq 0x2d06a
leaq 0xf8(%rsp), %rdi
callq 0x8c7f8
leaq 0xc0(%rsp), %rdi
callq 0xccf46
leaq 0x90(%rsp), %r14
movq %r14, %rdi
callq 0xcd028
movq -0x18(%r14), %rax
testq %rax, %rax
je 0xc8f19
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x160, %rsp # imm = 0x160
popq %rbx
popq %r14
popq %r15
retq
callq 0x1b320
jmp 0xc8f54
jmp 0xc8f54
jmp 0xc8f54
jmp 0xc8f54
jmp 0xc8f54
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xc8f71
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xc8f71
movq %rax, %rdi
callq 0x2d431
movq %rax, %rbx
movq %rsp, %rdi
callq 0xcc83e
leaq 0x68(%rsp), %rdi
callq 0xcc894
movq %rbx, %rdi
callq 0x1c020
nop
|
_Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options:
push r15
push r14
push rbx
sub rsp, 160h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
mov rsi, rsp; int
movaps xmmword ptr [rsi], xmm0
lea rax, _ZNSt17_Function_handlerIFN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_0E9_M_invokeERKSt9_Any_dataSG_; std::_Function_handler<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::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_invoke(std::_Any_data const&,std::string const&)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_0E10_M_managerERSt9_Any_dataRKSV_St18_Manager_operation; std::_Function_handler<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::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
movzx eax, byte ptr [rdx]
movzx ecx, byte ptr [rdx+1]; int
lea r15, [rsp+178h+var_110]
mov rdi, r15; int
mov edx, eax; int
call _ZN15SchemaConverterC2ERKSt8functionIFN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERKSB_EEbb; SchemaConverter::SchemaConverter(std::function<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::string const&)> const&,bool,bool)
mov rax, [rsp+178h+var_168]
test rax, rax
jz short loc_C8DE2
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_C8DE2:
xor eax, eax
mov [rsp+178h+var_170], rax
mov [rsp+178h+var_178], r15
lea rcx, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_S7_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_1E9_M_invokeERKSt9_Any_dataS7_S7_; std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_invoke(std::_Any_data const&,std::string const&,std::string const&)
mov [rsp+178h+var_160], rcx
lea rcx, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_S7_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_1E10_M_managerERSt9_Any_dataRKSM_St18_Manager_operation; std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+178h+var_168], rcx
mov [rsp+178h+var_150], rax
mov [rsp+178h+var_158], r15
lea rcx, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_RKN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapESt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_2E9_M_invokeERKSt9_Any_dataS7_SI_; std::_Function_handler<std::string ()(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_invoke(std::_Any_data const&,std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov [rsp+178h+var_140], rcx
lea rcx, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_RKN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapESt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_2E10_M_managerERSt9_Any_dataRKSX_St18_Manager_operation; std::_Function_handler<std::string ()(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+178h+var_148], rcx
mov [rsp+178h+var_130], rax
mov [rsp+178h+var_138], r15
lea rcx, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_3E9_M_invokeERKSt9_Any_dataSF_; std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_invoke(std::_Any_data const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov [rsp+178h+var_120], rcx
lea rcx, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_3E10_M_managerERSt9_Any_dataRKSU_St18_Manager_operation; std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+178h+var_128], rcx
cmp [r14+10h], rax
jz loc_C8F29
mov rsi, rsp
mov rdi, r14
call qword ptr [r14+18h]
lea rdi, [rsp+178h+var_110]; this
call _ZN15SchemaConverter12check_errorsEv; SchemaConverter::check_errors(void)
lea rsi, [rsp+178h+var_110]
mov rdi, rbx
call _ZN15SchemaConverter14format_grammarB5cxx11Ev; SchemaConverter::format_grammar(void)
mov rax, [rsp+178h+var_128]
test rax, rax
jz short loc_C8E8D
lea rdi, [rsp+178h+var_138]
mov rsi, rdi
mov edx, 3
call rax
loc_C8E8D:
mov rax, [rsp+178h+var_148]
test rax, rax
jz short loc_C8EA6
lea rdi, [rsp+178h+var_158]
mov rsi, rdi
mov edx, 3
call rax
loc_C8EA6:
mov rax, [rsp+178h+var_168]
test rax, rax
jz short loc_C8EBD
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_C8EBD:
lea rdi, [rsp+178h+var_30]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+178h+var_48]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+178h+var_80]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
lea rdi, [rsp+178h+var_B8]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapESt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESaISH_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSJ_18_Mod_range_hashingENSJ_20_Default_ranged_hashENSJ_20_Prime_rehash_policyENSJ_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
lea r14, [rsp+178h+var_E8]
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::~_Rb_tree()
mov rax, [r14-18h]
test rax, rax
jz short loc_C8F19
lea rdi, [rsp+178h+var_110]
mov rsi, rdi
mov edx, 3
call rax
loc_C8F19:
mov rax, rbx
add rsp, 160h
pop rbx
pop r14
pop r15
retn
loc_C8F29:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
jmp short loc_C8F54
jmp short loc_C8F54
jmp short loc_C8F54
jmp short loc_C8F54
jmp short loc_C8F54
mov rbx, rax
mov rax, [rsp+178h+var_168]
test rax, rax
jz short loc_C8F71
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_C8F71
loc_C8F54:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
mov rdi, rsp; this
call _ZN22common_grammar_builderD2Ev; common_grammar_builder::~common_grammar_builder()
lea rdi, [rsp+178h+var_110]; this
call _ZN15SchemaConverterD2Ev; SchemaConverter::~SchemaConverter()
loc_C8F71:
mov rdi, rbx
call __Unwind_Resume
|
long long build_grammar[abi:cxx11](long long a1, long long a2, unsigned __int8 *a3, long long a4, int a5, int a6)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
int *v11; // [rsp+0h] [rbp-178h] BYREF
long long v12; // [rsp+8h] [rbp-170h]
long long ( *v13)(); // [rsp+10h] [rbp-168h]
void *v14; // [rsp+18h] [rbp-160h]
int *v15; // [rsp+20h] [rbp-158h] BYREF
long long v16; // [rsp+28h] [rbp-150h]
long long ( *v17)(); // [rsp+30h] [rbp-148h]
long long ( *v18)(int, int, int, int, int, int, int, long long); // [rsp+38h] [rbp-140h]
int *v19; // [rsp+40h] [rbp-138h] BYREF
long long v20; // [rsp+48h] [rbp-130h]
long long ( *v21)(); // [rsp+50h] [rbp-128h]
long long ( *v22)(int, int, int, int, int, int, void *, int, long long); // [rsp+58h] [rbp-120h]
int v23; // [rsp+60h] [rbp-118h]
int v24[4]; // [rsp+68h] [rbp-110h] BYREF
void ( *v25)(int *, int *, long long); // [rsp+78h] [rbp-100h]
_BYTE v26[48]; // [rsp+90h] [rbp-E8h] BYREF
_BYTE v27[56]; // [rsp+C0h] [rbp-B8h] BYREF
_BYTE v28[56]; // [rsp+F8h] [rbp-80h] BYREF
_BYTE v29[24]; // [rsp+130h] [rbp-48h] BYREF
_BYTE v30[48]; // [rsp+148h] [rbp-30h] BYREF
SchemaConverter::SchemaConverter(
(int)v24,
(int)&v11,
*a3,
a3[1],
a5,
a6,
0LL,
0,
(long long)std::_Function_handler<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::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_manager,
(int)std::_Function_handler<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::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_invoke,
v15,
v16,
(long long)v17);
if ( v13 )
((void ( *)(int **, int **, long long))v13)(&v11, &v11, 3LL);
v12 = 0LL;
v11 = v24;
v14 = &std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_invoke;
v13 = std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_manager;
v16 = 0LL;
v15 = v24;
v18 = std::_Function_handler<std::string ()(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_invoke;
v17 = std::_Function_handler<std::string ()(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_manager;
v20 = 0LL;
v19 = v24;
v22 = std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_invoke;
v21 = std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_manager;
if ( !*(_QWORD *)(a2 + 16) )
std::__throw_bad_function_call();
(*(void ( **)(long long, int **))(a2 + 24))(a2, &v11);
SchemaConverter::check_errors((SchemaConverter *)v24);
SchemaConverter::format_grammar[abi:cxx11](
a1,
(unsigned int)v24,
v6,
v7,
v8,
v9,
(_DWORD)v11,
v12,
(_DWORD)v13,
(_DWORD)v14,
(_DWORD)v15,
v16,
(_DWORD)v17,
(_DWORD)v18,
(_DWORD)v19,
v20,
(_DWORD)v21,
(_DWORD)v22,
v23,
v24[0],
v24[2],
(char)v25);
if ( v21 )
((void ( *)(int **, int **, long long))v21)(&v19, &v19, 3LL);
if ( v17 )
((void ( *)(int **, int **, long long))v17)(&v15, &v15, 3LL);
if ( v13 )
((void ( *)(int **, int **, long long))v13)(&v11, &v11, 3LL);
std::vector<std::string>::~vector((long long)v30);
std::vector<std::string>::~vector((long long)v29);
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable((long long)v28);
std::_Hashtable<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable(v27);
std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::~_Rb_tree(v26);
if ( v25 )
v25(v24, v24, 3LL);
return a1;
}
|
build_grammar[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x160
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
LEA RAX,[0x1c909a]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x1c90c6]
MOV qword ptr [RSI + 0x10],RAX
MOVZX EAX,byte ptr [RDX]
MOVZX ECX,byte ptr [RDX + 0x1]
LAB_001c8dbc:
LEA R15,[RSP + 0x68]
MOV RDI,R15
MOV EDX,EAX
CALL 0x001cc368
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x001c8de2
LAB_001c8dd5:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c8de2:
XOR EAX,EAX
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP],R15
LEA RCX,[0x1c90de]
MOV qword ptr [RSP + 0x18],RCX
LEA RCX,[0x1c90f0]
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x20],R15
LEA RCX,[0x1c9116]
MOV qword ptr [RSP + 0x38],RCX
LEA RCX,[0x1c91c8]
MOV qword ptr [RSP + 0x30],RCX
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x40],R15
LEA RCX,[0x1cbcbe]
MOV qword ptr [RSP + 0x58],RCX
LEA RCX,[0x1cbd28]
MOV qword ptr [RSP + 0x50],RCX
CMP qword ptr [R14 + 0x10],RAX
JZ 0x001c8f29
LAB_001c8e53:
MOV RSI,RSP
MOV RDI,R14
CALL qword ptr [R14 + 0x18]
LEA RDI,[RSP + 0x68]
CALL 0x001cc56a
LEA RSI,[RSP + 0x68]
MOV RDI,RBX
CALL 0x001cc732
MOV RAX,qword ptr [RSP + 0x50]
TEST RAX,RAX
JZ 0x001c8e8d
LEA RDI,[RSP + 0x40]
LAB_001c8e83:
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c8e8d:
MOV RAX,qword ptr [RSP + 0x30]
TEST RAX,RAX
JZ 0x001c8ea6
LEA RDI,[RSP + 0x20]
LAB_001c8e9c:
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c8ea6:
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x001c8ebd
LAB_001c8eb0:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c8ebd:
LEA RDI,[RSP + 0x148]
CALL 0x0012d06a
LEA RDI,[RSP + 0x130]
CALL 0x0012d06a
LEA RDI,[RSP + 0xf8]
CALL 0x0018c7f8
LEA RDI,[RSP + 0xc0]
CALL 0x001ccf46
LEA R14,[RSP + 0x90]
MOV RDI,R14
CALL 0x001cd028
MOV RAX,qword ptr [R14 + -0x18]
TEST RAX,RAX
JZ 0x001c8f19
LAB_001c8f0a:
LEA RDI,[RSP + 0x68]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c8f19:
MOV RAX,RBX
ADD RSP,0x160
POP RBX
POP R14
POP R15
RET
LAB_001c8f29:
CALL 0x0011b320
|
/* build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&,
common_grammar_options const&) */
function * build_grammar_abi_cxx11_(function *param_1,common_grammar_options *param_2)
{
long in_RDX;
SchemaConverter *local_178;
int8 uStack_170;
code *local_168;
code *local_160;
SchemaConverter *local_158;
int8 local_150;
code *local_148;
code *local_140;
SchemaConverter *local_138;
int8 local_130;
code *local_128;
code *local_120;
SchemaConverter local_110 [16];
code *local_100;
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
local_e8 [48];
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
local_b8 [56];
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
local_80 [56];
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_48 [24];
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_30 [24];
local_178 = (SchemaConverter *)0x0;
uStack_170 = 0;
local_160 = std::
_Function_handler<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::__cxx11::string_const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_0>
::_M_invoke;
local_168 = std::
_Function_handler<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::__cxx11::string_const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_0>
::_M_manager;
/* try { // try from 001c8dbc to 001c8dca has its CatchHandler @ 001c8f38 */
SchemaConverter::SchemaConverter
(local_110,(function *)&local_178,*(bool *)in_RDX,*(bool *)(in_RDX + 1));
if (local_168 != (code *)0x0) {
/* try { // try from 001c8dd5 to 001c8de1 has its CatchHandler @ 001c8f36 */
(*local_168)(&local_178,&local_178,3);
}
uStack_170 = 0;
local_160 = std::
_Function_handler<std::__cxx11::string(std::__cxx11::string_const&,std::__cxx11::string_const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_1>
::_M_invoke;
local_168 = std::
_Function_handler<std::__cxx11::string(std::__cxx11::string_const&,std::__cxx11::string_const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_1>
::_M_manager;
local_150 = 0;
local_140 = std::
_Function_handler<std::__cxx11::string(std::__cxx11::string_const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_2>
::_M_invoke;
local_148 = std::
_Function_handler<std::__cxx11::string(std::__cxx11::string_const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_2>
::_M_manager;
local_130 = 0;
local_120 = std::
_Function_handler<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>&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_3>
::_M_invoke;
local_128 = std::
_Function_handler<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>&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_3>
::_M_manager;
local_178 = local_110;
local_158 = local_110;
local_138 = local_110;
if (*(long *)(param_2 + 0x10) != 0) {
/* try { // try from 001c8e53 to 001c8e73 has its CatchHandler @ 001c8f5c */
(**(code **)(param_2 + 0x18))(param_2,&local_178);
SchemaConverter::check_errors(local_110);
SchemaConverter::format_grammar_abi_cxx11_();
if (local_128 != (code *)0x0) {
/* try { // try from 001c8e83 to 001c8e8c has its CatchHandler @ 001c8f34 */
(*local_128)(&local_138,&local_138,3);
}
if (local_148 != (code *)0x0) {
/* try { // try from 001c8e9c to 001c8ea5 has its CatchHandler @ 001c8f32 */
(*local_148)(&local_158,&local_158,3);
}
if (local_168 != (code *)0x0) {
/* try { // try from 001c8eb0 to 001c8ebc has its CatchHandler @ 001c8f30 */
(*local_168)(&local_178,&local_178,3);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_30);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_48);
std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::~_Hashtable(local_80);
std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::~_Hashtable(local_b8);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::~_Rb_tree(local_e8);
if (local_100 != (code *)0x0) {
/* try { // try from 001c8f0a to 001c8f18 has its CatchHandler @ 001c8f2e */
(*local_100)(local_110,local_110,3);
}
return param_1;
}
/* WARNING: Subroutine does not return */
/* try { // try from 001c8f29 to 001c8f2d has its CatchHandler @ 001c8f5c */
std::__throw_bad_function_call();
}
|
|
11,346 |
MNN::CreateRandomUniform(flatbuffers::FlatBufferBuilder&, int, int, MNN::DataType, float, float)
|
mnn-tts/MNN/schema/current/TensorflowOp_generated.h
|
inline flatbuffers::Offset<RandomUniform> CreateRandomUniform(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t seed = 0,
int32_t seed2 = 0,
DataType type = DataType_DT_FLOAT,
float low = 0.0f,
float high = 1.0f) {
RandomUniformBuilder builder_(_fbb);
builder_.add_high(high);
builder_.add_low(low);
builder_.add_type(type);
builder_.add_seed2(seed2);
builder_.add_seed(seed);
return builder_.Finish();
}
|
O0
|
c
|
MNN::CreateRandomUniform(flatbuffers::FlatBufferBuilder&, int, int, MNN::DataType, float, float):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movss %xmm0, 0x18(%rsp)
movss %xmm1, 0x14(%rsp)
movq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x248f0
movss 0x14(%rsp), %xmm0
movq %rsp, %rdi
callq 0x24930
movss 0x18(%rsp), %xmm0
movq %rsp, %rdi
callq 0x24970
movl 0x1c(%rsp), %esi
movq %rsp, %rdi
callq 0x249a0
movl 0x20(%rsp), %esi
movq %rsp, %rdi
callq 0x249d0
movl 0x24(%rsp), %esi
movq %rsp, %rdi
callq 0x24a00
movq %rsp, %rdi
callq 0x24a30
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN3MNN19CreateRandomUniformERN11flatbuffers17FlatBufferBuilderEiiNS_8DataTypeEff:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_14], esi
mov [rsp+38h+var_18], edx
mov [rsp+38h+var_1C], ecx
movss [rsp+38h+var_20], xmm0
movss [rsp+38h+var_24], xmm1
mov rsi, [rsp+38h+var_10]; flatbuffers::FlatBufferBuilder *
mov rdi, rsp; this
call _ZN3MNN20RandomUniformBuilderC2ERN11flatbuffers17FlatBufferBuilderE; MNN::RandomUniformBuilder::RandomUniformBuilder(flatbuffers::FlatBufferBuilder &)
movss xmm0, [rsp+38h+var_24]; float
mov rdi, rsp; this
call _ZN3MNN20RandomUniformBuilder8add_highEf; MNN::RandomUniformBuilder::add_high(float)
movss xmm0, [rsp+38h+var_20]; float
mov rdi, rsp; this
call _ZN3MNN20RandomUniformBuilder7add_lowEf; MNN::RandomUniformBuilder::add_low(float)
mov esi, [rsp+38h+var_1C]
mov rdi, rsp
call _ZN3MNN20RandomUniformBuilder8add_typeENS_8DataTypeE; MNN::RandomUniformBuilder::add_type(MNN::DataType)
mov esi, [rsp+38h+var_18]; int
mov rdi, rsp; this
call _ZN3MNN20RandomUniformBuilder9add_seed2Ei; MNN::RandomUniformBuilder::add_seed2(int)
mov esi, [rsp+38h+var_14]; int
mov rdi, rsp; this
call _ZN3MNN20RandomUniformBuilder8add_seedEi; MNN::RandomUniformBuilder::add_seed(int)
mov rdi, rsp; this
call _ZN3MNN20RandomUniformBuilder6FinishEv; MNN::RandomUniformBuilder::Finish(void)
mov [rsp+38h+var_4], eax
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
|
long long MNN::CreateRandomUniform(
flatbuffers::FlatBufferBuilder *a1,
int a2,
int a3,
unsigned int a4,
float a5,
float a6)
{
_BYTE v7[20]; // [rsp+0h] [rbp-38h] BYREF
float v8; // [rsp+14h] [rbp-24h]
float v9; // [rsp+18h] [rbp-20h]
unsigned int v10; // [rsp+1Ch] [rbp-1Ch]
int v11; // [rsp+20h] [rbp-18h]
int v12; // [rsp+24h] [rbp-14h]
flatbuffers::FlatBufferBuilder *v13; // [rsp+28h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
v8 = a6;
MNN::RandomUniformBuilder::RandomUniformBuilder((MNN::RandomUniformBuilder *)v7, a1);
MNN::RandomUniformBuilder::add_high((MNN::RandomUniformBuilder *)v7, v8);
MNN::RandomUniformBuilder::add_low((MNN::RandomUniformBuilder *)v7, v9);
MNN::RandomUniformBuilder::add_type(v7, v10);
MNN::RandomUniformBuilder::add_seed2((MNN::RandomUniformBuilder *)v7, v11);
MNN::RandomUniformBuilder::add_seed((MNN::RandomUniformBuilder *)v7, v12);
return (unsigned int)MNN::RandomUniformBuilder::Finish((MNN::RandomUniformBuilder *)v7);
}
|
CreateRandomUniform:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x24],ESI
MOV dword ptr [RSP + 0x20],EDX
MOV dword ptr [RSP + 0x1c],ECX
MOVSS dword ptr [RSP + 0x18],XMM0
MOVSS dword ptr [RSP + 0x14],XMM1
MOV RSI,qword ptr [RSP + 0x28]
MOV RDI,RSP
CALL 0x001248f0
MOVSS XMM0,dword ptr [RSP + 0x14]
MOV RDI,RSP
CALL 0x00124930
MOVSS XMM0,dword ptr [RSP + 0x18]
MOV RDI,RSP
CALL 0x00124970
MOV ESI,dword ptr [RSP + 0x1c]
MOV RDI,RSP
CALL 0x001249a0
MOV ESI,dword ptr [RSP + 0x20]
MOV RDI,RSP
CALL 0x001249d0
MOV ESI,dword ptr [RSP + 0x24]
MOV RDI,RSP
CALL 0x00124a00
MOV RDI,RSP
CALL 0x00124a30
MOV dword ptr [RSP + 0x34],EAX
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
/* MNN::CreateRandomUniform(flatbuffers::FlatBufferBuilder&, int, int, MNN::DataType, float, float)
*/
int4
MNN::CreateRandomUniform
(float param_1_00,float param_2_00,FlatBufferBuilder *param_1,int param_2,int param_3,
int4 param_6)
{
int4 uVar1;
RandomUniformBuilder aRStack_38 [20];
float local_24;
float local_20;
int4 local_1c;
int local_18;
int local_14;
FlatBufferBuilder *local_10;
local_24 = param_2_00;
local_20 = param_1_00;
local_1c = param_6;
local_18 = param_3;
local_14 = param_2;
local_10 = param_1;
RandomUniformBuilder::RandomUniformBuilder(aRStack_38,param_1);
RandomUniformBuilder::add_high(aRStack_38,local_24);
RandomUniformBuilder::add_low(aRStack_38,local_20);
RandomUniformBuilder::add_type(aRStack_38,local_1c);
RandomUniformBuilder::add_seed2(aRStack_38,local_18);
RandomUniformBuilder::add_seed(aRStack_38,local_14);
uVar1 = RandomUniformBuilder::Finish(aRStack_38);
return uVar1;
}
|
|
11,347 |
plutovg_canvas_font_metrics
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-canvas.c
|
void plutovg_canvas_font_metrics(const plutovg_canvas_t* canvas, float* ascent, float* descent, float* line_gap, plutovg_rect_t* extents)
{
plutovg_state_t* state = canvas->state;
if(state->font_face && state->font_size > 0.f) {
plutovg_font_face_get_metrics(state->font_face, state->font_size, ascent, descent, line_gap, extents);
return;
}
if(ascent) *ascent = 0.f;
if(descent) *descent = 0.f;
if(line_gap) *line_gap = 0.f;
if(extents) {
extents->x = 0.f;
extents->y = 0.f;
extents->w = 0.f;
extents->h = 0.f;
}
}
|
O1
|
c
|
plutovg_canvas_font_metrics:
movq 0x18(%rdi), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x44f5
movss 0x88(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
ja 0x5034
testq %rsi, %rsi
je 0x4500
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x450b
movl $0x0, (%rdx)
testq %rcx, %rcx
je 0x4516
movl $0x0, (%rcx)
testq %r8, %r8
je 0x4522
xorps %xmm0, %xmm0
movups %xmm0, (%r8)
retq
|
plutovg_canvas_font_metrics:
mov rax, [rdi+18h]
mov rdi, [rax+8]
test rdi, rdi
jz short loc_44F5
movss xmm0, dword ptr [rax+88h]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
ja plutovg_font_face_get_metrics
loc_44F5:
test rsi, rsi
jz short loc_4500
mov dword ptr [rsi], 0
loc_4500:
test rdx, rdx
jz short loc_450B
mov dword ptr [rdx], 0
loc_450B:
test rcx, rcx
jz short loc_4516
mov dword ptr [rcx], 0
loc_4516:
test r8, r8
jz short locret_4522
xorps xmm0, xmm0
movups xmmword ptr [r8], xmm0
locret_4522:
retn
|
long long plutovg_canvas_font_metrics(long long a1, _DWORD *a2, _DWORD *a3, _DWORD *a4, _OWORD *a5)
{
long long result; // rax
result = *(_QWORD *)(a1 + 24);
if ( *(_QWORD *)(result + 8) && *(float *)(result + 136) > 0.0 )
return plutovg_font_face_get_metrics();
if ( a2 )
*a2 = 0;
if ( a3 )
*a3 = 0;
if ( a4 )
*a4 = 0;
if ( a5 )
*a5 = 0LL;
return result;
}
|
plutovg_canvas_font_metrics:
MOV RAX,qword ptr [RDI + 0x18]
MOV RDI,qword ptr [RAX + 0x8]
TEST RDI,RDI
JZ 0x001044f5
MOVSS XMM0,dword ptr [RAX + 0x88]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JA 0x00105034
LAB_001044f5:
TEST RSI,RSI
JZ 0x00104500
MOV dword ptr [RSI],0x0
LAB_00104500:
TEST RDX,RDX
JZ 0x0010450b
MOV dword ptr [RDX],0x0
LAB_0010450b:
TEST RCX,RCX
JZ 0x00104516
MOV dword ptr [RCX],0x0
LAB_00104516:
TEST R8,R8
JZ 0x00104522
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R8],XMM0
LAB_00104522:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void plutovg_canvas_font_metrics
(long param_1,float *param_2,float *param_3,float *param_4,float *param_5)
{
ushort uVar1;
int iVar2;
int iVar3;
long lVar4;
float fVar5;
float fVar6;
lVar4 = *(long *)(*(long *)(param_1 + 0x18) + 8);
if ((lVar4 != 0) && (fVar5 = *(float *)(*(long *)(param_1 + 0x18) + 0x88), 0.0 < fVar5)) {
uVar1 = *(ushort *)(*(long *)(lVar4 + 0x28) + 0x12 + (long)*(int *)(lVar4 + 0x3c));
fVar5 = fVar5 / (float)(ushort)(uVar1 << 8 | uVar1 >> 8);
if (param_2 != (float *)0x0) {
*param_2 = (float)*(int *)(lVar4 + 4) * fVar5;
}
if (param_3 != (float *)0x0) {
*param_3 = (float)*(int *)(lVar4 + 8) * fVar5;
}
if (param_4 != (float *)0x0) {
*param_4 = (float)*(int *)(lVar4 + 0xc) * fVar5;
}
if (param_5 != (float *)0x0) {
iVar2 = *(int *)(lVar4 + 0x10);
*param_5 = (float)iVar2 * fVar5;
iVar3 = *(int *)(lVar4 + 0x1c);
fVar6 = (float)(_DAT_00123280 ^ (uint)fVar5);
param_5[1] = (float)iVar3 * fVar6;
param_5[2] = (float)(*(int *)(lVar4 + 0x18) - iVar2) * fVar5;
param_5[3] = (float)(*(int *)(lVar4 + 0x14) - iVar3) * fVar6;
}
return;
}
if (param_2 != (float *)0x0) {
*param_2 = 0.0;
}
if (param_3 != (float *)0x0) {
*param_3 = 0.0;
}
if (param_4 != (float *)0x0) {
*param_4 = 0.0;
}
if (param_5 != (float *)0x0) {
param_5[0] = 0.0;
param_5[1] = 0.0;
param_5[2] = 0.0;
param_5[3] = 0.0;
}
return;
}
|
|
11,348 |
set_closure_from_var
|
bluesky950520[P]quickjs/quickjs.c
|
static void set_closure_from_var(JSContext *ctx, JSClosureVar *cv,
JSVarDef *vd, int var_idx)
{
cv->is_local = TRUE;
cv->is_arg = FALSE;
cv->is_const = vd->is_const;
cv->is_lexical = vd->is_lexical;
cv->var_kind = vd->var_kind;
cv->var_idx = var_idx;
cv->var_name = JS_DupAtom(ctx, vd->var_name);
}
|
O0
|
c
|
set_closure_from_var:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x18(%rsp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movq 0x18(%rsp), %rax
movb (%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, (%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x1, %eax
movb %al, %dl
movq 0x18(%rsp), %rax
movb (%rax), %cl
andb $0x1, %dl
shlb $0x2, %dl
andb $-0x5, %cl
orb %dl, %cl
movb %cl, (%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
shrl %eax
andl $0x1, %eax
movb %al, %dl
movq 0x18(%rsp), %rax
movb (%rax), %cl
andb $0x1, %dl
shlb $0x3, %dl
andb $-0x9, %cl
orb %dl, %cl
movb %cl, (%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
movb %al, %dl
movq 0x18(%rsp), %rax
movb (%rax), %cl
andb $0xf, %dl
shlb $0x4, %dl
andb $0xf, %cl
orb %dl, %cl
movb %cl, (%rax)
movl 0xc(%rsp), %eax
movw %ax, %cx
movq 0x18(%rsp), %rax
movw %cx, 0x2(%rax)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
callq 0x27fa0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
|
set_closure_from_var:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_18], rdx
mov [rsp+28h+var_1C], ecx
mov rax, [rsp+28h+var_10]
mov cl, [rax]
and cl, 0FEh
or cl, 1
mov [rax], cl
mov rax, [rsp+28h+var_10]
mov cl, [rax]
and cl, 0FDh
or cl, 0
mov [rax], cl
mov rax, [rsp+28h+var_18]
mov eax, [rax+0Ch]
and eax, 1
mov dl, al
mov rax, [rsp+28h+var_10]
mov cl, [rax]
and dl, 1
shl dl, 2
and cl, 0FBh
or cl, dl
mov [rax], cl
mov rax, [rsp+28h+var_18]
mov eax, [rax+0Ch]
shr eax, 1
and eax, 1
mov dl, al
mov rax, [rsp+28h+var_10]
mov cl, [rax]
and dl, 1
shl dl, 3
and cl, 0F7h
or cl, dl
mov [rax], cl
mov rax, [rsp+28h+var_18]
mov eax, [rax+0Ch]
shr eax, 4
and eax, 0Fh
mov dl, al
mov rax, [rsp+28h+var_10]
mov cl, [rax]
and dl, 0Fh
shl dl, 4
and cl, 0Fh
or cl, dl
mov [rax], cl
mov eax, [rsp+28h+var_1C]
mov cx, ax
mov rax, [rsp+28h+var_10]
mov [rax+2], cx
mov rdi, [rsp+28h+var_8]
mov rax, [rsp+28h+var_18]
mov esi, [rax]
call JS_DupAtom
mov ecx, eax
mov rax, [rsp+28h+var_10]
mov [rax+4], ecx
add rsp, 28h
retn
|
long long set_closure_from_var(long long a1, long long a2, unsigned int *a3, __int16 a4)
{
int v4; // ecx
long long result; // rax
*(_BYTE *)a2 = *(_BYTE *)a2 & 0xFE | 1;
*(_BYTE *)a2 &= ~2u;
*(_BYTE *)a2 = (4 * (a3[3] & 1)) | *(_BYTE *)a2 & 0xFB;
*(_BYTE *)a2 = (8 * ((a3[3] & 2) != 0)) | *(_BYTE *)a2 & 0xF7;
*(_BYTE *)a2 = (16 * ((a3[3] >> 4) & 0xF)) | *(_BYTE *)a2 & 0xF;
*(_WORD *)(a2 + 2) = a4;
v4 = JS_DupAtom(a1, *a3);
result = a2;
*(_DWORD *)(a2 + 4) = v4;
return result;
}
|
set_closure_from_var:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV dword ptr [RSP + 0xc],ECX
MOV RAX,qword ptr [RSP + 0x18]
MOV CL,byte ptr [RAX]
AND CL,0xfe
OR CL,0x1
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + 0x18]
MOV CL,byte ptr [RAX]
AND CL,0xfd
OR CL,0x0
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x1
MOV DL,AL
MOV RAX,qword ptr [RSP + 0x18]
MOV CL,byte ptr [RAX]
AND DL,0x1
SHL DL,0x2
AND CL,0xfb
OR CL,DL
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX + 0xc]
SHR EAX,0x1
AND EAX,0x1
MOV DL,AL
MOV RAX,qword ptr [RSP + 0x18]
MOV CL,byte ptr [RAX]
AND DL,0x1
SHL DL,0x3
AND CL,0xf7
OR CL,DL
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX + 0xc]
SHR EAX,0x4
AND EAX,0xf
MOV DL,AL
MOV RAX,qword ptr [RSP + 0x18]
MOV CL,byte ptr [RAX]
AND DL,0xf
SHL DL,0x4
AND CL,0xf
OR CL,DL
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RSP + 0xc]
MOV CX,AX
MOV RAX,qword ptr [RSP + 0x18]
MOV word ptr [RAX + 0x2],CX
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RAX]
CALL 0x00127fa0
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX + 0x4],ECX
ADD RSP,0x28
RET
|
void set_closure_from_var(int8 param_1,byte *param_2,int4 *param_3,int2 param_4)
{
int4 uVar1;
*param_2 = *param_2 & 0xfe | 1;
*param_2 = *param_2 & 0xfd;
*param_2 = *param_2 & 0xfb | ((byte)param_3[3] & 1) << 2;
*param_2 = *param_2 & 0xf7 | ((byte)((uint)param_3[3] >> 1) & 1) << 3;
*param_2 = *param_2 & 0xf | (char)((uint)param_3[3] >> 4) << 4;
*(int2 *)(param_2 + 2) = param_4;
uVar1 = JS_DupAtom(param_1,*param_3);
*(int4 *)(param_2 + 4) = uVar1;
return;
}
|
|
11,349 |
set_closure_from_var
|
bluesky950520[P]quickjs/quickjs.c
|
static void set_closure_from_var(JSContext *ctx, JSClosureVar *cv,
JSVarDef *vd, int var_idx)
{
cv->is_local = TRUE;
cv->is_arg = FALSE;
cv->is_const = vd->is_const;
cv->is_lexical = vd->is_lexical;
cv->var_kind = vd->var_kind;
cv->var_idx = var_idx;
cv->var_name = JS_DupAtom(ctx, vd->var_name);
}
|
O1
|
c
|
set_closure_from_var:
movb (%rsi), %al
andb $-0x4, %al
incb %al
movb %al, (%rsi)
movb 0xc(%rdx), %r8b
shlb $0x2, %r8b
andb $0x4, %r8b
andb $-0x7, %al
orb %r8b, %al
movb %al, (%rsi)
movb 0xc(%rdx), %r8b
shlb $0x2, %r8b
andb $0x8, %r8b
andb $-0xb, %al
orb %r8b, %al
movb %al, (%rsi)
movb 0xc(%rdx), %r8b
andb $-0x10, %r8b
andb $0xd, %al
orb %r8b, %al
movb %al, (%rsi)
movw %cx, 0x2(%rsi)
movslq (%rdx), %rax
cmpq $0xe0, %rax
jl 0x5d195
movq 0x18(%rdi), %rcx
movq 0x68(%rcx), %rcx
movq (%rcx,%rax,8), %rcx
incl (%rcx)
movl %eax, 0x4(%rsi)
retq
|
set_closure_from_var:
mov al, [rsi]
and al, 0FCh
inc al
mov [rsi], al
mov r8b, [rdx+0Ch]
shl r8b, 2
and r8b, 4
and al, 0F9h
or al, r8b
mov [rsi], al
mov r8b, [rdx+0Ch]
shl r8b, 2
and r8b, 8
and al, 0F5h
or al, r8b
mov [rsi], al
mov r8b, [rdx+0Ch]
and r8b, 0F0h
and al, 0Dh
or al, r8b
mov [rsi], al
mov [rsi+2], cx
movsxd rax, dword ptr [rdx]
cmp rax, 0E0h
jl short loc_5D195
mov rcx, [rdi+18h]
mov rcx, [rcx+68h]
mov rcx, [rcx+rax*8]
inc dword ptr [rcx]
loc_5D195:
mov [rsi+4], eax
retn
|
long long set_closure_from_var(long long a1, long long a2, int *a3, __int16 a4)
{
char v4; // al
char v5; // al
char v6; // al
long long result; // rax
_DWORD *v8; // rcx
v4 = (*(_BYTE *)a2 & 0xFC) + 1;
*(_BYTE *)a2 = v4;
v5 = (4 * *((_BYTE *)a3 + 12)) & 4 | v4 & 0xF9;
*(_BYTE *)a2 = v5;
v6 = (4 * *((_BYTE *)a3 + 12)) & 8 | v5 & 0xF5;
*(_BYTE *)a2 = v6;
*(_BYTE *)a2 = a3[3] & 0xF0 | v6 & 0xD;
*(_WORD *)(a2 + 2) = a4;
result = *a3;
if ( result >= 224 )
{
v8 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8 * result);
++*v8;
}
*(_DWORD *)(a2 + 4) = result;
return result;
}
| |||
11,350 |
set_closure_from_var
|
bluesky950520[P]quickjs/quickjs.c
|
static void set_closure_from_var(JSContext *ctx, JSClosureVar *cv,
JSVarDef *vd, int var_idx)
{
cv->is_local = TRUE;
cv->is_arg = FALSE;
cv->is_const = vd->is_const;
cv->is_lexical = vd->is_lexical;
cv->var_kind = vd->var_kind;
cv->var_idx = var_idx;
cv->var_name = JS_DupAtom(ctx, vd->var_name);
}
|
O2
|
c
|
set_closure_from_var:
movb (%rsi), %al
andb $-0x4, %al
incb %al
movb %al, (%rsi)
movb 0xc(%rdx), %r8b
shlb $0x2, %r8b
andb $0x4, %r8b
andb $-0x7, %al
orb %r8b, %al
movb %al, (%rsi)
movb 0xc(%rdx), %r8b
shlb $0x2, %r8b
andb $0x8, %r8b
andb $-0xb, %al
orb %r8b, %al
movb %al, (%rsi)
movb 0xc(%rdx), %r8b
andb $-0x10, %r8b
andb $0xd, %al
orb %r8b, %al
movb %al, (%rsi)
movw %cx, 0x2(%rsi)
movslq (%rdx), %rax
cmpq $0xe0, %rax
jl 0x4f9e3
movq 0x18(%rdi), %rcx
movq 0x68(%rcx), %rcx
movq (%rcx,%rax,8), %rcx
incl (%rcx)
movl %eax, 0x4(%rsi)
retq
|
set_closure_from_var:
mov al, [rsi]
and al, 0FCh
inc al
mov [rsi], al
mov r8b, [rdx+0Ch]
shl r8b, 2
and r8b, 4
and al, 0F9h
or al, r8b
mov [rsi], al
mov r8b, [rdx+0Ch]
shl r8b, 2
and r8b, 8
and al, 0F5h
or al, r8b
mov [rsi], al
mov r8b, [rdx+0Ch]
and r8b, 0F0h
and al, 0Dh
or al, r8b
mov [rsi], al
mov [rsi+2], cx
movsxd rax, dword ptr [rdx]
cmp rax, 0E0h
jl short loc_4F9E3
mov rcx, [rdi+18h]
mov rcx, [rcx+68h]
mov rcx, [rcx+rax*8]
inc dword ptr [rcx]
loc_4F9E3:
mov [rsi+4], eax
retn
|
long long set_closure_from_var(long long a1, long long a2, int *a3, __int16 a4)
{
char v4; // al
char v5; // al
char v6; // al
long long result; // rax
_DWORD *v8; // rcx
v4 = (*(_BYTE *)a2 & 0xFC) + 1;
*(_BYTE *)a2 = v4;
v5 = (4 * *((_BYTE *)a3 + 12)) & 4 | v4 & 0xF9;
*(_BYTE *)a2 = v5;
v6 = (4 * *((_BYTE *)a3 + 12)) & 8 | v5 & 0xF5;
*(_BYTE *)a2 = v6;
*(_BYTE *)a2 = a3[3] & 0xF0 | v6 & 0xD;
*(_WORD *)(a2 + 2) = a4;
result = *a3;
if ( result >= 224 )
{
v8 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8 * result);
++*v8;
}
*(_DWORD *)(a2 + 4) = result;
return result;
}
|
set_closure_from_var:
MOV AL,byte ptr [RSI]
AND AL,0xfc
INC AL
MOV byte ptr [RSI],AL
MOV R8B,byte ptr [RDX + 0xc]
SHL R8B,0x2
AND R8B,0x4
AND AL,0xf9
OR AL,R8B
MOV byte ptr [RSI],AL
MOV R8B,byte ptr [RDX + 0xc]
SHL R8B,0x2
AND R8B,0x8
AND AL,0xf5
OR AL,R8B
MOV byte ptr [RSI],AL
MOV R8B,byte ptr [RDX + 0xc]
AND R8B,0xf0
AND AL,0xd
OR AL,R8B
MOV byte ptr [RSI],AL
MOV word ptr [RSI + 0x2],CX
MOVSXD RAX,dword ptr [RDX]
CMP RAX,0xe0
JL 0x0014f9e3
MOV RCX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV RCX,qword ptr [RCX + RAX*0x8]
INC dword ptr [RCX]
LAB_0014f9e3:
MOV dword ptr [RSI + 0x4],EAX
RET
|
void set_closure_from_var(long param_1,byte *param_2,int *param_3,int2 param_4)
{
int iVar1;
int *piVar2;
byte bVar3;
byte bVar4;
byte bVar5;
bVar3 = (*param_2 & 0xfc) + 1;
*param_2 = bVar3;
bVar4 = (*(byte *)(param_3 + 3) & 1) << 2;
*param_2 = bVar3 & 0xf9 | bVar4;
bVar5 = (*(byte *)(param_3 + 3) & 2) << 2;
*param_2 = bVar3 & 0xf1 | bVar4 | bVar5;
*param_2 = bVar3 & 1 | bVar4 | bVar5 | *(byte *)(param_3 + 3) & 0xf0;
*(int2 *)(param_2 + 2) = param_4;
iVar1 = *param_3;
if (0xdf < (long)iVar1) {
piVar2 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (long)iVar1 * 8);
*piVar2 = *piVar2 + 1;
}
*(int *)(param_2 + 4) = iVar1;
return;
}
|
|
11,351 |
js_number_toFixed
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_number_toFixed(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val;
int f;
double d;
val = js_thisNumberValue(ctx, this_val);
if (JS_IsException(val))
return val;
if (JS_ToFloat64Free(ctx, &d, val))
return JS_EXCEPTION;
if (JS_ToInt32Sat(ctx, &f, argv[0]))
return JS_EXCEPTION;
if (f < 0 || f > 100) {
return JS_ThrowRangeError(ctx, "toFixed() digits argument must be between 0 and 100");
}
if (fabs(d) >= 1e21) {
// use ToString(d)
return js_dtoa(ctx, d, 0, JS_DTOA_TOSTRING);
} else {
return js_dtoa(ctx, d, f, JS_DTOA_FIXED);
}
}
|
O0
|
c
|
js_number_toFixed:
subq $0x68, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0xd7dd0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xd7829
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0xd7922
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0x10(%rsp), %rsi
callq 0x3e8e0
cmpl $0x0, %eax
je 0xd785d
movl $0x0, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
jmp 0xd7922
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x1c(%rsp), %rsi
callq 0x3e970
cmpl $0x0, %eax
je 0xd7893
movl $0x0, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
jmp 0xd7922
cmpl $0x0, 0x1c(%rsp)
jl 0xd78a1
cmpl $0x64, 0x1c(%rsp)
jle 0xd78c0
movq 0x40(%rsp), %rdi
leaq 0x3f8ef(%rip), %rsi # 0x11719c
movb $0x0, %al
callq 0x2f960
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
jmp 0xd7922
movsd 0x10(%rsp), %xmm0
movaps 0x3c283(%rip), %xmm1 # 0x113b50
pand %xmm1, %xmm0
movsd 0x3c22f(%rip), %xmm1 # 0x113b08
ucomisd %xmm1, %xmm0
jb 0xd78ff
movq 0x40(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
xorl %edx, %edx
movl %edx, %esi
callq 0x3f940
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
jmp 0xd7922
movq 0x40(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
movl 0x1c(%rsp), %esi
movl $0x2, %edx
callq 0x3f940
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rdx
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_number_toFixed:
sub rsp, 68h
mov [rsp+68h+var_20], rsi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_28], rdi
mov [rsp+68h+var_2C], ecx
mov [rsp+68h+var_38], r8
mov rdi, [rsp+68h+var_28]
mov rsi, [rsp+68h+var_20]
mov rdx, [rsp+68h+var_18]
call js_thisNumberValue
mov [rsp+68h+var_68], rax
mov [rsp+68h+var_60], rdx
mov rax, [rsp+68h+var_68]
mov [rsp+68h+var_48], rax
mov rax, [rsp+68h+var_60]
mov [rsp+68h+var_40], rax
mov rdi, [rsp+68h+var_48]
mov rsi, [rsp+68h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_D7829
mov rax, [rsp+68h+var_48]
mov [rsp+68h+var_10], rax
mov rax, [rsp+68h+var_40]
mov [rsp+68h+var_8], rax
jmp loc_D7922
loc_D7829:
mov rdi, [rsp+68h+var_28]
mov rdx, [rsp+68h+var_48]
mov rcx, [rsp+68h+var_40]
lea rsi, [rsp+68h+var_58]
call JS_ToFloat64Free
cmp eax, 0
jz short loc_D785D
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 6
jmp loc_D7922
loc_D785D:
mov rdi, [rsp+68h+var_28]
mov rax, [rsp+68h+var_38]
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+68h+var_4C]
call JS_ToInt32Sat
cmp eax, 0
jz short loc_D7893
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 6
jmp loc_D7922
loc_D7893:
cmp [rsp+68h+var_4C], 0
jl short loc_D78A1
cmp [rsp+68h+var_4C], 64h ; 'd'
jle short loc_D78C0
loc_D78A1:
mov rdi, [rsp+68h+var_28]
lea rsi, aTofixedDigitsA; "toFixed() digits argument must be betwe"...
mov al, 0
call JS_ThrowRangeError
mov [rsp+68h+var_10], rax
mov [rsp+68h+var_8], rdx
jmp short loc_D7922
loc_D78C0:
movsd xmm0, [rsp+68h+var_58]
movaps xmm1, cs:xmmword_113B50
pand xmm0, xmm1
movsd xmm1, cs:qword_113B08
ucomisd xmm0, xmm1
jb short loc_D78FF
mov rdi, [rsp+68h+var_28]
movsd xmm0, [rsp+68h+var_58]
xor edx, edx
mov esi, edx
call js_dtoa
mov [rsp+68h+var_10], rax
mov [rsp+68h+var_8], rdx
jmp short loc_D7922
loc_D78FF:
mov rdi, [rsp+68h+var_28]
movsd xmm0, [rsp+68h+var_58]
mov esi, [rsp+68h+var_4C]
mov edx, 2
call js_dtoa
mov [rsp+68h+var_10], rax
mov [rsp+68h+var_8], rdx
loc_D7922:
mov rax, [rsp+68h+var_10]
mov rdx, [rsp+68h+var_8]
add rsp, 68h
retn
|
long long js_number_toFixed(
long long a1,
long long a2,
long long a3,
int a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
long long v14; // rdx
long long v15; // rcx
long long v16; // r8
long long v17; // r9
__m128 v18; // xmm4
__m128 v19; // xmm5
long long v20; // rdx
long long v21; // rdx
long long v23; // [rsp+0h] [rbp-68h]
double v24; // [rsp+10h] [rbp-58h] BYREF
unsigned int v25; // [rsp+1Ch] [rbp-4Ch] BYREF
long long v26; // [rsp+20h] [rbp-48h]
long long v27; // [rsp+28h] [rbp-40h]
long long v28; // [rsp+30h] [rbp-38h]
int v29; // [rsp+3Ch] [rbp-2Ch]
long long v30; // [rsp+40h] [rbp-28h]
long long v31; // [rsp+48h] [rbp-20h]
long long v32; // [rsp+50h] [rbp-18h]
long long v33; // [rsp+58h] [rbp-10h]
long long v34; // [rsp+60h] [rbp-8h]
v31 = a2;
v32 = a3;
v30 = a1;
v29 = a4;
v28 = a5;
v23 = js_thisNumberValue(a1, a2, a3);
v26 = v23;
v27 = v13;
if ( JS_IsException_1(v23, v13) )
{
v33 = v26;
v34 = v27;
}
else if ( (unsigned int)JS_ToFloat64Free(v30, &v24, v26, v27) )
{
LODWORD(v33) = 0;
v34 = 6LL;
}
else if ( (unsigned int)JS_ToInt32Sat(v30, (long long)&v25, *(_DWORD **)v28, *(_QWORD *)(v28 + 8)) )
{
LODWORD(v33) = 0;
v34 = 6LL;
}
else if ( v25 <= 0x64 )
{
if ( *(double *)_mm_and_si128((__m128i)*(unsigned long long *)&v24, (__m128i)xmmword_113B50).m128i_i64 < 1.0e21 )
v33 = js_dtoa(v30, v25, 2, v24);
else
v33 = js_dtoa(v30, 0, 0, v24);
v34 = v21;
}
else
{
v33 = JS_ThrowRangeError(
v30,
(long long)"toFixed() digits argument must be between 0 and 100",
v14,
v15,
v16,
v17,
a6,
a7,
a8,
a9,
v18,
v19,
a12,
a13,
v23);
v34 = v20;
}
return v33;
}
|
js_number_toFixed:
SUB RSP,0x68
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x40],RDI
MOV dword ptr [RSP + 0x3c],ECX
MOV qword ptr [RSP + 0x30],R8
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x001d7dd0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001d7829
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x60],RAX
JMP 0x001d7922
LAB_001d7829:
MOV RDI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0x10]
CALL 0x0013e8e0
CMP EAX,0x0
JZ 0x001d785d
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x6
JMP 0x001d7922
LAB_001d785d:
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x1c]
CALL 0x0013e970
CMP EAX,0x0
JZ 0x001d7893
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x6
JMP 0x001d7922
LAB_001d7893:
CMP dword ptr [RSP + 0x1c],0x0
JL 0x001d78a1
CMP dword ptr [RSP + 0x1c],0x64
JLE 0x001d78c0
LAB_001d78a1:
MOV RDI,qword ptr [RSP + 0x40]
LEA RSI,[0x21719c]
MOV AL,0x0
CALL 0x0012f960
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
JMP 0x001d7922
LAB_001d78c0:
MOVSD XMM0,qword ptr [RSP + 0x10]
MOVAPS XMM1,xmmword ptr [0x00213b50]
PAND XMM0,XMM1
MOVSD XMM1,qword ptr [0x00213b08]
UCOMISD XMM0,XMM1
JC 0x001d78ff
MOV RDI,qword ptr [RSP + 0x40]
MOVSD XMM0,qword ptr [RSP + 0x10]
XOR EDX,EDX
MOV ESI,EDX
CALL 0x0013f940
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
JMP 0x001d7922
LAB_001d78ff:
MOV RDI,qword ptr [RSP + 0x40]
MOVSD XMM0,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0x1c]
MOV EDX,0x2
CALL 0x0013f940
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
LAB_001d7922:
MOV RAX,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
ADD RSP,0x68
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 [16]
js_number_toFixed(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int iVar1;
int1 auVar2 [16];
ulong local_58;
int local_4c;
int1 local_48 [16];
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_48 = js_thisNumberValue(param_1,param_2,param_3);
iVar1 = JS_IsException(local_48._0_8_,local_48._8_8_);
if (iVar1 == 0) {
iVar1 = JS_ToFloat64Free(local_28,&local_58,local_48._0_8_,local_48._8_8_);
if (iVar1 == 0) {
iVar1 = JS_ToInt32Sat(local_28,&local_4c,*local_38,local_38[1]);
if (iVar1 == 0) {
if ((local_4c < 0) || (100 < local_4c)) {
auVar2 = JS_ThrowRangeError(local_28,"toFixed() digits argument must be between 0 and 100"
);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
else if ((double)(local_58 & _DAT_00213b50) < DAT_00213b08) {
auVar2 = js_dtoa(local_58,local_28,local_4c,2);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
else {
auVar2 = js_dtoa(local_58,local_28,0);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
}
else {
local_10 = 0;
local_8 = 6;
}
}
else {
local_10 = 0;
local_8 = 6;
}
}
else {
local_10 = local_48._0_4_;
uStack_c = local_48._4_4_;
local_8 = local_48._8_8_;
}
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
|
|
11,352 |
js_number_toFixed
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_number_toFixed(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val;
int f;
double d;
val = js_thisNumberValue(ctx, this_val);
if (JS_IsException(val))
return val;
if (JS_ToFloat64Free(ctx, &d, val))
return JS_EXCEPTION;
if (JS_ToInt32Sat(ctx, &f, argv[0]))
return JS_EXCEPTION;
if (f < 0 || f > 100) {
return JS_ThrowRangeError(ctx, "toFixed() digits argument must be between 0 and 100");
}
if (fabs(d) >= 1e21) {
// use ToString(d)
return js_dtoa(ctx, d, 0, JS_DTOA_TOSTRING);
} else {
return js_dtoa(ctx, d, f, JS_DTOA_FIXED);
}
}
|
O2
|
c
|
js_number_toFixed:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rdi, %r15
callq 0x6aa30
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
jne 0x6a45e
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r14, %r12
andq %rax, %r12
jmp 0x6a498
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x24e38
pushq $0x6
popq %rbx
testl %eax, %eax
jne 0x6a492
movq (%r12), %rdx
movq 0x8(%r12), %rcx
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x24eed
testl %eax, %eax
je 0x6a4ad
xorl %r14d, %r14d
xorl %r12d, %r12d
movl %r14d, %eax
orq %r12, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl 0xc(%rsp), %esi
cmpl $0x65, %esi
jb 0x6a4cc
leaq 0x21c16(%rip), %rsi # 0x8c0d3
xorl %r14d, %r14d
movq %r15, %rdi
xorl %eax, %eax
callq 0x1e863
jmp 0x6a495
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
movsd 0x10(%rsp), %xmm0
movapd 0x1e48c(%rip), %xmm1 # 0x88970
andpd %xmm0, %xmm1
ucomisd 0x1e620(%rip), %xmm1 # 0x88b10
jae 0x6a4fa
pushq $0x2
popq %rdx
movq %r15, %rdi
jmp 0x6a501
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2542c
movq %rax, %r14
movq %rdx, %rbx
jmp 0x6a459
|
js_number_toFixed:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r12, r8
mov r15, rdi
call js_thisNumberValue
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jnz short loc_6A45E
mov rax, 0FFFFFFFF00000000h
mov r12, r14
loc_6A459:
and r12, rax
jmp short loc_6A498
loc_6A45E:
lea rsi, [rsp+38h+var_28]
mov rdi, r15
mov rdx, r14
mov rcx, rbx
call JS_ToFloat64Free
push 6
pop rbx
test eax, eax
jnz short loc_6A492
mov rdx, [r12]
mov rcx, [r12+8]
lea rsi, [rsp+38h+var_2C]
mov rdi, r15
call JS_ToInt32Sat
test eax, eax
jz short loc_6A4AD
loc_6A492:
xor r14d, r14d
loc_6A495:
xor r12d, r12d
loc_6A498:
mov eax, r14d
or rax, r12
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
loc_6A4AD:
mov esi, [rsp+38h+var_2C]
cmp esi, 65h ; 'e'
jb short loc_6A4CC
lea rsi, aTofixedDigitsA; "toFixed() digits argument must be betwe"...
xor r14d, r14d
mov rdi, r15
xor eax, eax
call JS_ThrowRangeError
jmp short loc_6A495
loc_6A4CC:
mov r12, 0FFFFFFFF00000000h
movsd xmm0, [rsp+38h+var_28]
movapd xmm1, cs:xmmword_88970
andpd xmm1, xmm0
ucomisd xmm1, cs:qword_88B10
jnb short loc_6A4FA
push 2
pop rdx
mov rdi, r15
jmp short loc_6A501
loc_6A4FA:
mov rdi, r15
xor esi, esi
xor edx, edx
loc_6A501:
call js_dtoa
mov r14, rax
mov rbx, rdx
jmp loc_6A459
|
unsigned long long js_number_toFixed(
const char *a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13)
{
long long v14; // rax
long long v15; // rdx
unsigned long long v16; // r14
long long v17; // rax
unsigned long long v18; // r12
unsigned long long v19; // r12
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
int v27; // esi
int v28; // edx
char v29; // [rsp+0h] [rbp-38h]
unsigned int v30; // [rsp+Ch] [rbp-2Ch] BYREF
unsigned long long v31[5]; // [rsp+10h] [rbp-28h] BYREF
v14 = js_thisNumberValue();
v16 = v14;
if ( (_DWORD)v15 != 6 )
{
if ( (unsigned int)JS_ToFloat64Free(a1, (double *)v31, v14, v15)
|| (unsigned int)JS_ToInt32Sat((long long)a1, (long long)&v30, *(_DWORD **)a13, *(_QWORD *)(a13 + 8)) )
{
LODWORD(v16) = 0;
}
else
{
v27 = v30;
if ( v30 < 0x65 )
{
v18 = 0xFFFFFFFF00000000LL;
if ( fabs(*(double *)v31) >= 1.0e21 )
{
v27 = 0;
v28 = 0;
}
else
{
v28 = 2;
}
v17 = js_dtoa((long long)a1, v27, v28, (__m128i)v31[0]);
LODWORD(v16) = v17;
goto LABEL_3;
}
LODWORD(v16) = 0;
JS_ThrowRangeError(
(long long)a1,
(long long)"toFixed() digits argument must be between 0 and 100",
v20,
v21,
v22,
v23,
a2,
a3,
a4,
a5,
v24,
v25,
a8,
a9,
v29);
}
v19 = 0LL;
return v19 | (unsigned int)v16;
}
v17 = 0xFFFFFFFF00000000LL;
v18 = v16;
LABEL_3:
v19 = v17 & v18;
return v19 | (unsigned int)v16;
}
|
js_number_toFixed:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,R8
MOV R15,RDI
CALL 0x0016aa30
MOV R14,RAX
MOV RBX,RDX
CMP EBX,0x6
JNZ 0x0016a45e
MOV RAX,-0x100000000
MOV R12,R14
LAB_0016a459:
AND R12,RAX
JMP 0x0016a498
LAB_0016a45e:
LEA RSI,[RSP + 0x10]
MOV RDI,R15
MOV RDX,R14
MOV RCX,RBX
CALL 0x00124e38
PUSH 0x6
POP RBX
TEST EAX,EAX
JNZ 0x0016a492
MOV RDX,qword ptr [R12]
MOV RCX,qword ptr [R12 + 0x8]
LEA RSI,[RSP + 0xc]
MOV RDI,R15
CALL 0x00124eed
TEST EAX,EAX
JZ 0x0016a4ad
LAB_0016a492:
XOR R14D,R14D
LAB_0016a495:
XOR R12D,R12D
LAB_0016a498:
MOV EAX,R14D
OR RAX,R12
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0016a4ad:
MOV ESI,dword ptr [RSP + 0xc]
CMP ESI,0x65
JC 0x0016a4cc
LEA RSI,[0x18c0d3]
XOR R14D,R14D
MOV RDI,R15
XOR EAX,EAX
CALL 0x0011e863
JMP 0x0016a495
LAB_0016a4cc:
MOV R12,-0x100000000
MOVSD XMM0,qword ptr [RSP + 0x10]
MOVAPD XMM1,xmmword ptr [0x00188970]
ANDPD XMM1,XMM0
UCOMISD XMM1,qword ptr [0x00188b10]
JNC 0x0016a4fa
PUSH 0x2
POP RDX
MOV RDI,R15
JMP 0x0016a501
LAB_0016a4fa:
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
LAB_0016a501:
CALL 0x0012542c
MOV R14,RAX
MOV RBX,RDX
JMP 0x0016a459
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 [16] js_number_toFixed(int8 param_1)
{
int iVar1;
ulong uVar2;
int8 uVar3;
int8 *in_R8;
ulong uVar4;
int1 auVar5 [16];
int1 auVar6 [16];
uint local_2c;
ulong local_28;
auVar5 = js_thisNumberValue();
if (auVar5._8_4_ == 6) {
uVar2 = 0xffffffff00000000;
uVar4 = auVar5._0_8_;
LAB_0016a459:
uVar3 = auVar5._8_8_;
uVar2 = auVar5._0_8_ & uVar2;
}
else {
iVar1 = JS_ToFloat64Free(param_1,&local_28,auVar5._0_8_,auVar5._8_8_);
uVar3 = 6;
if ((iVar1 == 0) && (iVar1 = JS_ToInt32Sat(param_1,&local_2c,*in_R8,in_R8[1]), iVar1 == 0)) {
if (local_2c < 0x65) {
if (_DAT_00188b10 <= (double)(_DAT_00188970 & local_28)) {
local_2c = 0;
uVar3 = 0;
}
else {
uVar3 = 2;
}
auVar6 = js_dtoa(param_1,local_2c,uVar3);
auVar5._8_8_ = auVar6._8_8_;
auVar5._0_8_ = 0xffffffff00000000;
uVar2 = auVar6._0_8_;
uVar4 = uVar2;
goto LAB_0016a459;
}
JS_ThrowRangeError(param_1,"toFixed() digits argument must be between 0 and 100");
}
uVar4 = 0;
uVar2 = 0;
}
auVar6._0_8_ = uVar4 & 0xffffffff | uVar2;
auVar6._8_8_ = uVar3;
return auVar6;
}
|
|
11,353 |
minja::SequenceNode::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
|
MacroNode(const Location & location, std::shared_ptr<VariableExpr> && n, Expression::Parameters && p, std::shared_ptr<TemplateNode> && b)
: TemplateNode(location), name(std::move(n)), params(std::move(p)), body(std::move(b)) {
for (size_t i = 0; i < params.size(); ++i) {
const auto & name = params[i].first;
if (!name.empty()) {
named_param_positions[name] = i;
}
}
}
|
O1
|
cpp
|
minja::SequenceNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
cmpq %r12, %r15
je 0xa6be4
movq %rdx, %rbx
movq %rsi, %r14
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa03ce
addq $0x10, %r15
cmpq %r12, %r15
jne 0xa6bcd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZNK5minja12SequenceNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
push rax
mov r15, [rdi+20h]
mov r12, [rdi+28h]
cmp r15, r12
jz short loc_A6BE4
mov rbx, rdx
mov r14, rsi
loc_A6BCD:
mov rdi, [r15]
mov rsi, r14
mov rdx, rbx
call _ZNK5minja12TemplateNode6renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE; minja::TemplateNode::render(std::ostringstream &,std::shared_ptr<minja::Context> const&)
add r15, 10h
cmp r15, r12
jnz short loc_A6BCD
loc_A6BE4:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long minja::SequenceNode::do_render(long long a1)
{
long long ( ****v1)(_QWORD); // r15
long long ( ****i)(_QWORD); // r12
long long result; // rax
v1 = *(long long ( *****)(_QWORD))(a1 + 32);
for ( i = *(long long ( *****)(_QWORD))(a1 + 40); v1 != i; v1 += 2 )
result = minja::TemplateNode::render(*v1);
return result;
}
|
do_render:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,qword ptr [RDI + 0x20]
MOV R12,qword ptr [RDI + 0x28]
CMP R15,R12
JZ 0x001a6be4
MOV RBX,RDX
MOV R14,RSI
LAB_001a6bcd:
MOV RDI,qword ptr [R15]
MOV RSI,R14
MOV RDX,RBX
CALL 0x001a03ce
ADD R15,0x10
CMP R15,R12
JNZ 0x001a6bcd
LAB_001a6be4:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::SequenceNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context>
const&) const */
void minja::SequenceNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
int8 *puVar1;
int8 *puVar2;
puVar1 = *(int8 **)(param_1 + 0x28);
for (puVar2 = *(int8 **)(param_1 + 0x20); puVar2 != puVar1; puVar2 = puVar2 + 2) {
TemplateNode::render((ostringstream *)*puVar2,param_2);
}
return;
}
|
|
11,354 |
minja::SequenceNode::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
|
MacroNode(const Location & location, std::shared_ptr<VariableExpr> && n, Expression::Parameters && p, std::shared_ptr<TemplateNode> && b)
: TemplateNode(location), name(std::move(n)), params(std::move(p)), body(std::move(b)) {
for (size_t i = 0; i < params.size(); ++i) {
const auto & name = params[i].first;
if (!name.empty()) {
named_param_positions[name] = i;
}
}
}
|
O2
|
cpp
|
minja::SequenceNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
callq 0x77a5e
leaq 0x889f0(%rip), %rax # 0x103468
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x28(%rbx), %rax
movq %rax, 0x10(%rsp)
andq $0x0, 0x28(%rbx)
movups (%r13), %xmm0
andq $0x0, 0x8(%r13)
movups %xmm0, 0x20(%rbx)
andq $0x0, (%r13)
movups (%r12), %xmm0
movups %xmm0, 0x30(%rbx)
movq 0x10(%r12), %rax
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%r12)
movups %xmm0, (%r12)
andq $0x0, 0x50(%rbx)
movups (%r15), %xmm1
andq $0x0, 0x8(%r15)
movups %xmm1, 0x48(%rbx)
andq $0x0, (%r15)
leaq 0x30(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rbx), %r12
leaq 0x58(%rbx), %r13
leaq 0x88(%rbx), %rax
movq %rax, 0x58(%rbx)
movq $0x1, 0x60(%rbx)
movups %xmm0, 0x68(%rbx)
movl $0x3f800000, 0x78(%rbx) # imm = 0x3F800000
movups %xmm0, 0x80(%rbx)
xorl %ebp, %ebp
pushq $0x30
popq %r14
xorl %r15d, %r15d
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r14
cmpq %rax, %r15
jae 0x7ab49
cmpq $0x0, 0x8(%rsi,%rbp)
je 0x7ab40
addq %rbp, %rsi
movq %r13, %rdi
callq 0x7ad42
movq %r15, (%rax)
incq %r15
addq $0x30, %rbp
jmp 0x7ab15
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbp
movq %r13, %rdi
callq 0x7b184
movq %r12, %rdi
callq 0x37354
movq 0x8(%rsp), %rdi
callq 0x65fd8
movq 0x10(%rsp), %rdi
callq 0x37354
movq %rbx, %rdi
callq 0x7c07c
movq %rbp, %rdi
callq 0x24fe0
nop
|
_ZN5minja9MacroNodeC2ERKNS_8LocationEOSt10shared_ptrINS_12VariableExprEEOSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_INS_10ExpressionEEESaISI_EEOS4_INS_12TemplateNodeEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, r8
mov r12, rcx
mov r13, rdx
mov rbx, rdi
call _ZN5minja12TemplateNodeC2ERKNS_8LocationE; minja::TemplateNode::TemplateNode(minja::Location const&)
lea rax, _ZTVN5minja9MacroNodeE; `vtable for'minja::MacroNode
add rax, 10h
mov [rbx], rax
lea rax, [rbx+28h]
mov [rsp+48h+var_38], rax
and qword ptr [rbx+28h], 0
movups xmm0, xmmword ptr [r13+0]
and qword ptr [r13+8], 0
movups xmmword ptr [rbx+20h], xmm0
and qword ptr [r13+0], 0
movups xmm0, xmmword ptr [r12]
movups xmmword ptr [rbx+30h], xmm0
mov rax, [r12+10h]
mov [rbx+40h], rax
xorps xmm0, xmm0
and qword ptr [r12+10h], 0
movups xmmword ptr [r12], xmm0
and qword ptr [rbx+50h], 0
movups xmm1, xmmword ptr [r15]
and qword ptr [r15+8], 0
movups xmmword ptr [rbx+48h], xmm1
and qword ptr [r15], 0
lea rax, [rbx+30h]
mov [rsp+48h+var_40], rax
lea r12, [rbx+50h]
lea r13, [rbx+58h]
lea rax, [rbx+88h]
mov [rbx+58h], rax
mov qword ptr [rbx+60h], 1
movups xmmword ptr [rbx+68h], xmm0
mov dword ptr [rbx+78h], 3F800000h
movups xmmword ptr [rbx+80h], xmm0
xor ebp, ebp
push 30h ; '0'
pop r14
xor r15d, r15d
loc_7AB15:
mov rsi, [rbx+30h]
mov rax, [rbx+38h]
sub rax, rsi
cqo
idiv r14
cmp r15, rax
jnb short loc_7AB49
cmp qword ptr [rsi+rbp+8], 0
jz short loc_7AB40
add rsi, rbp
mov rdi, r13
call _ZNSt8__detail9_Map_baseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS6_mESaIS9_ENS_10_Select1stESt8equal_toIS6_ESt4hashIS6_ENS_18_Mod_range_hashingENS_20_Default_ranged_hashENS_20_Prime_rehash_policyENS_17_Hashtable_traitsILb1ELb0ELb1EEELb1EEixERS8_; std::__detail::_Map_base<std::string,std::pair<std::string const,ulong>,std::allocator<std::pair<std::string const,ulong>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>,true>::operator[](std::string const&)
mov [rax], r15
loc_7AB40:
inc r15
add rbp, 30h ; '0'
jmp short loc_7AB15
loc_7AB49:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbp, rax
mov rdi, r13
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESaIS8_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSA_18_Mod_range_hashingENSA_20_Default_ranged_hashENSA_20_Prime_rehash_policyENSA_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,ulong>,std::allocator<std::pair<std::string const,ulong>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
mov rdi, r12
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [rsp+arg_0]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESaISB_EED2Ev; std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::~vector()
mov rdi, [rsp+arg_8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbx; this
call _ZN5minja12TemplateNodeD2Ev; minja::TemplateNode::~TemplateNode()
mov rdi, rbp
call __Unwind_Resume
|
unsigned long long minja::MacroNode::MacroNode(long long a1, _QWORD *a2, __int128 *a3, long long a4, __int128 *a5)
{
int v8; // ecx
int v9; // r8d
int v10; // r9d
__int128 v11; // xmm0
__int128 v12; // xmm1
long long v13; // rbp
unsigned long long i; // r15
long long v15; // rsi
unsigned long long result; // rax
char v17; // [rsp+0h] [rbp-48h]
minja::TemplateNode::TemplateNode((_QWORD *)a1, a2);
*(_QWORD *)a1 = &`vtable for'minja::MacroNode + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v11 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v11;
*(_QWORD *)a3 = 0LL;
*(_OWORD *)(a1 + 48) = *(_OWORD *)a4;
*(_QWORD *)(a1 + 64) = *(_QWORD *)(a4 + 16);
*(_QWORD *)(a4 + 16) = 0LL;
*(_OWORD *)a4 = 0LL;
*(_QWORD *)(a1 + 80) = 0LL;
v12 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 72) = v12;
*(_QWORD *)a5 = 0LL;
*(_QWORD *)(a1 + 88) = a1 + 136;
*(_QWORD *)(a1 + 96) = 1LL;
*(_OWORD *)(a1 + 104) = 0LL;
*(_DWORD *)(a1 + 120) = 1065353216;
*(_OWORD *)(a1 + 128) = 0LL;
v13 = 0LL;
for ( i = 0LL; ; ++i )
{
v15 = *(_QWORD *)(a1 + 48);
result = (*(_QWORD *)(a1 + 56) - v15) / 48;
if ( i >= result )
break;
if ( *(_QWORD *)(v15 + v13 + 8) )
*(_QWORD *)std::__detail::_Map_base<std::string,std::pair<std::string const,unsigned long>,std::allocator<std::pair<std::string const,unsigned long>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>,true>::operator[](
(int)a1 + 88,
(int)v13 + (int)v15,
(*(_QWORD *)(a1 + 56) - v15) % 48,
v8,
v9,
v10,
v17) = i;
v13 += 48LL;
}
return result;
}
|
MacroNode:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,R8
MOV R12,RCX
MOV R13,RDX
MOV RBX,RDI
CALL 0x00177a5e
LEA RAX,[0x203468]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA RAX,[RBX + 0x28]
MOV qword ptr [RSP + 0x10],RAX
AND qword ptr [RBX + 0x28],0x0
MOVUPS XMM0,xmmword ptr [R13]
AND qword ptr [R13 + 0x8],0x0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
AND qword ptr [R13],0x0
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RBX + 0x40],RAX
XORPS XMM0,XMM0
AND qword ptr [R12 + 0x10],0x0
MOVUPS xmmword ptr [R12],XMM0
AND qword ptr [RBX + 0x50],0x0
MOVUPS XMM1,xmmword ptr [R15]
AND qword ptr [R15 + 0x8],0x0
MOVUPS xmmword ptr [RBX + 0x48],XMM1
AND qword ptr [R15],0x0
LEA RAX,[RBX + 0x30]
MOV qword ptr [RSP + 0x8],RAX
LEA R12,[RBX + 0x50]
LEA R13,[RBX + 0x58]
LEA RAX,[RBX + 0x88]
MOV qword ptr [RBX + 0x58],RAX
MOV qword ptr [RBX + 0x60],0x1
MOVUPS xmmword ptr [RBX + 0x68],XMM0
MOV dword ptr [RBX + 0x78],0x3f800000
MOVUPS xmmword ptr [RBX + 0x80],XMM0
XOR EBP,EBP
PUSH 0x30
POP R14
XOR R15D,R15D
LAB_0017ab15:
MOV RSI,qword ptr [RBX + 0x30]
MOV RAX,qword ptr [RBX + 0x38]
SUB RAX,RSI
CQO
IDIV R14
CMP R15,RAX
JNC 0x0017ab49
CMP qword ptr [RSI + RBP*0x1 + 0x8],0x0
JZ 0x0017ab40
ADD RSI,RBP
LAB_0017ab35:
MOV RDI,R13
CALL 0x0017ad42
LAB_0017ab3d:
MOV qword ptr [RAX],R15
LAB_0017ab40:
INC R15
ADD RBP,0x30
JMP 0x0017ab15
LAB_0017ab49:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::MacroNode::MacroNode(minja::Location const&, std::shared_ptr<minja::VariableExpr>&&,
std::vector<std::pair<std::__cxx11::string, std::shared_ptr<minja::Expression> >,
std::allocator<std::pair<std::__cxx11::string, std::shared_ptr<minja::Expression> > > >&&,
std::shared_ptr<minja::TemplateNode>&&) */
void __thiscall
minja::MacroNode::MacroNode
(MacroNode *this,Location *param_1,shared_ptr *param_2,vector *param_3,shared_ptr *param_4
)
{
long lVar1;
int8 uVar2;
ulong *puVar3;
long lVar4;
ulong uVar5;
TemplateNode::TemplateNode((TemplateNode *)this,param_1);
*(int ***)this = &PTR_do_render_00203478;
*(int8 *)(this + 0x28) = 0;
uVar2 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar2;
*(int8 *)param_2 = 0;
uVar2 = *(int8 *)(param_3 + 8);
*(int8 *)(this + 0x30) = *(int8 *)param_3;
*(int8 *)(this + 0x38) = uVar2;
*(int8 *)(this + 0x40) = *(int8 *)(param_3 + 0x10);
*(int8 *)(param_3 + 0x10) = 0;
*(int8 *)param_3 = 0;
*(int8 *)(param_3 + 8) = 0;
*(int8 *)(this + 0x50) = 0;
uVar2 = *(int8 *)(param_4 + 8);
*(int8 *)(param_4 + 8) = 0;
*(int8 *)(this + 0x48) = *(int8 *)param_4;
*(int8 *)(this + 0x50) = uVar2;
*(int8 *)param_4 = 0;
*(MacroNode **)(this + 0x58) = this + 0x88;
*(int8 *)(this + 0x60) = 1;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x70) = 0;
*(int4 *)(this + 0x78) = 0x3f800000;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
lVar4 = 0;
for (uVar5 = 0; lVar1 = *(long *)(this + 0x30),
uVar5 < (ulong)((*(long *)(this + 0x38) - lVar1) / 0x30); uVar5 = uVar5 + 1) {
if (*(long *)(lVar1 + 8 + lVar4) != 0) {
/* try { // try from 0017ab35 to 0017ab3c has its CatchHandler @ 0017ab58 */
puVar3 = (ulong *)std::__detail::
_Map_base<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>,true>
::operator[]((_Map_base<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>,true>
*)(this + 0x58),(string *)(lVar1 + lVar4));
*puVar3 = uVar5;
}
lVar4 = lVar4 + 0x30;
}
return;
}
|
|
11,355 |
js_array_iterator_finalizer
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_array_iterator_finalizer(JSRuntime *rt, JSValue val)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSArrayIteratorData *it = p->u.array_iterator_data;
if (it) {
JS_FreeValueRT(rt, it->obj);
js_free_rt(rt, it);
}
}
|
O1
|
c
|
js_array_iterator_finalizer:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rsi), %rbx
testq %rbx, %rbx
je 0x3b268
movq %rdi, %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x1d8c6
decq 0x28(%r14)
movq %rbx, %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
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
js_array_iterator_finalizer:
push r14
push rbx
push rax
mov rbx, [rsi+30h]
test rbx, rbx
jz short loc_3B268
mov r14, rdi
mov rsi, [rbx]
mov rdx, [rbx+8]
call JS_FreeValueRT
dec qword ptr [r14+28h]
mov rdi, rbx
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
loc_3B268:
add rsp, 8
pop rbx
pop r14
retn
|
long long js_array_iterator_finalizer(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
long long ( *v4)(_QWORD, long long); // rcx
long long result; // rax
v2 = *(_QWORD *)(a2 + 48);
if ( v2 )
{
JS_FreeValueRT(a1, *(_DWORD **)v2, *(_QWORD *)(v2 + 8));
--*(_QWORD *)(a1 + 40);
v3 = (*(long long ( **)(long long))(a1 + 32))(v2);
v4 = *(long long ( **)(_QWORD, long long))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v3 - 8;
return v4(*(_QWORD *)(a1 + 64), v2);
}
return result;
}
|
js_array_iterator_finalizer:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,qword ptr [RSI + 0x30]
TEST RBX,RBX
JZ 0x0013b268
MOV R14,RDI
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
CALL 0x0011d8c6
DEC qword ptr [R14 + 0x28]
MOV RDI,RBX
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_0013b268:
ADD RSP,0x8
POP RBX
POP R14
RET
|
void js_array_iterator_finalizer(long param_1,long param_2)
{
int8 *puVar1;
long lVar2;
puVar1 = *(int8 **)(param_2 + 0x30);
if (puVar1 != (int8 *)0x0) {
JS_FreeValueRT(param_1,*puVar1,puVar1[1]);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar2 = (**(code **)(param_1 + 0x20))(puVar1);
lVar2 = (*(long *)(param_1 + 0x30) - lVar2) + -8;
*(long *)(param_1 + 0x30) = lVar2;
/* WARNING: Could not recover jumptable at 0x0013b266. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),puVar1,lVar2,*(code **)(param_1 + 0x10));
return;
}
return;
}
|
|
11,356 |
type_inference_set_explicit_type
|
eshkol/src/frontend/type_inference/context.c
|
void type_inference_set_explicit_type(TypeInferenceContext* context, AstNode* node, Type* type) {
assert(context != NULL);
assert(node != NULL);
// Check if the node is already in the explicit context
for (size_t i = 0; i < context->explicit_count; i++) {
if (context->explicit_nodes[i] == node) {
// Update the type
context->explicit_types[i] = type;
node->type_info = type; // Also store directly in the node
return;
}
}
// Check if we need to resize the arrays
if (context->explicit_count >= context->explicit_capacity) {
size_t new_capacity = context->explicit_capacity * 2;
// Allocate new arrays
AstNode** new_nodes = arena_alloc(context->arena, new_capacity * sizeof(AstNode*));
if (!new_nodes) return;
Type** new_types = arena_alloc(context->arena, new_capacity * sizeof(Type*));
if (!new_types) return;
// Copy old arrays to new arrays
for (size_t i = 0; i < context->explicit_count; i++) {
new_nodes[i] = context->explicit_nodes[i];
new_types[i] = context->explicit_types[i];
}
// Update context
context->explicit_nodes = new_nodes;
context->explicit_types = new_types;
context->explicit_capacity = new_capacity;
}
// Add the node
context->explicit_nodes[context->explicit_count] = node;
context->explicit_types[context->explicit_count] = type;
node->type_info = type; // Also store directly in the node
context->explicit_count++;
}
|
O3
|
c
|
type_inference_set_explicit_type:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3687
movq %rsi, %r15
testq %rsi, %rsi
je 0x36a6
movq %rdi, %r14
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0x35d8
movq 0x30(%r14), %rsi
xorl %eax, %eax
cmpq %r15, (%rsi,%rax,8)
je 0x366c
incq %rax
cmpq %rax, %rcx
jne 0x35c6
movq 0x40(%r14), %rbx
cmpq %rbx, %rcx
jae 0x35e7
movq 0x30(%r14), %r12
jmp 0x3653
movq %rdx, -0x30(%rbp)
movq (%r14), %rdi
movq %rbx, %r13
shlq $0x4, %r13
movq %r13, %rsi
callq 0x1ac7
testq %rax, %rax
je 0x3678
movq %rax, %r12
movq (%r14), %rdi
movq %r13, %rsi
callq 0x1ac7
testq %rax, %rax
je 0x3678
addq %rbx, %rbx
movq 0x48(%r14), %rcx
testq %rcx, %rcx
movq -0x30(%rbp), %rdx
je 0x3647
xorl %edi, %edi
movq 0x30(%r14), %rsi
movq (%rsi,%rdi,8), %rsi
movq %rsi, (%r12,%rdi,8)
movq 0x38(%r14), %rsi
movq (%rsi,%rdi,8), %rsi
movq %rsi, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x3627
movq %r12, 0x30(%r14)
movq %rax, 0x38(%r14)
movq %rbx, 0x40(%r14)
movq %r15, (%r12,%rcx,8)
movq 0x38(%r14), %rax
movq %rdx, (%rax,%rcx,8)
movq %rdx, 0x18(%r15)
incq %rcx
movq %rcx, 0x48(%r14)
jmp 0x3678
movq 0x38(%r14), %rcx
movq %rdx, (%rcx,%rax,8)
movq %rdx, 0x18(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaa0b(%rip), %rdi # 0xe099
leaq 0xb68e(%rip), %rsi # 0xed23
leaq 0xb77d(%rip), %rcx # 0xee19
movl $0x89, %edx
callq 0x1130
leaq 0xb75f(%rip), %rdi # 0xee0c
leaq 0xb66f(%rip), %rsi # 0xed23
leaq 0xb75e(%rip), %rcx # 0xee19
movl $0x8a, %edx
callq 0x1130
|
type_inference_set_explicit_type:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
test rdi, rdi
jz loc_3687
mov r15, rsi
test rsi, rsi
jz loc_36A6
mov r14, rdi
mov rcx, [rdi+48h]
test rcx, rcx
jz short loc_35D8
mov rsi, [r14+30h]
xor eax, eax
loc_35C6:
cmp [rsi+rax*8], r15
jz loc_366C
inc rax
cmp rcx, rax
jnz short loc_35C6
loc_35D8:
mov rbx, [r14+40h]
cmp rcx, rbx
jnb short loc_35E7
mov r12, [r14+30h]
jmp short loc_3653
loc_35E7:
mov [rbp+var_30], rdx
mov rdi, [r14]
mov r13, rbx
shl r13, 4
mov rsi, r13
call arena_alloc
test rax, rax
jz short loc_3678
mov r12, rax
mov rdi, [r14]
mov rsi, r13
call arena_alloc
test rax, rax
jz short loc_3678
add rbx, rbx
mov rcx, [r14+48h]
test rcx, rcx
mov rdx, [rbp+var_30]
jz short loc_3647
xor edi, edi
loc_3627:
mov rsi, [r14+30h]
mov rsi, [rsi+rdi*8]
mov [r12+rdi*8], rsi
mov rsi, [r14+38h]
mov rsi, [rsi+rdi*8]
mov [rax+rdi*8], rsi
inc rdi
cmp rcx, rdi
jnz short loc_3627
loc_3647:
mov [r14+30h], r12
mov [r14+38h], rax
mov [r14+40h], rbx
loc_3653:
mov [r12+rcx*8], r15
mov rax, [r14+38h]
mov [rax+rcx*8], rdx
mov [r15+18h], rdx
inc rcx
mov [r14+48h], rcx
jmp short loc_3678
loc_366C:
mov rcx, [r14+38h]
mov [rcx+rax*8], rdx
mov [r15+18h], rdx
loc_3678:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3687:
lea rdi, aTypeContextNul+5; "context != NULL"
lea rsi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/eshkol"...
lea rcx, aVoidTypeInfere; "void type_inference_set_explicit_type(T"...
mov edx, 89h
call ___assert_fail
loc_36A6:
lea rdi, aNodeNull; "node != NULL"
lea rsi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/eshkol"...
lea rcx, aVoidTypeInfere; "void type_inference_set_explicit_type(T"...
mov edx, 8Ah
call ___assert_fail
|
long long type_inference_set_explicit_type(long long *a1, long long a2, long long a3)
{
unsigned long long v4; // rcx
long long result; // rax
unsigned long long v6; // rbx
long long v7; // r12
long long v8; // rbx
long long i; // rdi
long long v10; // [rsp+0h] [rbp-30h]
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github2025/eshkol/src/frontend/type_inference/context.c",
137LL,
"void type_inference_set_explicit_type(TypeInferenceContext *, AstNode *, Type *)");
if ( !a2 )
__assert_fail(
"node != NULL",
"/workspace/llm4binary/github2025/eshkol/src/frontend/type_inference/context.c",
138LL,
"void type_inference_set_explicit_type(TypeInferenceContext *, AstNode *, Type *)");
v4 = a1[9];
if ( !v4 )
{
LABEL_7:
v6 = a1[8];
if ( v4 >= v6 )
{
v10 = a3;
result = arena_alloc(*a1, 16 * v6);
if ( !result )
return result;
v7 = result;
result = arena_alloc(*a1, 16 * v6);
if ( !result )
return result;
v8 = 2 * v6;
v4 = a1[9];
a3 = v10;
if ( v4 )
{
for ( i = 0LL; i != v4; ++i )
{
*(_QWORD *)(v7 + 8 * i) = *(_QWORD *)(a1[6] + 8 * i);
*(_QWORD *)(result + 8 * i) = *(_QWORD *)(a1[7] + 8 * i);
}
}
a1[6] = v7;
a1[7] = result;
a1[8] = v8;
}
else
{
v7 = a1[6];
}
*(_QWORD *)(v7 + 8 * v4) = a2;
result = a1[7];
*(_QWORD *)(result + 8 * v4) = a3;
*(_QWORD *)(a2 + 24) = a3;
a1[9] = v4 + 1;
return result;
}
result = 0LL;
while ( *(_QWORD *)(a1[6] + 8 * result) != a2 )
{
if ( v4 == ++result )
goto LABEL_7;
}
*(_QWORD *)(a1[7] + 8 * result) = a3;
*(_QWORD *)(a2 + 24) = a3;
return result;
}
|
type_inference_set_explicit_type:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x00103687
MOV R15,RSI
TEST RSI,RSI
JZ 0x001036a6
MOV R14,RDI
MOV RCX,qword ptr [RDI + 0x48]
TEST RCX,RCX
JZ 0x001035d8
MOV RSI,qword ptr [R14 + 0x30]
XOR EAX,EAX
LAB_001035c6:
CMP qword ptr [RSI + RAX*0x8],R15
JZ 0x0010366c
INC RAX
CMP RCX,RAX
JNZ 0x001035c6
LAB_001035d8:
MOV RBX,qword ptr [R14 + 0x40]
CMP RCX,RBX
JNC 0x001035e7
MOV R12,qword ptr [R14 + 0x30]
JMP 0x00103653
LAB_001035e7:
MOV qword ptr [RBP + -0x30],RDX
MOV RDI,qword ptr [R14]
MOV R13,RBX
SHL R13,0x4
MOV RSI,R13
CALL 0x00101ac7
TEST RAX,RAX
JZ 0x00103678
MOV R12,RAX
MOV RDI,qword ptr [R14]
MOV RSI,R13
CALL 0x00101ac7
TEST RAX,RAX
JZ 0x00103678
ADD RBX,RBX
MOV RCX,qword ptr [R14 + 0x48]
TEST RCX,RCX
MOV RDX,qword ptr [RBP + -0x30]
JZ 0x00103647
XOR EDI,EDI
LAB_00103627:
MOV RSI,qword ptr [R14 + 0x30]
MOV RSI,qword ptr [RSI + RDI*0x8]
MOV qword ptr [R12 + RDI*0x8],RSI
MOV RSI,qword ptr [R14 + 0x38]
MOV RSI,qword ptr [RSI + RDI*0x8]
MOV qword ptr [RAX + RDI*0x8],RSI
INC RDI
CMP RCX,RDI
JNZ 0x00103627
LAB_00103647:
MOV qword ptr [R14 + 0x30],R12
MOV qword ptr [R14 + 0x38],RAX
MOV qword ptr [R14 + 0x40],RBX
LAB_00103653:
MOV qword ptr [R12 + RCX*0x8],R15
MOV RAX,qword ptr [R14 + 0x38]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV qword ptr [R15 + 0x18],RDX
INC RCX
MOV qword ptr [R14 + 0x48],RCX
JMP 0x00103678
LAB_0010366c:
MOV RCX,qword ptr [R14 + 0x38]
MOV qword ptr [RCX + RAX*0x8],RDX
MOV qword ptr [R15 + 0x18],RDX
LAB_00103678:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00103687:
LEA RDI,[0x10e099]
LEA RSI,[0x10ed23]
LEA RCX,[0x10ee19]
MOV EDX,0x89
CALL 0x00101130
LAB_001036a6:
LEA RDI,[0x10ee0c]
LEA RSI,[0x10ed23]
LEA RCX,[0x10ee19]
MOV EDX,0x8a
CALL 0x00101130
|
void type_inference_set_explicit_type(int8 *param_1,long param_2,int8 param_3)
{
ulong uVar1;
long lVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
if (param_1 == (int8 *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github2025/eshkol/src/frontend/type_inference/context.c",
0x89,
"void type_inference_set_explicit_type(TypeInferenceContext *, AstNode *, Type *)"
);
}
if (param_2 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("node != NULL",
"/workspace/llm4binary/github2025/eshkol/src/frontend/type_inference/context.c",
0x8a,
"void type_inference_set_explicit_type(TypeInferenceContext *, AstNode *, Type *)"
);
}
uVar4 = param_1[9];
if (uVar4 != 0) {
uVar1 = 0;
do {
if (*(long *)(param_1[6] + uVar1 * 8) == param_2) {
*(int8 *)(param_1[7] + uVar1 * 8) = param_3;
*(int8 *)(param_2 + 0x18) = param_3;
return;
}
uVar1 = uVar1 + 1;
} while (uVar4 != uVar1);
}
uVar1 = param_1[8];
if (uVar4 < uVar1) {
lVar2 = param_1[6];
}
else {
lVar2 = arena_alloc(*param_1,uVar1 << 4);
if (lVar2 == 0) {
return;
}
lVar3 = arena_alloc(*param_1,uVar1 << 4);
if (lVar3 == 0) {
return;
}
uVar4 = param_1[9];
if (uVar4 != 0) {
uVar5 = 0;
do {
*(int8 *)(lVar2 + uVar5 * 8) = *(int8 *)(param_1[6] + uVar5 * 8);
*(int8 *)(lVar3 + uVar5 * 8) = *(int8 *)(param_1[7] + uVar5 * 8);
uVar5 = uVar5 + 1;
} while (uVar4 != uVar5);
}
param_1[6] = lVar2;
param_1[7] = lVar3;
param_1[8] = uVar1 * 2;
}
*(long *)(lVar2 + uVar4 * 8) = param_2;
*(int8 *)(param_1[7] + uVar4 * 8) = param_3;
*(int8 *)(param_2 + 0x18) = param_3;
param_1[9] = uVar4 + 1;
return;
}
|
|
11,357 |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
|
seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h
|
static const MatcherDescriberInterface* GetDescriberImpl(
const MatcherBase& m) {
// If the impl is a MatcherDescriberInterface, then return it.
// Otherwise use MatcherBase itself.
// This allows us to implement the GetDescriber() function without support
// from the impl, but some users really want to get their impl back when
// they call GetDescriber().
// We use std::get on a tuple as a workaround of not having `if constexpr`.
return std::get<(
std::is_convertible<decltype(&P::Get(m)),
const MatcherDescriberInterface*>::value
? 1
: 0)>(std::make_tuple(&m, &P::Get(m)));
}
|
O1
|
c
|
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&):
movq %rdi, %rax
retq
|
_ZN7testing8internal11MatcherBaseISt17basic_string_viewIcSt11char_traitsIcEEE16GetDescriberImplINS6_11ValuePolicyINS0_9EqMatcherINSt7__cxx1112basic_stringIcS4_SaIcEEEEELb0EEEEEPKNS_25MatcherDescriberInterfaceERKS6_:
mov rax, rdi
retn
|
long long testing::internal::MatcherBase<std::string_view>::GetDescriberImpl<testing::internal::MatcherBase<std::string_view>::ValuePolicy<testing::internal::EqMatcher<std::string>,false>>(
long long a1)
{
return a1;
}
|
GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string>,false>>:
MOV RAX,RDI
RET
|
/* testing::MatcherDescriberInterface const*
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char> >
>::GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char,
std::char_traits<char> > >::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string >,
false> >(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char> > >
const&) */
MatcherDescriberInterface *
testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>>::
GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string>,false>>
(MatcherBase *param_1)
{
return (MatcherDescriberInterface *)param_1;
}
|
|
11,358 |
my_strxfrm_pad_unicode
|
eloqsql/strings/ctype-utf8.c
|
size_t
my_strxfrm_pad_unicode(uchar *str, uchar *strend)
{
uchar *str0= str;
DBUG_ASSERT(str && str <= strend);
for ( ; str < strend ; )
{
*str++= 0x00;
if (str < strend)
*str++= 0x20;
}
return str - str0;
}
|
O3
|
c
|
my_strxfrm_pad_unicode:
movq %rdi, %rax
cmpq %rsi, %rdi
jae 0x4ebcc
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rcx
leaq 0x1(%rcx), %rax
movb $0x0, (%rcx)
cmpq %rsi, %rax
jae 0x4ebc3
movb $0x20, 0x1(%rcx)
addq $0x2, %rcx
movq %rcx, %rax
movq %rax, %rcx
cmpq %rsi, %rax
jb 0x4ebac
popq %rbp
subq %rdi, %rax
retq
|
my_strxfrm_pad_unicode:
mov rax, rdi
cmp rdi, rsi
jnb short loc_4EBCC
push rbp
mov rbp, rsp
mov rcx, rdi
loc_4EBAC:
lea rax, [rcx+1]
mov byte ptr [rcx], 0
cmp rax, rsi
jnb short loc_4EBC3
mov byte ptr [rcx+1], 20h ; ' '
add rcx, 2
mov rax, rcx
loc_4EBC3:
mov rcx, rax
cmp rax, rsi
jb short loc_4EBAC
pop rbp
loc_4EBCC:
sub rax, rdi
retn
|
long long my_strxfrm_pad_unicode(_BYTE *a1, unsigned long long a2)
{
_BYTE *v2; // rax
_BYTE *v3; // rcx
v2 = a1;
if ( (unsigned long long)a1 < a2 )
{
v3 = a1;
do
{
v2 = v3 + 1;
*v3 = 0;
if ( (unsigned long long)(v3 + 1) < a2 )
{
v3[1] = 32;
v2 = v3 + 2;
}
v3 = v2;
}
while ( (unsigned long long)v2 < a2 );
}
return v2 - a1;
}
|
my_strxfrm_pad_unicode:
MOV RAX,RDI
CMP RDI,RSI
JNC 0x0014ebcc
PUSH RBP
MOV RBP,RSP
MOV RCX,RDI
LAB_0014ebac:
LEA RAX,[RCX + 0x1]
MOV byte ptr [RCX],0x0
CMP RAX,RSI
JNC 0x0014ebc3
MOV byte ptr [RCX + 0x1],0x20
ADD RCX,0x2
MOV RAX,RCX
LAB_0014ebc3:
MOV RCX,RAX
CMP RAX,RSI
JC 0x0014ebac
POP RBP
LAB_0014ebcc:
SUB RAX,RDI
RET
|
long my_strxfrm_pad_unicode(int1 *param_1,int1 *param_2)
{
int1 *puVar1;
int1 *puVar2;
puVar2 = param_1;
puVar1 = param_1;
if (param_1 < param_2) {
do {
puVar2 = puVar1 + 1;
*puVar1 = 0;
if (puVar2 < param_2) {
puVar1[1] = 0x20;
puVar2 = puVar1 + 2;
}
puVar1 = puVar2;
} while (puVar2 < param_2);
}
return (long)puVar2 - (long)param_1;
}
|
|
11,359 |
JS_NewTypedArray
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_NewTypedArray(JSContext *ctx, int argc, JSValue *argv,
JSTypedArrayEnum type)
{
if (type < JS_TYPED_ARRAY_UINT8C || type > JS_TYPED_ARRAY_FLOAT64)
return JS_ThrowRangeError(ctx, "invalid typed array type");
return js_typed_array_constructor(ctx, JS_UNDEFINED, argc, argv,
JS_CLASS_UINT8C_ARRAY + type);
}
|
O2
|
c
|
JS_NewTypedArray:
pushq %rbx
cmpl $0xc, %ecx
jb 0x35cfa
leaq 0x5331d(%rip), %rsi # 0x89009
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1e863
pushq $0x6
popq %rdx
jmp 0x35d10
movq %rdx, %r8
addl $0x15, %ecx
pushq $0x3
popq %rdx
xorl %esi, %esi
movl %ecx, %r9d
callq 0x35d15
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
|
JS_NewTypedArray:
push rbx
cmp ecx, 0Ch
jb short loc_35CFA
lea rsi, aInvalidTypedAr_0; "invalid typed array type"
xor ebx, ebx
xor eax, eax
call JS_ThrowRangeError
push 6
pop rdx
jmp short loc_35D10
loc_35CFA:
mov r8, rdx
add ecx, 15h
push 3
pop rdx
xor esi, esi
mov r9d, ecx
call js_typed_array_constructor
mov rbx, rax
loc_35D10:
mov rax, rbx
pop rbx
retn
|
long long JS_NewTypedArray(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
long long v14; // rbx
char v16; // [rsp+0h] [rbp-8h]
if ( (unsigned int)a12 < 0xC )
return js_typed_array_constructor(a1, 0LL, 3LL, (unsigned int)(a12 + 21), a11, (unsigned int)(a12 + 21));
v14 = 0LL;
JS_ThrowRangeError(a1, (long long)"invalid typed array type", a11, a12, a13, a14, a2, a3, a4, a5, a6, a7, a8, a9, v16);
return v14;
}
|
JS_NewTypedArray:
PUSH RBX
CMP ECX,0xc
JC 0x00135cfa
LEA RSI,[0x189009]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x0011e863
PUSH 0x6
POP RDX
JMP 0x00135d10
LAB_00135cfa:
MOV R8,RDX
ADD ECX,0x15
PUSH 0x3
POP RDX
XOR ESI,ESI
MOV R9D,ECX
CALL 0x00135d15
MOV RBX,RAX
LAB_00135d10:
MOV RAX,RBX
POP RBX
RET
|
int8 JS_NewTypedArray(int8 param_1,int8 param_2,int8 param_3,uint param_4)
{
int8 uVar1;
if (param_4 < 0xc) {
uVar1 = js_typed_array_constructor(param_1,0,3,param_4 + 0x15,param_3,param_4 + 0x15);
}
else {
uVar1 = 0;
JS_ThrowRangeError(param_1,"invalid typed array type");
}
return uVar1;
}
|
|
11,360 |
mysql_local_infile_error
|
eloqsql/libmariadb/libmariadb/ma_loaddata.c
|
static
int mysql_local_infile_error(void *ptr, char *error_buf, unsigned int error_buf_len)
{
MYSQL_INFILE_INFO *info = (MYSQL_INFILE_INFO *)ptr;
if (info) {
ma_strmake(error_buf, info->error_msg, error_buf_len);
return(info->error_no);
}
ma_strmake(error_buf, "Unknown error", error_buf_len);
return(CR_UNKNOWN_ERROR);
}
|
O0
|
c
|
mysql_local_infile_error:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x920e4
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0xc, %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x968c0
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x92100
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
leaq 0xbdae9(%rip), %rsi # 0x14fbdd
callq 0x968c0
movl $0x7d0, -0x4(%rbp) # imm = 0x7D0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
mysql_local_infile_error:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_920E4
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_28]
add rsi, 0Ch
mov eax, [rbp+var_1C]
mov edx, eax
call ma_strmake
mov rax, [rbp+var_28]
mov eax, [rax+8]
mov [rbp+var_4], eax
jmp short loc_92100
loc_920E4:
mov rdi, [rbp+var_18]
mov eax, [rbp+var_1C]
mov edx, eax
lea rsi, aUnknownError_1; "Unknown error"
call ma_strmake
mov [rbp+var_4], 7D0h
loc_92100:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long mysql_local_infile_error(long long a1, long long a2, unsigned int a3)
{
if ( a1 )
{
ma_strmake(a2, a1 + 12, a3);
return *(unsigned int *)(a1 + 8);
}
else
{
ma_strmake(a2, "Unknown error", a3);
return 2000;
}
}
|
mysql_local_infile_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001920e4
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0xc
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
CALL 0x001968c0
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00192100
LAB_001920e4:
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
LEA RSI,[0x24fbdd]
CALL 0x001968c0
MOV dword ptr [RBP + -0x4],0x7d0
LAB_00192100:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_local_infile_error(long param_1,int8 param_2,int4 param_3)
{
int4 local_c;
if (param_1 == 0) {
ma_strmake(param_2,"Unknown error",param_3);
local_c = 2000;
}
else {
ma_strmake(param_2,param_1 + 0xc,param_3);
local_c = *(int4 *)(param_1 + 8);
}
return local_c;
}
|
|
11,361 |
js_object_fromEntries
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_object_fromEntries(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, iter, next_method = JS_UNDEFINED;
JSValue iterable;
BOOL done;
/* RequireObjectCoercible() not necessary because it is tested in
JS_GetIterator() by JS_GetProperty() */
iterable = argv[0];
obj = JS_NewObject(ctx);
if (JS_IsException(obj))
return obj;
iter = JS_GetIterator(ctx, iterable, FALSE);
if (JS_IsException(iter))
goto fail;
next_method = JS_GetProperty(ctx, iter, JS_ATOM_next);
if (JS_IsException(next_method))
goto fail;
for(;;) {
JSValue key, value, item;
item = JS_IteratorNext(ctx, iter, next_method, 0, NULL, &done);
if (JS_IsException(item))
goto fail;
if (done) {
JS_FreeValue(ctx, item);
break;
}
key = JS_UNDEFINED;
value = JS_UNDEFINED;
if (!JS_IsObject(item)) {
JS_ThrowTypeErrorNotAnObject(ctx);
goto fail1;
}
key = JS_GetPropertyUint32(ctx, item, 0);
if (JS_IsException(key))
goto fail1;
value = JS_GetPropertyUint32(ctx, item, 1);
if (JS_IsException(value)) {
JS_FreeValue(ctx, key);
goto fail1;
}
if (JS_DefinePropertyValueValue(ctx, obj, key, value,
JS_PROP_C_W_E | JS_PROP_THROW) < 0) {
fail1:
JS_FreeValue(ctx, item);
goto fail;
}
JS_FreeValue(ctx, item);
}
JS_FreeValue(ctx, next_method);
JS_FreeValue(ctx, iter);
return obj;
fail:
if (JS_IsObject(iter)) {
/* close the iterator object, preserving pending exception */
JS_IteratorClose(ctx, iter, TRUE);
}
JS_FreeValue(ctx, next_method);
JS_FreeValue(ctx, iter);
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O0
|
c
|
js_object_fromEntries:
subq $0x158, %rsp # imm = 0x158
movq %rsi, 0x138(%rsp)
movq %rdx, 0x140(%rsp)
movq %rdi, 0x130(%rsp)
movl %ecx, 0x12c(%rsp)
movq %r8, 0x120(%rsp)
movq 0x4d6fb(%rip), %rax # 0x113b80
movq %rax, 0xf0(%rsp)
movq 0x4d6f4(%rip), %rax # 0x113b88
movq %rax, 0xf8(%rsp)
movq 0x120(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0xe0(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xe8(%rsp)
movq 0x130(%rsp), %rdi
callq 0x30860
movq %rax, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x110(%rsp), %rdi
movq 0x118(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xc6537
movq 0x110(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x150(%rsp)
jmp 0xc69bf
movq 0x130(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x74aa0
movq %rax, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x100(%rsp), %rdi
movq 0x108(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xc65a5
jmp 0xc6915
movq 0x130(%rsp), %rdi
movq 0x100(%rsp), %rsi
movq 0x108(%rsp), %rdx
movl $0x6b, %ecx
callq 0x30070
movq %rax, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xf8(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xc6616
jmp 0xc6915
jmp 0xc6618
movq 0x130(%rsp), %rdi
movq 0x100(%rsp), %rsi
movq 0x108(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xf8(%rsp), %r8
xorl %r9d, %r9d
xorl %eax, %eax
leaq 0xdc(%rsp), %rax
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x751a0
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xc669c
jmp 0xc6915
cmpl $0x0, 0xdc(%rsp)
je 0xc66c5
movq 0x130(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0x29f80
jmp 0xc68b6
movl $0x0, 0x58(%rsp)
movq $0x3, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0xa0(%rsp)
movl $0x0, 0x48(%rsp)
movq $0x3, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x31260
cmpl $0x0, %eax
jne 0xc674e
movq 0x130(%rsp), %rdi
callq 0x35890
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
jmp 0xc687b
movq 0x130(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
xorl %ecx, %ecx
callq 0x37750
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x98(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xc67ad
jmp 0xc687b
movq 0x130(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movl $0x1, %ecx
callq 0x37750
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xc6829
movq 0x130(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0x29f80
jmp 0xc687b
movq 0x130(%rsp), %rdi
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
movq 0x98(%rsp), %rcx
movq 0xa0(%rsp), %r8
leaq 0x88(%rsp), %rax
movl $0x4007, %r9d # imm = 0x4007
movq (%rax), %r10
movq %r10, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x3d580
cmpl $0x0, %eax
jge 0xc6897
jmp 0xc687b
movq 0x130(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0x29f80
jmp 0xc6915
movq 0x130(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0x29f80
jmp 0xc6618
movq 0x130(%rsp), %rdi
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
callq 0x29f80
movq 0x130(%rsp), %rdi
movq 0x100(%rsp), %rsi
movq 0x108(%rsp), %rdx
callq 0x29f80
movq 0x110(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x150(%rsp)
jmp 0xc69bf
movq 0x100(%rsp), %rdi
movq 0x108(%rsp), %rsi
callq 0x31260
cmpl $0x0, %eax
je 0xc6951
movq 0x130(%rsp), %rdi
movq 0x100(%rsp), %rsi
movq 0x108(%rsp), %rdx
movl $0x1, %ecx
callq 0x6e2b0
movq 0x130(%rsp), %rdi
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
callq 0x29f80
movq 0x130(%rsp), %rdi
movq 0x100(%rsp), %rsi
movq 0x108(%rsp), %rdx
callq 0x29f80
movq 0x130(%rsp), %rdi
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
callq 0x29f80
movl $0x0, 0x148(%rsp)
movq $0x6, 0x150(%rsp)
movq 0x148(%rsp), %rax
movq 0x150(%rsp), %rdx
addq $0x158, %rsp # imm = 0x158
retq
nopw (%rax,%rax)
|
js_object_fromEntries:
sub rsp, 158h
mov [rsp+158h+var_20], rsi
mov [rsp+158h+var_18], rdx
mov [rsp+158h+var_28], rdi
mov [rsp+158h+var_2C], ecx
mov [rsp+158h+var_38], r8
mov rax, cs:qword_113B80
mov [rsp+158h+var_68], rax
mov rax, cs:qword_113B88
mov [rsp+158h+var_60], rax
mov rax, [rsp+158h+var_38]
mov rcx, [rax]
mov [rsp+158h+var_78], rcx
mov rax, [rax+8]
mov [rsp+158h+var_70], rax
mov rdi, [rsp+158h+var_28]
call JS_NewObject
mov [rsp+158h+var_90], rax
mov [rsp+158h+var_88], rdx
mov rax, [rsp+158h+var_90]
mov [rsp+158h+var_48], rax
mov rax, [rsp+158h+var_88]
mov [rsp+158h+var_40], rax
mov rdi, [rsp+158h+var_48]
mov rsi, [rsp+158h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_C6537
mov rax, [rsp+158h+var_48]
mov [rsp+158h+var_10], rax
mov rax, [rsp+158h+var_40]
mov [rsp+158h+var_8], rax
jmp loc_C69BF
loc_C6537:
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_78]
mov rdx, [rsp+158h+var_70]
xor ecx, ecx
call JS_GetIterator
mov [rsp+158h+var_A0], rax
mov [rsp+158h+var_98], rdx
mov rax, [rsp+158h+var_A0]
mov [rsp+158h+var_58], rax
mov rax, [rsp+158h+var_98]
mov [rsp+158h+var_50], rax
mov rdi, [rsp+158h+var_58]
mov rsi, [rsp+158h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_C65A5
jmp loc_C6915
loc_C65A5:
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_58]
mov rdx, [rsp+158h+var_50]
mov ecx, 6Bh ; 'k'
call JS_GetProperty
mov [rsp+158h+var_B0], rax
mov [rsp+158h+var_A8], rdx
mov rax, [rsp+158h+var_B0]
mov [rsp+158h+var_68], rax
mov rax, [rsp+158h+var_A8]
mov [rsp+158h+var_60], rax
mov rdi, [rsp+158h+var_68]
mov rsi, [rsp+158h+var_60]
call JS_IsException_1
cmp eax, 0
jz short loc_C6616
jmp loc_C6915
loc_C6616:
jmp short $+2
loc_C6618:
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_58]
mov rdx, [rsp+158h+var_50]
mov rcx, [rsp+158h+var_68]
mov r8, [rsp+158h+var_60]
xor r9d, r9d
xor eax, eax
lea rax, [rsp+158h+var_7C]
mov [rsp+158h+var_158], 0
mov [rsp+158h+var_150], rax
call JS_IteratorNext
mov [rsp+158h+var_F0], rax
mov [rsp+158h+var_E8], rdx
mov rax, [rsp+158h+var_F0]
mov [rsp+158h+var_E0], rax
mov rax, [rsp+158h+var_E8]
mov [rsp+158h+var_D8], rax
mov rdi, [rsp+158h+var_E0]
mov rsi, [rsp+158h+var_D8]
call JS_IsException_1
cmp eax, 0
jz short loc_C669C
jmp loc_C6915
loc_C669C:
cmp [rsp+158h+var_7C], 0
jz short loc_C66C5
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_E0]
mov rdx, [rsp+158h+var_D8]
call JS_FreeValue
jmp loc_C68B6
loc_C66C5:
mov dword ptr [rsp+158h+var_100], 0
mov [rsp+158h+var_F8], 3
mov rax, [rsp+158h+var_100]
mov [rsp+158h+var_C0], rax
mov rax, [rsp+158h+var_F8]
mov [rsp+158h+var_B8], rax
mov dword ptr [rsp+158h+var_110], 0
mov [rsp+158h+var_108], 3
mov rax, [rsp+158h+var_110]
mov [rsp+158h+var_D0], rax
mov rax, [rsp+158h+var_108]
mov [rsp+158h+var_C8], rax
mov rdi, [rsp+158h+var_E0]
mov rsi, [rsp+158h+var_D8]
call JS_IsObject
cmp eax, 0
jnz short loc_C674E
mov rdi, [rsp+158h+var_28]
call JS_ThrowTypeErrorNotAnObject
mov [rsp+158h+var_120], rax
mov [rsp+158h+var_118], rdx
jmp loc_C687B
loc_C674E:
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_E0]
mov rdx, [rsp+158h+var_D8]
xor ecx, ecx
call JS_GetPropertyUint32
mov [rsp+158h+var_130], rax
mov [rsp+158h+var_128], rdx
mov rax, [rsp+158h+var_130]
mov [rsp+158h+var_C0], rax
mov rax, [rsp+158h+var_128]
mov [rsp+158h+var_B8], rax
mov rdi, [rsp+158h+var_C0]
mov rsi, [rsp+158h+var_B8]
call JS_IsException_1
cmp eax, 0
jz short loc_C67AD
jmp loc_C687B
loc_C67AD:
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_E0]
mov rdx, [rsp+158h+var_D8]
mov ecx, 1
call JS_GetPropertyUint32
mov [rsp+158h+var_140], rax
mov [rsp+158h+var_138], rdx
mov rax, [rsp+158h+var_140]
mov [rsp+158h+var_D0], rax
mov rax, [rsp+158h+var_138]
mov [rsp+158h+var_C8], rax
mov rdi, [rsp+158h+var_D0]
mov rsi, [rsp+158h+var_C8]
call JS_IsException_1
cmp eax, 0
jz short loc_C6829
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_C0]
mov rdx, [rsp+158h+var_B8]
call JS_FreeValue
jmp short loc_C687B
loc_C6829:
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_48]
mov rdx, [rsp+158h+var_40]
mov rcx, [rsp+158h+var_C0]
mov r8, [rsp+158h+var_B8]
lea rax, [rsp+158h+var_D0]
mov r9d, 4007h
mov r10, [rax]
mov [rsp+158h+var_158], r10
mov rax, [rax+8]
mov [rsp+158h+var_150], rax
call JS_DefinePropertyValueValue
cmp eax, 0
jge short loc_C6897
jmp short $+2
loc_C687B:
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_E0]
mov rdx, [rsp+158h+var_D8]
call JS_FreeValue
jmp short loc_C6915
loc_C6897:
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_E0]
mov rdx, [rsp+158h+var_D8]
call JS_FreeValue
jmp loc_C6618
loc_C68B6:
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_68]
mov rdx, [rsp+158h+var_60]
call JS_FreeValue
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_58]
mov rdx, [rsp+158h+var_50]
call JS_FreeValue
mov rax, [rsp+158h+var_48]
mov [rsp+158h+var_10], rax
mov rax, [rsp+158h+var_40]
mov [rsp+158h+var_8], rax
jmp loc_C69BF
loc_C6915:
mov rdi, [rsp+158h+var_58]
mov rsi, [rsp+158h+var_50]
call JS_IsObject
cmp eax, 0
jz short loc_C6951
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_58]
mov rdx, [rsp+158h+var_50]
mov ecx, 1
call JS_IteratorClose
loc_C6951:
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_68]
mov rdx, [rsp+158h+var_60]
call JS_FreeValue
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_58]
mov rdx, [rsp+158h+var_50]
call JS_FreeValue
mov rdi, [rsp+158h+var_28]
mov rsi, [rsp+158h+var_48]
mov rdx, [rsp+158h+var_40]
call JS_FreeValue
mov dword ptr [rsp+158h+var_10], 0
mov [rsp+158h+var_8], 6
loc_C69BF:
mov rax, [rsp+158h+var_10]
mov rdx, [rsp+158h+var_8]
add rsp, 158h
retn
|
long long js_object_fromEntries(
long long a1,
long long a2,
long long a3,
int a4,
long long *a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
double v14; // xmm4_8
double v15; // xmm5_8
long long v16; // rdx
long long v17; // rdx
long long v18; // rdx
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
long long v25; // rdx
long long v26; // rdx
double v27; // xmm4_8
double v28; // xmm5_8
double v29; // xmm4_8
double v30; // xmm5_8
_DWORD *v32; // [rsp+18h] [rbp-140h]
long long PropertyUint32; // [rsp+28h] [rbp-130h]
long long v34; // [rsp+68h] [rbp-F0h]
long long v35; // [rsp+80h] [rbp-D8h]
long long v36; // [rsp+90h] [rbp-C8h]
long long v37; // [rsp+A0h] [rbp-B8h]
int v38; // [rsp+DCh] [rbp-7Ch] BYREF
long long v39; // [rsp+E0h] [rbp-78h]
long long v40; // [rsp+E8h] [rbp-70h]
long long Property; // [rsp+F0h] [rbp-68h]
long long v42; // [rsp+F8h] [rbp-60h]
long long Iterator; // [rsp+100h] [rbp-58h]
long long v44; // [rsp+108h] [rbp-50h]
long long v45; // [rsp+110h] [rbp-48h]
long long v46; // [rsp+118h] [rbp-40h]
long long *v47; // [rsp+120h] [rbp-38h]
int v48; // [rsp+12Ch] [rbp-2Ch]
long long v49; // [rsp+130h] [rbp-28h]
long long v50; // [rsp+138h] [rbp-20h]
long long v51; // [rsp+140h] [rbp-18h]
long long v52; // [rsp+148h] [rbp-10h]
long long v53; // [rsp+150h] [rbp-8h]
v50 = a2;
v51 = a3;
v49 = a1;
v48 = a4;
v47 = a5;
Property = 0LL;
v42 = 3LL;
v39 = *a5;
v40 = a5[1];
v45 = JS_NewObject(a1);
v46 = v13;
if ( JS_IsException_1(v45, v13) )
{
v52 = v45;
v53 = v46;
}
else
{
Iterator = JS_GetIterator(v49, v39, v40, 0, a6, a7, a8, a9, v14, v15, a12, a13);
v44 = v16;
if ( !JS_IsException_1(Iterator, v16) )
{
Property = JS_GetProperty(v49, Iterator, v44, 107);
v42 = v17;
if ( !JS_IsException_1(Property, v17) )
{
while ( 1 )
{
v34 = JS_IteratorNext(v49, Iterator, v44, Property, v42, 0, 0LL, &v38);
v35 = v18;
if ( JS_IsException_1(v34, v18) )
goto LABEL_16;
if ( v38 )
{
JS_FreeValue(v49, v34, v35);
JS_FreeValue(v49, Property, v42);
JS_FreeValue(v49, Iterator, v44);
v52 = v45;
v53 = v46;
return v52;
}
if ( !JS_IsObject(v34, v35) )
break;
PropertyUint32 = JS_GetPropertyUint32(v49, v34, v35, 0);
v37 = v25;
if ( JS_IsException_1(PropertyUint32, v25) )
goto LABEL_14;
v32 = (_DWORD *)JS_GetPropertyUint32(v49, v34, v35, 1u);
v36 = v26;
if ( JS_IsException_1((long long)v32, v26) )
{
JS_FreeValue(v49, PropertyUint32, v37);
goto LABEL_14;
}
if ( (int)JS_DefinePropertyValueValue(
v49,
v45,
v46,
PropertyUint32,
v37,
16391,
a6,
a7,
a8,
a9,
v27,
v28,
a12,
a13,
v32,
v36) < 0 )
goto LABEL_14;
JS_FreeValue(v49, v34, v35);
}
JS_ThrowTypeErrorNotAnObject(v49, a6, a7, a8, a9, v23, v24, a12, a13, v35, v19, v20, v21, v22);
LABEL_14:
JS_FreeValue(v49, v34, v35);
}
}
LABEL_16:
if ( JS_IsObject(Iterator, v44) )
JS_IteratorClose(v49, Iterator, v44, 1, a6, a7, a8, a9, v29, v30, a12, a13);
JS_FreeValue(v49, Property, v42);
JS_FreeValue(v49, Iterator, v44);
JS_FreeValue(v49, v45, v46);
LODWORD(v52) = 0;
v53 = 6LL;
}
return v52;
}
|
js_object_fromEntries:
SUB RSP,0x158
MOV qword ptr [RSP + 0x138],RSI
MOV qword ptr [RSP + 0x140],RDX
MOV qword ptr [RSP + 0x130],RDI
MOV dword ptr [RSP + 0x12c],ECX
MOV qword ptr [RSP + 0x120],R8
MOV RAX,qword ptr [0x00213b80]
MOV qword ptr [RSP + 0xf0],RAX
MOV RAX,qword ptr [0x00213b88]
MOV qword ptr [RSP + 0xf8],RAX
MOV RAX,qword ptr [RSP + 0x120]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0xe0],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0xe8],RAX
MOV RDI,qword ptr [RSP + 0x130]
CALL 0x00130860
MOV qword ptr [RSP + 0xc8],RAX
MOV qword ptr [RSP + 0xd0],RDX
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x110],RAX
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x118],RAX
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0x118]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001c6537
MOV RAX,qword ptr [RSP + 0x110]
MOV qword ptr [RSP + 0x148],RAX
MOV RAX,qword ptr [RSP + 0x118]
MOV qword ptr [RSP + 0x150],RAX
JMP 0x001c69bf
LAB_001c6537:
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0xe0]
MOV RDX,qword ptr [RSP + 0xe8]
XOR ECX,ECX
CALL 0x00174aa0
MOV qword ptr [RSP + 0xb8],RAX
MOV qword ptr [RSP + 0xc0],RDX
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x100],RAX
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x108],RAX
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0x108]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001c65a5
JMP 0x001c6915
LAB_001c65a5:
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x100]
MOV RDX,qword ptr [RSP + 0x108]
MOV ECX,0x6b
CALL 0x00130070
MOV qword ptr [RSP + 0xa8],RAX
MOV qword ptr [RSP + 0xb0],RDX
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xf0],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xf8],RAX
MOV RDI,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0xf8]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001c6616
JMP 0x001c6915
LAB_001c6616:
JMP 0x001c6618
LAB_001c6618:
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x100]
MOV RDX,qword ptr [RSP + 0x108]
MOV RCX,qword ptr [RSP + 0xf0]
MOV R8,qword ptr [RSP + 0xf8]
XOR R9D,R9D
XOR EAX,EAX
LEA RAX,[RSP + 0xdc]
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001751a0
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x80],RAX
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001c669c
JMP 0x001c6915
LAB_001c669c:
CMP dword ptr [RSP + 0xdc],0x0
JZ 0x001c66c5
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
CALL 0x00129f80
JMP 0x001c68b6
LAB_001c66c5:
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x3
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xa0],RAX
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x3
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x90],RAX
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x00131260
CMP EAX,0x0
JNZ 0x001c674e
MOV RDI,qword ptr [RSP + 0x130]
CALL 0x00135890
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
JMP 0x001c687b
LAB_001c674e:
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
XOR ECX,ECX
CALL 0x00137750
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xa0],RAX
MOV RDI,qword ptr [RSP + 0x98]
MOV RSI,qword ptr [RSP + 0xa0]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001c67ad
JMP 0x001c687b
LAB_001c67ad:
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
MOV ECX,0x1
CALL 0x00137750
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x90],RAX
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x90]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001c6829
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
CALL 0x00129f80
JMP 0x001c687b
LAB_001c6829:
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x110]
MOV RDX,qword ptr [RSP + 0x118]
MOV RCX,qword ptr [RSP + 0x98]
MOV R8,qword ptr [RSP + 0xa0]
LEA RAX,[RSP + 0x88]
MOV R9D,0x4007
MOV R10,qword ptr [RAX]
MOV qword ptr [RSP],R10
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0013d580
CMP EAX,0x0
JGE 0x001c6897
JMP 0x001c687b
LAB_001c687b:
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
CALL 0x00129f80
JMP 0x001c6915
LAB_001c6897:
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
CALL 0x00129f80
JMP 0x001c6618
LAB_001c68b6:
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0xf0]
MOV RDX,qword ptr [RSP + 0xf8]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x100]
MOV RDX,qword ptr [RSP + 0x108]
CALL 0x00129f80
MOV RAX,qword ptr [RSP + 0x110]
MOV qword ptr [RSP + 0x148],RAX
MOV RAX,qword ptr [RSP + 0x118]
MOV qword ptr [RSP + 0x150],RAX
JMP 0x001c69bf
LAB_001c6915:
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0x108]
CALL 0x00131260
CMP EAX,0x0
JZ 0x001c6951
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x100]
MOV RDX,qword ptr [RSP + 0x108]
MOV ECX,0x1
CALL 0x0016e2b0
LAB_001c6951:
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0xf0]
MOV RDX,qword ptr [RSP + 0xf8]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x100]
MOV RDX,qword ptr [RSP + 0x108]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x110]
MOV RDX,qword ptr [RSP + 0x118]
CALL 0x00129f80
MOV dword ptr [RSP + 0x148],0x0
MOV qword ptr [RSP + 0x150],0x6
LAB_001c69bf:
MOV RAX,qword ptr [RSP + 0x148]
MOV RDX,qword ptr [RSP + 0x150]
ADD RSP,0x158
RET
|
int1 [16]
js_object_fromEntries
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int iVar1;
int8 uVar3;
int8 uVar5;
int1 auVar6 [16];
int local_7c;
int8 local_78;
int8 local_70;
int1 local_68 [16];
int1 local_58 [16];
int1 local_48 [16];
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
int8 uVar2;
int8 uVar4;
local_68._0_8_ = DAT_00213b80;
local_68._8_8_ = DAT_00213b88;
local_78 = *param_5;
local_70 = param_5[1];
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_48 = JS_NewObject(param_1);
iVar1 = JS_IsException(local_48._0_8_,local_48._8_8_);
if (iVar1 == 0) {
local_58 = JS_GetIterator(local_28,local_78,local_70,0);
iVar1 = JS_IsException(local_58._0_8_,local_58._8_8_);
if (iVar1 == 0) {
local_68 = JS_GetProperty(local_28,local_58._0_8_,local_58._8_8_,0x6b);
iVar1 = JS_IsException(local_68._0_8_,local_68._8_8_);
if (iVar1 == 0) {
while( true ) {
auVar6 = JS_IteratorNext(local_28,local_58._0_8_,local_58._8_8_,local_68._0_8_,
local_68._8_8_,0,0,&local_7c);
uVar4 = auVar6._8_8_;
uVar2 = auVar6._0_8_;
iVar1 = JS_IsException(uVar2,uVar4);
if (iVar1 != 0) break;
if (local_7c != 0) {
JS_FreeValue(local_28,uVar2,uVar4);
JS_FreeValue(local_28,local_68._0_8_,local_68._8_8_);
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
local_10 = local_48._0_4_;
uStack_c = local_48._4_4_;
local_8 = local_48._8_8_;
goto LAB_001c69bf;
}
iVar1 = JS_IsObject(uVar2,uVar4);
if (iVar1 == 0) {
JS_ThrowTypeErrorNotAnObject(local_28);
LAB_001c687b:
JS_FreeValue(local_28,uVar2,uVar4);
break;
}
auVar6 = JS_GetPropertyUint32(local_28,uVar2,uVar4,0);
uVar5 = auVar6._8_8_;
uVar3 = auVar6._0_8_;
iVar1 = JS_IsException(uVar3,uVar5);
if (iVar1 != 0) goto LAB_001c687b;
auVar6 = JS_GetPropertyUint32(local_28,uVar2,uVar4,1);
iVar1 = JS_IsException(auVar6._0_8_,auVar6._8_8_);
if (iVar1 != 0) {
JS_FreeValue(local_28,uVar3,uVar5);
goto LAB_001c687b;
}
iVar1 = JS_DefinePropertyValueValue
(local_28,local_48._0_8_,local_48._8_8_,uVar3,uVar5,0x4007,auVar6);
if (iVar1 < 0) goto LAB_001c687b;
JS_FreeValue(local_28,uVar2,uVar4);
}
}
}
iVar1 = JS_IsObject(local_58._0_8_,local_58._8_8_);
if (iVar1 != 0) {
JS_IteratorClose(local_28,local_58._0_8_,local_58._8_8_,1);
}
JS_FreeValue(local_28,local_68._0_8_,local_68._8_8_);
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
JS_FreeValue(local_28,local_48._0_8_,local_48._8_8_);
local_10 = 0;
local_8 = 6;
}
else {
local_10 = local_48._0_4_;
uStack_c = local_48._4_4_;
local_8 = local_48._8_8_;
}
LAB_001c69bf:
auVar6._4_4_ = uStack_c;
auVar6._0_4_ = local_10;
auVar6._8_8_ = local_8;
return auVar6;
}
|
|
11,362 |
js_object_fromEntries
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_object_fromEntries(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, iter, next_method = JS_UNDEFINED;
JSValue iterable;
BOOL done;
/* RequireObjectCoercible() not necessary because it is tested in
JS_GetIterator() by JS_GetProperty() */
iterable = argv[0];
obj = JS_NewObject(ctx);
if (JS_IsException(obj))
return obj;
iter = JS_GetIterator(ctx, iterable, FALSE);
if (JS_IsException(iter))
goto fail;
next_method = JS_GetProperty(ctx, iter, JS_ATOM_next);
if (JS_IsException(next_method))
goto fail;
for(;;) {
JSValue key, value, item;
item = JS_IteratorNext(ctx, iter, next_method, 0, NULL, &done);
if (JS_IsException(item))
goto fail;
if (done) {
JS_FreeValue(ctx, item);
break;
}
key = JS_UNDEFINED;
value = JS_UNDEFINED;
if (!JS_IsObject(item)) {
JS_ThrowTypeErrorNotAnObject(ctx);
goto fail1;
}
key = JS_GetPropertyUint32(ctx, item, 0);
if (JS_IsException(key))
goto fail1;
value = JS_GetPropertyUint32(ctx, item, 1);
if (JS_IsException(value)) {
JS_FreeValue(ctx, key);
goto fail1;
}
if (JS_DefinePropertyValueValue(ctx, obj, key, value,
JS_PROP_C_W_E | JS_PROP_THROW) < 0) {
fail1:
JS_FreeValue(ctx, item);
goto fail;
}
JS_FreeValue(ctx, item);
}
JS_FreeValue(ctx, next_method);
JS_FreeValue(ctx, iter);
return obj;
fail:
if (JS_IsObject(iter)) {
/* close the iterator object, preserving pending exception */
JS_IteratorClose(ctx, iter, TRUE);
}
JS_FreeValue(ctx, next_method);
JS_FreeValue(ctx, iter);
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_object_fromEntries:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r15
movq (%r8), %r14
movq 0x8(%r8), %r12
movq 0x40(%rdi), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movl $0x1, %ecx
callq 0x24f61
movq %rax, %r13
movq %rdx, %rbx
cmpl $0x6, %ebx
jne 0x74e0f
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r13, %rcx
andq %rax, %rcx
jmp 0x75041
movq $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x45867
movq %rax, %r14
movq %rdx, %r12
movl %r12d, %ebp
cmpq $0x6, %rbp
jne 0x74e45
movl $0x3, %eax
movq %rax, (%rsp)
jmp 0x74fef
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x6b, %ecx
movq %r14, %r8
movq %r12, %r9
pushq $0x0
pushq $0x0
callq 0x26fff
addq $0x10, %rsp
movq %rax, 0x8(%rsp)
movq %rdx, (%rsp)
cmpl $0x6, %edx
je 0x74fef
movq %rbp, 0x48(%rsp)
movq %rbx, 0x10(%rsp)
movq %r13, 0x18(%rsp)
leaq 0x18(%r15), %rax
movq %rax, 0x50(%rsp)
movq %r15, %rdi
movq %r14, %rbx
movq %r14, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
xorl %r9d, %r9d
leaq 0x24(%rsp), %rax
pushq %rax
pushq $0x0
callq 0x45b58
addq $0x10, %rsp
movq %rax, %rbp
movq %rdx, %r14
movl %r14d, %eax
movl $0x2, %r13d
cmpq $0x6, %rax
je 0x74f7c
movl $0x3, %r13d
cmpl $0x0, 0x24(%rsp)
jne 0x74f69
movl $0x0, 0x38(%rsp)
movq $0x3, 0x40(%rsp)
movq %r15, %rdi
cmpl $-0x1, %eax
jne 0x74f55
movq %rbp, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x28210
movl $0x2, %r13d
cmpl $0x6, %edx
je 0x74f69
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movl $0x1, %ecx
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x28210
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
cmpl $0x6, %edx
jne 0x74f8a
movq 0x18(%r15), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x21922
jmp 0x74f69
leaq 0x2e341(%rip), %rsi # 0xa329d
xorl %eax, %eax
callq 0x265c3
movl $0x2, %r13d
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x21922
testl %r13d, %r13d
movq %rbx, %r14
je 0x74e90
jmp 0x74fcc
subq $0x10, %rsp
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %r8
movl $0x4007, %r9d # imm = 0x4007
callq 0x2ab89
addq $0x10, %rsp
movl %eax, %r13d
testl %eax, %eax
shrl $0x1e, %r13d
andl $-0x2, %r13d
jmp 0x74f69
cmpl $0x1, %r13d
je 0x75059
cmpl $0x2, %r13d
jne 0x75060
movq 0x18(%rsp), %r13
movq 0x10(%rsp), %rbx
movq 0x48(%rsp), %rbp
cmpl $-0x1, %ebp
jne 0x75007
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x43b05
movq 0x18(%r15), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x21922
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x21922
movq 0x18(%r15), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x21922
movl $0x6, %ebx
xorl %r13d, %r13d
xorl %ecx, %ecx
movl %r13d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
xorl %ecx, %ecx
jmp 0x75041
movq 0x18(%rsp), %r13
movq 0x10(%rsp), %rbx
movq 0x18(%r15), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x21922
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x21922
jmp 0x74dfa
|
js_object_fromEntries:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rdi
mov r14, [r8]
mov r12, [r8+8]
mov rax, [rdi+40h]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
mov ecx, 1
call JS_NewObjectProtoClass
mov r13, rax
mov rbx, rdx
cmp ebx, 6
jnz short loc_74E0F
loc_74DFA:
mov rax, 0FFFFFFFF00000000h
mov rcx, r13
and rcx, rax
jmp loc_75041
loc_74E0F:
mov [rsp+88h+var_80], 0
mov rdi, r15
mov rsi, r14
mov rdx, r12
xor ecx, ecx
call JS_GetIterator
mov r14, rax
mov r12, rdx
mov ebp, r12d
cmp rbp, 6
jnz short loc_74E45
mov eax, 3
mov [rsp+88h+var_88], rax
jmp loc_74FEF
loc_74E45:
mov rdi, r15
mov rsi, r14
mov rdx, r12
mov ecx, 6Bh ; 'k'
mov r8, r14
mov r9, r12
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov [rsp+88h+var_80], rax
mov [rsp+88h+var_88], rdx
cmp edx, 6
jz loc_74FEF
mov [rsp+88h+var_40], rbp
mov [rsp+88h+var_78], rbx
mov [rsp+88h+var_70], r13
lea rax, [r15+18h]
mov [rsp+88h+var_38], rax
loc_74E90:
mov rdi, r15
mov rbx, r14
mov rsi, r14
mov rdx, r12
mov rcx, [rsp+88h+var_80]
mov r8, [rsp+88h+var_88]
xor r9d, r9d
lea rax, [rsp+88h+var_64]
push rax
push 0
call JS_IteratorNext
add rsp, 10h
mov rbp, rax
mov r14, rdx
mov eax, r14d
mov r13d, 2
cmp rax, 6
jz loc_74F7C
mov r13d, 3
cmp [rsp+88h+var_64], 0
jnz loc_74F69
mov dword ptr [rsp+88h+var_50], 0
mov qword ptr [rsp+88h+var_50+8], 3
mov rdi, r15
cmp eax, 0FFFFFFFFh
jnz short loc_74F55
mov rsi, rbp
mov rdx, r14
xor ecx, ecx
call JS_GetPropertyInt64
mov r13d, 2
cmp edx, 6
jz short loc_74F69
mov [rsp+88h+var_60], rax
mov [rsp+88h+var_58], rdx
mov ecx, 1
mov rdi, r15
mov rsi, rbp
mov rdx, r14
call JS_GetPropertyInt64
mov qword ptr [rsp+88h+var_50], rax
mov qword ptr [rsp+88h+var_50+8], rdx
cmp edx, 6
jnz short loc_74F8A
mov rdi, [r15+18h]
mov rsi, [rsp+88h+var_60]
mov rdx, [rsp+88h+var_58]
call JS_FreeValueRT
jmp short loc_74F69
loc_74F55:
lea rsi, aOperandPrototy+20h; "not an object"
xor eax, eax
call JS_ThrowTypeError
mov r13d, 2
loc_74F69:
mov rax, [rsp+88h+var_38]
mov rdi, [rax]
mov rsi, rbp
mov rdx, r14
call JS_FreeValueRT
loc_74F7C:
test r13d, r13d
mov r14, rbx
jz loc_74E90
jmp short loc_74FCC
loc_74F8A:
sub rsp, 10h
movups xmm0, [rsp+98h+var_50]
movups [rsp+98h+var_98], xmm0
mov rdi, r15
mov rsi, [rsp+98h+var_70]
mov rdx, [rsp+98h+var_78]
mov rcx, [rsp+98h+var_60]
mov r8, [rsp+98h+var_58]
mov r9d, 4007h
call JS_DefinePropertyValueValue
add rsp, 10h
mov r13d, eax
test eax, eax
shr r13d, 1Eh
and r13d, 0FFFFFFFEh
jmp short loc_74F69
loc_74FCC:
cmp r13d, 1
jz loc_75059
cmp r13d, 2
jnz loc_75060
mov r13, [rsp+88h+var_70]
mov rbx, [rsp+88h+var_78]
mov rbp, [rsp+88h+var_40]
loc_74FEF:
cmp ebp, 0FFFFFFFFh
jnz short loc_75007
mov rdi, r15
mov rsi, r14
mov rdx, r12
mov ecx, 1
call JS_IteratorClose
loc_75007:
mov rdi, [r15+18h]
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_88]
call JS_FreeValueRT
mov rdi, [r15+18h]
mov rsi, r14
mov rdx, r12
call JS_FreeValueRT
mov rdi, [r15+18h]
mov rsi, r13
mov rdx, rbx
call JS_FreeValueRT
mov ebx, 6
xor r13d, r13d
xor ecx, ecx
loc_75041:
mov eax, r13d
or rax, rcx
mov rdx, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_75059:
xor r13d, r13d
xor ecx, ecx
jmp short loc_75041
loc_75060:
mov r13, [rsp+88h+var_70]
mov rbx, [rsp+88h+var_78]
mov rdi, [r15+18h]
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_88]
call JS_FreeValueRT
mov rdi, [r15+18h]
mov rsi, r14
mov rdx, r12
call JS_FreeValueRT
jmp loc_74DFA
|
unsigned long long js_object_fromEntries(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13)
{
long long v13; // r14
long long v14; // r12
long long v15; // r13
double v16; // xmm4_8
double v17; // xmm5_8
long long v18; // rdx
long long v19; // rbx
unsigned long long v20; // rcx
_DWORD *Iterator; // rax
long long v22; // rdx
__m128 v23; // xmm4
__m128 v24; // xmm5
_DWORD *v25; // r14
long long v26; // r12
long long v27; // rbp
long long v28; // rdx
_DWORD *v29; // rbx
long long v30; // rdx
long long v31; // rcx
_DWORD *v32; // rbp
long long v33; // r8
long long v34; // r9
long long v35; // r14
unsigned int v36; // r13d
_DWORD *PropertyInt64; // rax
long long v38; // rdx
__m128 v39; // rax
double v40; // xmm4_8
double v41; // xmm5_8
long long v43; // [rsp+10h] [rbp-88h]
_DWORD *PropertyInternal2; // [rsp+18h] [rbp-80h]
long long v45; // [rsp+20h] [rbp-78h]
unsigned long long v46; // [rsp+28h] [rbp-70h]
int v47; // [rsp+34h] [rbp-64h] BYREF
_DWORD *v48; // [rsp+38h] [rbp-60h]
long long v49; // [rsp+40h] [rbp-58h]
__m128 v50; // [rsp+48h] [rbp-50h]
long long v51; // [rsp+58h] [rbp-40h]
long long *v52; // [rsp+60h] [rbp-38h]
v13 = *a13;
v14 = a13[1];
v15 = JS_NewObjectProtoClass(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 16LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 24LL),
1u);
v19 = v18;
if ( (_DWORD)v18 == 6 )
goto LABEL_2;
PropertyInternal2 = 0LL;
Iterator = JS_GetIterator(a1, v13, v14, 0, a2, a3, a4, a5, v16, v17, a8, a9);
v25 = Iterator;
v26 = v22;
v27 = (unsigned int)v22;
if ( (unsigned int)v22 == 6LL )
{
v43 = 3LL;
}
else
{
PropertyInternal2 = (_DWORD *)JS_GetPropertyInternal2(
a1,
(long long)Iterator,
v22,
0x6Bu,
(long long)Iterator,
v22,
0LL,
0);
v43 = v28;
if ( (_DWORD)v28 != 6 )
{
v51 = v27;
v45 = v19;
v46 = v15;
v52 = (long long *)(a1 + 24);
do
{
v29 = v25;
v32 = (_DWORD *)JS_IteratorNext(a1, (int)v25, v26, (int)PropertyInternal2, v43, 0, 0LL, &v47);
v35 = v30;
v36 = 2;
if ( (unsigned int)v30 != 6LL )
{
v36 = 3;
if ( !v47 )
{
v50.m128_i32[0] = 0;
v50.m128_u64[1] = 3LL;
if ( (_DWORD)v30 == -1 )
{
PropertyInt64 = (_DWORD *)JS_GetPropertyInt64(a1, (long long)v32, v30, 0LL);
v36 = 2;
if ( (_DWORD)v38 != 6 )
{
v48 = PropertyInt64;
v49 = v38;
v39.m128_u64[0] = JS_GetPropertyInt64(a1, (long long)v32, v35, 1uLL);
v50 = v39;
if ( v39.m128_i32[2] == 6 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v48, v49);
}
else
{
a2 = v50;
v36 = ((unsigned int)JS_DefinePropertyValueValue(
a1,
v46,
v45,
v48,
v49,
16391,
*(double *)v50.m128_u64,
a3,
a4,
a5,
v40,
v41,
a8,
a9,
v50.m128_u64[0],
v50.m128_i64[1]) >> 30) & 0xFFFFFFFE;
}
}
}
else
{
JS_ThrowTypeError(a1, (long long)"not an object", v30, v31, v33, v34, a2, a3, a4, a5, v23, v24, a8, a9, v43);
v36 = 2;
}
}
JS_FreeValueRT(*v52, v32, v35);
}
v25 = v29;
}
while ( !v36 );
if ( v36 == 1 )
{
LODWORD(v15) = 0;
v20 = 0LL;
return v20 | (unsigned int)v15;
}
if ( v36 != 2 )
{
v15 = v46;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), PropertyInternal2, v43);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v29, v26);
LABEL_2:
v20 = v15 & 0xFFFFFFFF00000000LL;
return v20 | (unsigned int)v15;
}
v15 = v46;
v19 = v45;
LODWORD(v27) = v51;
}
}
if ( (_DWORD)v27 == -1 )
JS_IteratorClose(a1, (long long)v25, v26, 1, a2, a3, a4, a5, *(double *)v23.m128_u64, *(double *)v24.m128_u64, a8, a9);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), PropertyInternal2, v43);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v25, v26);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v15, v19);
LODWORD(v15) = 0;
v20 = 0LL;
return v20 | (unsigned int)v15;
}
|
js_object_fromEntries:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RDI
MOV R14,qword ptr [R8]
MOV R12,qword ptr [R8 + 0x8]
MOV RAX,qword ptr [RDI + 0x40]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
MOV ECX,0x1
CALL 0x00124f61
MOV R13,RAX
MOV RBX,RDX
CMP EBX,0x6
JNZ 0x00174e0f
LAB_00174dfa:
MOV RAX,-0x100000000
MOV RCX,R13
AND RCX,RAX
JMP 0x00175041
LAB_00174e0f:
MOV qword ptr [RSP + 0x8],0x0
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
XOR ECX,ECX
CALL 0x00145867
MOV R14,RAX
MOV R12,RDX
MOV EBP,R12D
CMP RBP,0x6
JNZ 0x00174e45
MOV EAX,0x3
MOV qword ptr [RSP],RAX
JMP 0x00174fef
LAB_00174e45:
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
MOV ECX,0x6b
MOV R8,R14
MOV R9,R12
PUSH 0x0
PUSH 0x0
CALL 0x00126fff
ADD RSP,0x10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP],RDX
CMP EDX,0x6
JZ 0x00174fef
MOV qword ptr [RSP + 0x48],RBP
MOV qword ptr [RSP + 0x10],RBX
MOV qword ptr [RSP + 0x18],R13
LEA RAX,[R15 + 0x18]
MOV qword ptr [RSP + 0x50],RAX
LAB_00174e90:
MOV RDI,R15
MOV RBX,R14
MOV RSI,R14
MOV RDX,R12
MOV RCX,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RSP]
XOR R9D,R9D
LEA RAX,[RSP + 0x24]
PUSH RAX
PUSH 0x0
CALL 0x00145b58
ADD RSP,0x10
MOV RBP,RAX
MOV R14,RDX
MOV EAX,R14D
MOV R13D,0x2
CMP RAX,0x6
JZ 0x00174f7c
MOV R13D,0x3
CMP dword ptr [RSP + 0x24],0x0
JNZ 0x00174f69
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x3
MOV RDI,R15
CMP EAX,-0x1
JNZ 0x00174f55
MOV RSI,RBP
MOV RDX,R14
XOR ECX,ECX
CALL 0x00128210
MOV R13D,0x2
CMP EDX,0x6
JZ 0x00174f69
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
MOV ECX,0x1
MOV RDI,R15
MOV RSI,RBP
MOV RDX,R14
CALL 0x00128210
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
CMP EDX,0x6
JNZ 0x00174f8a
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x00121922
JMP 0x00174f69
LAB_00174f55:
LEA RSI,[0x1a329d]
XOR EAX,EAX
CALL 0x001265c3
MOV R13D,0x2
LAB_00174f69:
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RAX]
MOV RSI,RBP
MOV RDX,R14
CALL 0x00121922
LAB_00174f7c:
TEST R13D,R13D
MOV R14,RBX
JZ 0x00174e90
JMP 0x00174fcc
LAB_00174f8a:
SUB RSP,0x10
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x38]
MOV R8,qword ptr [RSP + 0x40]
MOV R9D,0x4007
CALL 0x0012ab89
ADD RSP,0x10
MOV R13D,EAX
TEST EAX,EAX
SHR R13D,0x1e
AND R13D,0xfffffffe
JMP 0x00174f69
LAB_00174fcc:
CMP R13D,0x1
JZ 0x00175059
CMP R13D,0x2
JNZ 0x00175060
MOV R13,qword ptr [RSP + 0x18]
MOV RBX,qword ptr [RSP + 0x10]
MOV RBP,qword ptr [RSP + 0x48]
LAB_00174fef:
CMP EBP,-0x1
JNZ 0x00175007
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
MOV ECX,0x1
CALL 0x00143b05
LAB_00175007:
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP]
CALL 0x00121922
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R14
MOV RDX,R12
CALL 0x00121922
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R13
MOV RDX,RBX
CALL 0x00121922
MOV EBX,0x6
XOR R13D,R13D
XOR ECX,ECX
LAB_00175041:
MOV EAX,R13D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00175059:
XOR R13D,R13D
XOR ECX,ECX
JMP 0x00175041
LAB_00175060:
MOV R13,qword ptr [RSP + 0x18]
MOV RBX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP]
CALL 0x00121922
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R14
MOV RDX,R12
CALL 0x00121922
JMP 0x00174dfa
|
int1 [16] js_object_fromEntries(long param_1)
{
int8 uVar1;
uint uVar2;
ulong uVar3;
int8 uVar4;
ulong uVar5;
ulong uVar7;
int iVar8;
int8 *in_R8;
int1 auVar9 [16];
int1 auVar10 [16];
int1 auVar11 [16];
int8 local_88;
int8 local_80;
int local_64;
int1 local_60 [16];
int1 local_50 [16];
ulong local_40;
int8 *local_38;
ulong uVar6;
uVar4 = *in_R8;
uVar1 = in_R8[1];
auVar9 = JS_NewObjectProtoClass
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x10),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x18),1);
uVar5 = auVar9._0_8_;
if (auVar9._8_4_ == 6) {
LAB_00174dfa:
uVar5 = uVar5 & 0xffffffff00000000;
}
else {
auVar10 = JS_GetIterator(param_1,uVar4,uVar1,0);
uVar6 = auVar10._8_8_;
uVar3 = auVar10._0_8_;
iVar8 = auVar10._8_4_;
if ((uVar6 & 0xffffffff) == 6) {
auVar10 = ZEXT816(3) << 0x40;
}
else {
auVar10 = JS_GetPropertyInternal2(param_1,uVar3,uVar6,0x6b,uVar3,uVar6,0,0);
if (auVar10._8_4_ != 6) {
local_38 = (int8 *)(param_1 + 0x18);
local_40 = uVar6 & 0xffffffff;
do {
auVar11 = JS_IteratorNext(param_1,uVar3,uVar6,auVar10._0_8_,auVar10._8_8_,0,0,&local_64);
uVar7 = auVar11._8_8_;
uVar4 = auVar11._0_8_;
uVar2 = 2;
if ((uVar7 & 0xffffffff) != 6) {
uVar2 = 3;
if (local_64 == 0) {
local_50._0_8_ = local_50._0_8_ & 0xffffffff00000000;
local_50._8_8_ = 3;
if (auVar11._8_4_ == -1) {
auVar11 = JS_GetPropertyInt64(param_1,uVar4,uVar7,0);
uVar2 = 2;
if (auVar11._8_4_ != 6) {
local_60 = auVar11;
local_50 = JS_GetPropertyInt64(param_1,uVar4,uVar7,1);
if (local_50._8_4_ == 6) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_60._0_8_,local_60._8_8_);
}
else {
uVar2 = JS_DefinePropertyValueValue
(param_1,uVar5,auVar9._8_8_,local_60._0_8_,local_60._8_8_,
0x4007,local_50);
uVar2 = uVar2 >> 0x1e & 0xfffffffe;
}
}
}
else {
JS_ThrowTypeError(param_1,"not an object");
uVar2 = 2;
}
}
JS_FreeValueRT(*local_38,uVar4,uVar7);
}
} while (uVar2 == 0);
if (uVar2 == 1) {
auVar9._8_8_ = 0;
auVar9._0_8_ = uVar3;
auVar9 = auVar9 << 0x40;
uVar5 = 0;
goto LAB_00175041;
}
if (uVar2 != 2) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar10._0_8_,auVar10._8_8_);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar3,uVar6);
goto LAB_00174dfa;
}
iVar8 = (int)local_40;
}
}
local_88 = auVar10._8_8_;
local_80 = auVar10._0_8_;
if (iVar8 == -1) {
JS_IteratorClose(param_1,uVar3,uVar6,1);
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_80,local_88);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar3,uVar6);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar5,auVar9._8_8_);
auVar9 = ZEXT816(6) << 0x40;
uVar5 = 0;
}
LAB_00175041:
auVar10._0_8_ = auVar9._0_8_ & 0xffffffff | uVar5;
auVar10._8_8_ = auVar9._8_8_;
return auVar10;
}
|
|
11,363 |
quantize_q4_K
|
monkey531[P]llama/ggml/src/ggml-quants.c
|
size_t quantize_q4_K(const float * restrict src, void * restrict dst, int64_t nrow, int64_t n_per_row, const float * quant_weights) {
size_t row_size = ggml_row_size(GGML_TYPE_Q4_K, n_per_row);
if (!quant_weights) {
quantize_row_q4_K_ref(src, dst, (int64_t)nrow*n_per_row);
}
else {
char * qrow = (char *)dst;
for (int64_t row = 0; row < nrow; ++row) {
quantize_row_q4_K_impl(src, (block_q4_K*)qrow, n_per_row, quant_weights);
src += n_per_row;
qrow += row_size;
}
}
return nrow * row_size;
}
|
O2
|
c
|
quantize_q4_K:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
pushq $0xc
popq %rdi
movq %rcx, %rsi
callq 0x1e1a0
movq %rax, 0x18(%rsp)
movq %r13, 0x48(%rsp)
testq %r13, %r13
je 0x331e2
movl $0x100, %ecx # imm = 0x100
movq %r14, %rax
cqto
idivq %rcx
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
movq %rax, 0x70(%rsp)
testq %rbx, %rbx
movl $0x0, %eax
cmovgq %rbx, %rax
movq %rax, 0x50(%rsp)
leaq 0x8(%r12), %rax
movq %rbx, 0x40(%rsp)
movq %r14, 0x38(%rsp)
cmpq 0x50(%rsp), %rcx
je 0x331f4
movq %rcx, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movq %rax, %r8
movq 0x48(%rsp), %rbx
xorl %edi, %edi
movq %r15, %r14
movq %r12, 0x20(%rsp)
movq %r15, 0x68(%rsp)
cmpq 0x70(%rsp), %rdi
je 0x331b4
xorps %xmm1, %xmm1
xorl %eax, %eax
cmpq $0x100, %rax # imm = 0x100
je 0x32e57
movss (%r14,%rax,4), %xmm0
mulss %xmm0, %xmm0
addss %xmm0, %xmm1
incq %rax
jmp 0x32e3c
movq %r8, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
addss %xmm1, %xmm1
mulss 0x1c6d3(%rip), %xmm1 # 0x4f540
ucomiss 0x1c6a4(%rip), %xmm1 # 0x4f518
movss %xmm1, 0x10(%rsp)
jae 0x32e8a
movaps %xmm1, %xmm0
callq 0x1ead0
movss 0x10(%rsp), %xmm1
movq %rbx, 0x78(%rsp)
movq %rbx, %r15
movq %r14, %r12
xorl %r13d, %r13d
cmpq $0x8, %r13
je 0x32f79
movq %r13, %rbx
shlq $0x5, %rbx
xorl %ebp, %ebp
cmpq $0x20, %rbp
je 0x32efd
movss (%r15,%rbp,4), %xmm2
movss (%r12,%rbp,4), %xmm0
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
ucomiss 0x1c64c(%rip), %xmm0 # 0x4f518
jb 0x32ed4
sqrtss %xmm0, %xmm0
jmp 0x32eeb
movss %xmm2, 0xc(%rsp)
callq 0x1ead0
movss 0xc(%rsp), %xmm2
movss 0x10(%rsp), %xmm1
mulss %xmm0, %xmm2
movss %xmm2, 0x110(%rsp,%rbp,4)
incq %rbp
jmp 0x32eab
xorps %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x20, %rax
je 0x32f16
addss 0x110(%rsp,%rax,4), %xmm0
incq %rax
jmp 0x32f02
movss %xmm0, 0xd0(%rsp,%r13,4)
leaq (%r14,%rbx,4), %rdx
leaq (%rsp,%rbx), %r8
addq $0x190, %r8 # imm = 0x190
leaq 0xb0(%rsp,%r13,4), %r9
leaq 0xf0(%rsp), %rax
movq %rax, (%rsp)
pushq $0x20
popq %rdi
pushq $0xf
popq %rsi
leaq 0x110(%rsp), %rcx
callq 0x3d0a1
movss 0x10(%rsp), %xmm1
movss %xmm0, 0x90(%rsp,%r13,4)
incq %r13
movl $0x80, %eax
addq %rax, %r12
addq %rax, %r15
jmp 0x32e98
pushq $0x8
popq %rbx
movl %ebx, %edi
pushq $0x3f
popq %rbp
movl %ebp, %esi
leaq 0x90(%rsp), %rdx
leaq 0x88(%rsp), %rcx
leaq 0xd0(%rsp), %r15
movq %r15, %r8
callq 0x3d417
movss %xmm0, 0xc(%rsp)
movl %ebx, %edi
movl %ebp, %esi
leaq 0xb0(%rsp), %rdx
leaq 0x80(%rsp), %rcx
movq %r15, %r8
callq 0x3d417
movss %xmm0, 0x10(%rsp)
xorl %eax, %eax
movq 0x20(%rsp), %rbx
movq %r14, %rbp
movq 0x28(%rsp), %r8
cmpq $0x8, %rax
je 0x3302d
movb 0x88(%rsp,%rax), %dl
movb 0x80(%rsp,%rax), %cl
cmpq $0x3, %rax
ja 0x32fff
movb %dl, -0x4(%r8,%rax)
movb %cl, (%r8,%rax)
jmp 0x33028
movl %edx, %esi
andb $0xf, %sil
movl %ecx, %edi
shlb $0x4, %dil
orb %sil, %dil
movb %dil, (%r8,%rax)
shlb $0x2, %dl
andb $-0x40, %dl
orb %dl, -0x8(%r8,%rax)
shlb $0x2, %cl
andb $-0x40, %cl
orb %cl, -0x4(%r8,%rax)
incq %rax
jmp 0x32fda
movss 0xc(%rsp), %xmm0
callq 0x30512
movl %eax, %r13d
imulq $0x90, 0x30(%rsp), %rax
leaq (%rbx,%rax), %r15
leaq (%rbx,%rax), %r12
addq $0x4, %r12
movw %r13w, -0x4(%r12)
movss 0x10(%rsp), %xmm0
callq 0x30512
movw %ax, -0x2(%r12)
movzwl %r13w, %ecx
movq 0x39f36(%rip), %rdx # 0x6cfa8
movss (%rdx,%rcx,4), %xmm0
movss %xmm0, 0xc(%rsp)
movzwl %ax, %eax
movq %rax, 0x10(%rsp)
leaq 0x190(%rsp), %rbx
xorl %r13d, %r13d
cmpq $0x8, %r13
je 0x3313e
movl %r13d, %edi
movq %r12, %rsi
leaq 0xb(%rsp), %rdx
leaq 0xa(%rsp), %rcx
callq 0x32b8b
movzbl 0xb(%rsp), %eax
cvtsi2ss %eax, %xmm0
mulss 0xc(%rsp), %xmm0
ucomiss 0x1c453(%rip), %xmm0 # 0x4f518
jne 0x330c9
jnp 0x3312e
movzbl 0xa(%rsp), %eax
cvtsi2ss %eax, %xmm1
movq 0x39ecf(%rip), %rax # 0x6cfa8
movq 0x10(%rsp), %rcx
mulss (%rax,%rcx,4), %xmm1
xorl %eax, %eax
cmpq $0x20, %rax
je 0x3312e
movss (%rbp,%rax,4), %xmm2
addss %xmm1, %xmm2
divss %xmm0, %xmm2
addss 0x1c437(%rip), %xmm2 # 0x4f538
movd %xmm2, %ecx
andl $0x7fffff, %ecx # imm = 0x7FFFFF
movl $0x40000f, %edx # imm = 0x40000F
cmpl %edx, %ecx
jb 0x33119
movl $0x40000f, %ecx # imm = 0x40000F
cmpl $0x400001, %ecx # imm = 0x400001
jae 0x33126
movl $0x400000, %ecx # imm = 0x400000
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x330e5
incq %r13
subq $-0x80, %rbp
addq $0x20, %rbx
jmp 0x33090
addq $0x10, %r15
leaq 0x1b0(%rsp), %rax
xorl %ecx, %ecx
movq 0x20(%rsp), %r12
movq 0x78(%rsp), %rbx
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %r8
cmpq $0xff, %rcx
ja 0x33195
xorl %edx, %edx
cmpq $0x20, %rdx
je 0x33187
movb (%rax,%rdx), %sil
shlb $0x4, %sil
orb -0x20(%rax,%rdx), %sil
movb %sil, (%r15,%rdx)
incq %rdx
jmp 0x3316b
addq $0x20, %r15
addq $0x40, %rcx
addq $0x40, %rax
jmp 0x33160
movl $0x400, %eax # imm = 0x400
addq %rax, %r14
incq %rdi
addq %rax, %rbx
addq $0x90, %r8
movq 0x68(%rsp), %r15
jmp 0x32e2c
movq 0x38(%rsp), %r14
leaq (%r15,%r14,4), %r15
movq 0x18(%rsp), %rax
addq %rax, %r12
movq 0x60(%rsp), %rcx
incq %rcx
movq 0x58(%rsp), %rdx
addq %rax, %rdx
movq %rdx, %rax
movq 0x40(%rsp), %rbx
jmp 0x32e00
imulq %rbx, %r14
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1ee20
movq 0x18(%rsp), %rax
imulq %rbx, %rax
addq $0x298, %rsp # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
quantize_q4_K:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 298h
mov r13, r8
mov r14, rcx
mov rbx, rdx
mov r12, rsi
mov r15, rdi
push 0Ch
pop rdi
mov rsi, rcx
call _ggml_row_size
mov [rsp+2C8h+var_2B0], rax
mov [rsp+2C8h+var_280], r13
test r13, r13
jz loc_331E2
mov ecx, 100h
mov rax, r14
cqo
idiv rcx
xor ecx, ecx
test rax, rax
cmovle rax, rcx
mov [rsp+2C8h+var_258], rax
test rbx, rbx
mov eax, 0
cmovg rax, rbx
mov [rsp+2C8h+var_278], rax
lea rax, [r12+8]
mov [rsp+2C8h+var_288], rbx
mov [rsp+2C8h+var_290], r14
loc_32E00:
cmp rcx, [rsp+2C8h+var_278]
jz loc_331F4
mov [rsp+2C8h+var_268], rcx
mov [rsp+2C8h+var_270], rax
mov r8, rax
mov rbx, [rsp+2C8h+var_280]
xor edi, edi
mov r14, r15
mov [rsp+2C8h+var_2A8], r12
mov [rsp+2C8h+var_260], r15
loc_32E2C:
cmp rdi, [rsp+2C8h+var_258]
jz loc_331B4
xorps xmm1, xmm1
xor eax, eax
loc_32E3C:
cmp rax, 100h
jz short loc_32E57
movss xmm0, dword ptr [r14+rax*4]
mulss xmm0, xmm0
addss xmm1, xmm0
inc rax
jmp short loc_32E3C
loc_32E57:
mov [rsp+2C8h+var_2A0], r8
mov [rsp+2C8h+var_298], rdi
addss xmm1, xmm1
mulss xmm1, cs:dword_4F540
ucomiss xmm1, cs:dword_4F518
movss dword ptr [rsp+2C8h+var_2B8], xmm1
jnb short loc_32E8A
movaps xmm0, xmm1
call _sqrtf
movss xmm1, dword ptr [rsp+2C8h+var_2B8]
loc_32E8A:
mov [rsp+2C8h+var_250], rbx
mov r15, rbx
mov r12, r14
xor r13d, r13d
loc_32E98:
cmp r13, 8
jz loc_32F79
mov rbx, r13
shl rbx, 5
xor ebp, ebp
loc_32EAB:
cmp rbp, 20h ; ' '
jz short loc_32EFD
movss xmm2, dword ptr [r15+rbp*4]
movss xmm0, dword ptr [r12+rbp*4]
mulss xmm0, xmm0
addss xmm0, xmm1
ucomiss xmm0, cs:dword_4F518
jb short loc_32ED4
sqrtss xmm0, xmm0
jmp short loc_32EEB
loc_32ED4:
movss [rsp+2C8h+var_2BC], xmm2
call _sqrtf
movss xmm2, [rsp+2C8h+var_2BC]
movss xmm1, dword ptr [rsp+2C8h+var_2B8]
loc_32EEB:
mulss xmm2, xmm0
movss [rsp+rbp*4+2C8h+var_1B8], xmm2
inc rbp
jmp short loc_32EAB
loc_32EFD:
xorps xmm0, xmm0
xor eax, eax
loc_32F02:
cmp rax, 20h ; ' '
jz short loc_32F16
addss xmm0, [rsp+rax*4+2C8h+var_1B8]
inc rax
jmp short loc_32F02
loc_32F16:
movss [rsp+r13*4+2C8h+var_1F8], xmm0
lea rdx, [r14+rbx*4]
lea r8, [rsp+rbx+2C8h+var_2C8]
add r8, 190h
lea r9, [rsp+r13*4+2C8h+var_218]
lea rax, [rsp+2C8h+var_1D8]
mov [rsp+2C8h+var_2C8], rax
push 20h ; ' '
pop rdi
push 0Fh
pop rsi
lea rcx, [rsp+2C8h+var_1B8]
call make_qkx3_quants
movss xmm1, dword ptr [rsp+2C8h+var_2B8]
movss [rsp+r13*4+2C8h+var_238], xmm0
inc r13
mov eax, 80h
add r12, rax
add r15, rax
jmp loc_32E98
loc_32F79:
push 8
pop rbx
mov edi, ebx
push 3Fh ; '?'
pop rbp
mov esi, ebp
lea rdx, [rsp+2C8h+var_238]
lea rcx, [rsp+2C8h+var_240]
lea r15, [rsp+2C8h+var_1F8]
mov r8, r15
call make_qp_quants
movss [rsp+2C8h+var_2BC], xmm0
mov edi, ebx
mov esi, ebp
lea rdx, [rsp+2C8h+var_218]
lea rcx, [rsp+2C8h+var_248]
mov r8, r15
call make_qp_quants
movss dword ptr [rsp+2C8h+var_2B8], xmm0
xor eax, eax
mov rbx, [rsp+2C8h+var_2A8]
mov rbp, r14
mov r8, [rsp+2C8h+var_2A0]
loc_32FDA:
cmp rax, 8
jz short loc_3302D
mov dl, [rsp+rax+2C8h+var_240]
mov cl, [rsp+rax+2C8h+var_248]
cmp rax, 3
ja short loc_32FFF
mov [r8+rax-4], dl
mov [r8+rax], cl
jmp short loc_33028
loc_32FFF:
mov esi, edx
and sil, 0Fh
mov edi, ecx
shl dil, 4
or dil, sil
mov [r8+rax], dil
shl dl, 2
and dl, 0C0h
or [r8+rax-8], dl
shl cl, 2
and cl, 0C0h
or [r8+rax-4], cl
loc_33028:
inc rax
jmp short loc_32FDA
loc_3302D:
movss xmm0, [rsp+2C8h+var_2BC]
call ggml_compute_fp32_to_fp16_0
mov r13d, eax
imul rax, [rsp+2C8h+var_298], 90h
lea r15, [rbx+rax]
lea r12, [rbx+rax]
add r12, 4
mov [r12-4], r13w
movss xmm0, dword ptr [rsp+2C8h+var_2B8]
call ggml_compute_fp32_to_fp16_0
mov [r12-2], ax
movzx ecx, r13w
mov rdx, cs:ggml_table_f32_f16_ptr
movss xmm0, dword ptr [rdx+rcx*4]
movss [rsp+2C8h+var_2BC], xmm0
movzx eax, ax
mov [rsp+2C8h+var_2B8], rax
lea rbx, [rsp+2C8h+var_138]
xor r13d, r13d
loc_33090:
cmp r13, 8
jz loc_3313E
mov edi, r13d
mov rsi, r12
lea rdx, [rsp+2C8h+var_2BD]
lea rcx, [rsp+2C8h+var_2BE]
call get_scale_min_k4
movzx eax, [rsp+2C8h+var_2BD]
cvtsi2ss xmm0, eax
mulss xmm0, [rsp+2C8h+var_2BC]
ucomiss xmm0, cs:dword_4F518
jnz short loc_330C9
jnp short loc_3312E
loc_330C9:
movzx eax, [rsp+2C8h+var_2BE]
cvtsi2ss xmm1, eax
mov rax, cs:ggml_table_f32_f16_ptr
mov rcx, [rsp+2C8h+var_2B8]
mulss xmm1, dword ptr [rax+rcx*4]
xor eax, eax
loc_330E5:
cmp rax, 20h ; ' '
jz short loc_3312E
movss xmm2, dword ptr [rbp+rax*4+0]
addss xmm2, xmm1
divss xmm2, xmm0
addss xmm2, cs:dword_4F538
movd ecx, xmm2
and ecx, 7FFFFFh
mov edx, 40000Fh
cmp ecx, edx
jb short loc_33119
mov ecx, 40000Fh
loc_33119:
cmp ecx, 400001h
jnb short loc_33126
mov ecx, 400000h
loc_33126:
mov [rbx+rax], cl
inc rax
jmp short loc_330E5
loc_3312E:
inc r13
sub rbp, 0FFFFFFFFFFFFFF80h
add rbx, 20h ; ' '
jmp loc_33090
loc_3313E:
add r15, 10h
lea rax, [rsp+2C8h+var_118]
xor ecx, ecx
mov r12, [rsp+2C8h+var_2A8]
mov rbx, [rsp+2C8h+var_250]
mov rdi, [rsp+2C8h+var_298]
mov r8, [rsp+2C8h+var_2A0]
loc_33160:
cmp rcx, 0FFh
ja short loc_33195
xor edx, edx
loc_3316B:
cmp rdx, 20h ; ' '
jz short loc_33187
mov sil, [rax+rdx]
shl sil, 4
or sil, [rax+rdx-20h]
mov [r15+rdx], sil
inc rdx
jmp short loc_3316B
loc_33187:
add r15, 20h ; ' '
add rcx, 40h ; '@'
add rax, 40h ; '@'
jmp short loc_33160
loc_33195:
mov eax, 400h
add r14, rax
inc rdi
add rbx, rax
add r8, 90h
mov r15, [rsp+2C8h+var_260]
jmp loc_32E2C
loc_331B4:
mov r14, [rsp+2C8h+var_290]
lea r15, [r15+r14*4]
mov rax, [rsp+2C8h+var_2B0]
add r12, rax
mov rcx, [rsp+2C8h+var_268]
inc rcx
mov rdx, [rsp+2C8h+var_270]
add rdx, rax
mov rax, rdx
mov rbx, [rsp+2C8h+var_288]
jmp loc_32E00
loc_331E2:
imul r14, rbx
mov rdi, r15
mov rsi, r12
mov rdx, r14
call _quantize_row_q4_K_ref
loc_331F4:
mov rax, [rsp+2C8h+var_2B0]
imul rax, rbx
add rsp, 298h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long quantize_q4_K(long long a1, long long a2, long long a3, long long a4, long long a5, double a6)
{
long long v10; // r15
long long v11; // rsi
long long v12; // rax
long long jj; // rdx
long long v14; // rcx
long long v15; // rax
long long v16; // rax
long long v17; // r8
long long v18; // rbx
long long v19; // rdi
long long v20; // r14
double v21; // xmm1_8
long long i; // rax
long long v23; // r15
long long v24; // r12
long long j; // r13
long long k; // rbp
float v27; // xmm2_4
float v28; // xmm0_4
long long m; // rax
unsigned int v30; // edx
unsigned long long v31; // rax
long long v32; // rbx
long long v33; // rbp
long long v34; // r8
char v35; // cl
unsigned __int16 v36; // r13
unsigned __int16 *v37; // r15
unsigned __int16 v38; // ax
_OWORD *v39; // rbx
long long n; // r13
float v41; // xmm1_4
long long ii; // rax
__m128i v43; // xmm2
unsigned int v44; // ecx
_WORD *v45; // r15
char *v46; // rax
unsigned long long v47; // rcx
long long v48; // rbx
long long v49; // rdi
long long v50; // r8
unsigned __int8 v52; // [rsp+Ah] [rbp-2BEh] BYREF
unsigned __int8 v53; // [rsp+Bh] [rbp-2BDh] BYREF
float v54; // [rsp+Ch] [rbp-2BCh]
long long v55; // [rsp+10h] [rbp-2B8h]
unsigned long long v56; // [rsp+18h] [rbp-2B0h]
long long v57; // [rsp+20h] [rbp-2A8h]
long long v58; // [rsp+28h] [rbp-2A0h]
long long v59; // [rsp+30h] [rbp-298h]
long long v60; // [rsp+38h] [rbp-290h]
long long v61; // [rsp+40h] [rbp-288h]
long long v62; // [rsp+48h] [rbp-280h]
long long v63; // [rsp+50h] [rbp-278h]
long long v64; // [rsp+58h] [rbp-270h]
long long v65; // [rsp+60h] [rbp-268h]
long long v66; // [rsp+68h] [rbp-260h]
long long v67; // [rsp+70h] [rbp-258h]
long long v68; // [rsp+78h] [rbp-250h]
_BYTE v69[8]; // [rsp+80h] [rbp-248h] BYREF
_BYTE v70[8]; // [rsp+88h] [rbp-240h] BYREF
_DWORD v71[8]; // [rsp+90h] [rbp-238h] BYREF
_DWORD v72[8]; // [rsp+B0h] [rbp-218h] BYREF
_DWORD v73[8]; // [rsp+D0h] [rbp-1F8h] BYREF
char v74[32]; // [rsp+F0h] [rbp-1D8h] BYREF
float v75[32]; // [rsp+110h] [rbp-1B8h] BYREF
_OWORD v76[2]; // [rsp+190h] [rbp-138h] BYREF
char v77; // [rsp+1B0h] [rbp-118h] BYREF
v10 = a1;
v11 = a4;
v56 = ggml_row_size(0xCu, a4);
v62 = a5;
if ( a5 )
{
v12 = a4 / 256;
jj = a4 % 256;
v14 = 0LL;
if ( a4 / 256 <= 0 )
v12 = 0LL;
v67 = v12;
v15 = 0LL;
if ( a3 > 0 )
v15 = a3;
v63 = v15;
v16 = a2 + 8;
v61 = a3;
v60 = a4;
while ( v14 != v63 )
{
v65 = v14;
v64 = v16;
v17 = v16;
v18 = v62;
v19 = 0LL;
v20 = v10;
v57 = a2;
v66 = v10;
while ( v19 != v67 )
{
v21 = 0.0;
for ( i = 0LL; i != 256; ++i )
{
*(_QWORD *)&a6 = *(unsigned int *)(v20 + 4 * i);
*(float *)&a6 = *(float *)&a6 * *(float *)&a6;
*(float *)&v21 = *(float *)&v21 + *(float *)&a6;
}
v58 = v17;
v59 = v19;
*(float *)&v21 = (float)(*(float *)&v21 + *(float *)&v21) * 0.00390625;
LODWORD(v55) = LODWORD(v21);
if ( *(float *)&v21 < 0.0 )
{
a6 = v21;
sqrtf(v19, v11, jj);
*(_QWORD *)&v21 = (unsigned int)v55;
}
v68 = v18;
v23 = v18;
v24 = v20;
for ( j = 0LL; j != 8; ++j )
{
for ( k = 0LL; k != 32; ++k )
{
v27 = *(float *)(v23 + 4 * k);
v28 = (float)(*(float *)(v24 + 4 * k) * *(float *)(v24 + 4 * k)) + *(float *)&v21;
if ( v28 < 0.0 )
{
v54 = *(float *)(v23 + 4 * k);
sqrtf(v19, v11, jj);
v27 = v54;
LODWORD(v21) = v55;
}
else
{
v28 = fsqrt(v28);
}
v75[k] = v27 * v28;
}
a6 = 0.0;
for ( m = 0LL; m != 32; ++m )
*(float *)&a6 = *(float *)&a6 + v75[m];
v73[j] = LODWORD(a6);
v19 = 32LL;
v11 = 15LL;
make_qkx3_quants(
32,
15,
v20 + ((_DWORD)j << 7),
(unsigned int)v75,
(unsigned int)&v76[2 * j],
(unsigned int)&v72[j],
(long long)v74);
*(_QWORD *)&v21 = (unsigned int)v55;
v71[j] = LODWORD(a6);
v24 += 128LL;
v23 += 128LL;
}
*(float *)&a6 = make_qp_quants(8LL, 63LL, v71, v70, v73, a6, v21);
v54 = *(float *)&a6;
v11 = 63LL;
LODWORD(v55) = make_qp_quants(8LL, 63LL, v72, v69, v73, a6, v21);
v31 = 0LL;
v32 = v57;
v33 = v20;
v34 = v58;
while ( v31 != 8 )
{
LOBYTE(v30) = v70[v31];
v35 = v69[v31];
if ( v31 > 3 )
{
v11 = v30;
LOBYTE(v11) = v30 & 0xF;
*(_BYTE *)(v34 + v31) = v30 & 0xF | (16 * v35);
*(_BYTE *)(v34 + v31 - 8) |= (4 * v30) & 0xC0;
*(_BYTE *)(v34 + v31 - 4) |= (4 * v35) & 0xC0;
}
else
{
*(_BYTE *)(v34 + v31 - 4) = v30;
*(_BYTE *)(v34 + v31) = v35;
}
++v31;
}
v36 = ggml_compute_fp32_to_fp16_0((__m128i)LODWORD(v54));
v37 = (unsigned __int16 *)(v32 + 144 * v59);
*v37 = v36;
v38 = ggml_compute_fp32_to_fp16_0((__m128i)(unsigned int)v55);
v37[1] = v38;
jj = (long long)ggml_table_f32_f16;
*(_QWORD *)&a6 = LODWORD(ggml_table_f32_f16[v36]);
v54 = ggml_table_f32_f16[v36];
v55 = v38;
v39 = v76;
for ( n = 0LL; n != 8; ++n )
{
v11 = (long long)(v37 + 2);
get_scale_min_k4(n, (long long)(v37 + 2), &v53, &v52);
*(float *)&a6 = (float)v53 * v54;
if ( *(float *)&a6 != 0.0 )
{
v41 = (float)v52 * ggml_table_f32_f16[v55];
for ( ii = 0LL; ii != 32; ++ii )
{
v43 = (__m128i)*(unsigned int *)(v33 + 4 * ii);
*(float *)v43.m128i_i32 = (float)((float)(*(float *)v43.m128i_i32 + v41) / *(float *)&a6) + 12582912.0;
v44 = _mm_cvtsi128_si32(v43) & 0x7FFFFF;
jj = 4194319LL;
if ( v44 >= 0x40000F )
v44 = 4194319;
if ( v44 < 0x400001 )
LOBYTE(v44) = 0;
*((_BYTE *)v39 + ii) = v44;
}
}
v33 += 128LL;
v39 += 2;
}
v45 = v37 + 8;
v46 = &v77;
v47 = 0LL;
a2 = v57;
v48 = v68;
v49 = v59;
v50 = v58;
while ( v47 <= 0xFF )
{
for ( jj = 0LL; jj != 32; ++jj )
{
LOBYTE(v11) = v46[jj - 32] | (16 * v46[jj]);
*((_BYTE *)v45 + jj) = v11;
}
v45 += 16;
v47 += 64LL;
v46 += 64;
}
v20 += 1024LL;
v19 = v49 + 1;
v18 = v48 + 1024;
v17 = v50 + 144;
v10 = v66;
}
v10 += 4 * v60;
a2 += v56;
v14 = v65 + 1;
jj = v56 + v64;
v16 = v56 + v64;
a3 = v61;
}
}
else
{
quantize_row_q4_K_ref(a1, a2, a3 * a4);
}
return a3 * v56;
}
|
quantize_q4_K:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x298
MOV R13,R8
MOV R14,RCX
MOV RBX,RDX
MOV R12,RSI
MOV R15,RDI
PUSH 0xc
POP RDI
MOV RSI,RCX
CALL 0x0011e1a0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x48],R13
TEST R13,R13
JZ 0x001331e2
MOV ECX,0x100
MOV RAX,R14
CQO
IDIV RCX
XOR ECX,ECX
TEST RAX,RAX
CMOVLE RAX,RCX
MOV qword ptr [RSP + 0x70],RAX
TEST RBX,RBX
MOV EAX,0x0
CMOVG RAX,RBX
MOV qword ptr [RSP + 0x50],RAX
LEA RAX,[R12 + 0x8]
MOV qword ptr [RSP + 0x40],RBX
MOV qword ptr [RSP + 0x38],R14
LAB_00132e00:
CMP RCX,qword ptr [RSP + 0x50]
JZ 0x001331f4
MOV qword ptr [RSP + 0x60],RCX
MOV qword ptr [RSP + 0x58],RAX
MOV R8,RAX
MOV RBX,qword ptr [RSP + 0x48]
XOR EDI,EDI
MOV R14,R15
MOV qword ptr [RSP + 0x20],R12
MOV qword ptr [RSP + 0x68],R15
LAB_00132e2c:
CMP RDI,qword ptr [RSP + 0x70]
JZ 0x001331b4
XORPS XMM1,XMM1
XOR EAX,EAX
LAB_00132e3c:
CMP RAX,0x100
JZ 0x00132e57
MOVSS XMM0,dword ptr [R14 + RAX*0x4]
MULSS XMM0,XMM0
ADDSS XMM1,XMM0
INC RAX
JMP 0x00132e3c
LAB_00132e57:
MOV qword ptr [RSP + 0x28],R8
MOV qword ptr [RSP + 0x30],RDI
ADDSS XMM1,XMM1
MULSS XMM1,dword ptr [0x0014f540]
UCOMISS XMM1,dword ptr [0x0014f518]
MOVSS dword ptr [RSP + 0x10],XMM1
JNC 0x00132e8a
MOVAPS XMM0,XMM1
CALL 0x0011ead0
MOVSS XMM1,dword ptr [RSP + 0x10]
LAB_00132e8a:
MOV qword ptr [RSP + 0x78],RBX
MOV R15,RBX
MOV R12,R14
XOR R13D,R13D
LAB_00132e98:
CMP R13,0x8
JZ 0x00132f79
MOV RBX,R13
SHL RBX,0x5
XOR EBP,EBP
LAB_00132eab:
CMP RBP,0x20
JZ 0x00132efd
MOVSS XMM2,dword ptr [R15 + RBP*0x4]
MOVSS XMM0,dword ptr [R12 + RBP*0x4]
MULSS XMM0,XMM0
ADDSS XMM0,XMM1
UCOMISS XMM0,dword ptr [0x0014f518]
JC 0x00132ed4
SQRTSS XMM0,XMM0
JMP 0x00132eeb
LAB_00132ed4:
MOVSS dword ptr [RSP + 0xc],XMM2
CALL 0x0011ead0
MOVSS XMM2,dword ptr [RSP + 0xc]
MOVSS XMM1,dword ptr [RSP + 0x10]
LAB_00132eeb:
MULSS XMM2,XMM0
MOVSS dword ptr [RSP + RBP*0x4 + 0x110],XMM2
INC RBP
JMP 0x00132eab
LAB_00132efd:
XORPS XMM0,XMM0
XOR EAX,EAX
LAB_00132f02:
CMP RAX,0x20
JZ 0x00132f16
ADDSS XMM0,dword ptr [RSP + RAX*0x4 + 0x110]
INC RAX
JMP 0x00132f02
LAB_00132f16:
MOVSS dword ptr [RSP + R13*0x4 + 0xd0],XMM0
LEA RDX,[R14 + RBX*0x4]
LEA R8,[RSP + RBX*0x1]
ADD R8,0x190
LEA R9,[RSP + R13*0x4 + 0xb0]
LEA RAX,[RSP + 0xf0]
MOV qword ptr [RSP],RAX
PUSH 0x20
POP RDI
PUSH 0xf
POP RSI
LEA RCX,[RSP + 0x110]
CALL 0x0013d0a1
MOVSS XMM1,dword ptr [RSP + 0x10]
MOVSS dword ptr [RSP + R13*0x4 + 0x90],XMM0
INC R13
MOV EAX,0x80
ADD R12,RAX
ADD R15,RAX
JMP 0x00132e98
LAB_00132f79:
PUSH 0x8
POP RBX
MOV EDI,EBX
PUSH 0x3f
POP RBP
MOV ESI,EBP
LEA RDX,[RSP + 0x90]
LEA RCX,[RSP + 0x88]
LEA R15,[RSP + 0xd0]
MOV R8,R15
CALL 0x0013d417
MOVSS dword ptr [RSP + 0xc],XMM0
MOV EDI,EBX
MOV ESI,EBP
LEA RDX,[RSP + 0xb0]
LEA RCX,[RSP + 0x80]
MOV R8,R15
CALL 0x0013d417
MOVSS dword ptr [RSP + 0x10],XMM0
XOR EAX,EAX
MOV RBX,qword ptr [RSP + 0x20]
MOV RBP,R14
MOV R8,qword ptr [RSP + 0x28]
LAB_00132fda:
CMP RAX,0x8
JZ 0x0013302d
MOV DL,byte ptr [RSP + RAX*0x1 + 0x88]
MOV CL,byte ptr [RSP + RAX*0x1 + 0x80]
CMP RAX,0x3
JA 0x00132fff
MOV byte ptr [R8 + RAX*0x1 + -0x4],DL
MOV byte ptr [R8 + RAX*0x1],CL
JMP 0x00133028
LAB_00132fff:
MOV ESI,EDX
AND SIL,0xf
MOV EDI,ECX
SHL DIL,0x4
OR DIL,SIL
MOV byte ptr [R8 + RAX*0x1],DIL
SHL DL,0x2
AND DL,0xc0
OR byte ptr [R8 + RAX*0x1 + -0x8],DL
SHL CL,0x2
AND CL,0xc0
OR byte ptr [R8 + RAX*0x1 + -0x4],CL
LAB_00133028:
INC RAX
JMP 0x00132fda
LAB_0013302d:
MOVSS XMM0,dword ptr [RSP + 0xc]
CALL 0x00130512
MOV R13D,EAX
IMUL RAX,qword ptr [RSP + 0x30],0x90
LEA R15,[RBX + RAX*0x1]
LEA R12,[RBX + RAX*0x1]
ADD R12,0x4
MOV word ptr [R12 + -0x4],R13W
MOVSS XMM0,dword ptr [RSP + 0x10]
CALL 0x00130512
MOV word ptr [R12 + -0x2],AX
MOVZX ECX,R13W
MOV RDX,qword ptr [0x0016cfa8]
MOVSS XMM0,dword ptr [RDX + RCX*0x4]
MOVSS dword ptr [RSP + 0xc],XMM0
MOVZX EAX,AX
MOV qword ptr [RSP + 0x10],RAX
LEA RBX,[RSP + 0x190]
XOR R13D,R13D
LAB_00133090:
CMP R13,0x8
JZ 0x0013313e
MOV EDI,R13D
MOV RSI,R12
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0xa]
CALL 0x00132b8b
MOVZX EAX,byte ptr [RSP + 0xb]
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RSP + 0xc]
UCOMISS XMM0,dword ptr [0x0014f518]
JNZ 0x001330c9
JNP 0x0013312e
LAB_001330c9:
MOVZX EAX,byte ptr [RSP + 0xa]
CVTSI2SS XMM1,EAX
MOV RAX,qword ptr [0x0016cfa8]
MOV RCX,qword ptr [RSP + 0x10]
MULSS XMM1,dword ptr [RAX + RCX*0x4]
XOR EAX,EAX
LAB_001330e5:
CMP RAX,0x20
JZ 0x0013312e
MOVSS XMM2,dword ptr [RBP + RAX*0x4]
ADDSS XMM2,XMM1
DIVSS XMM2,XMM0
ADDSS XMM2,dword ptr [0x0014f538]
MOVD ECX,XMM2
AND ECX,0x7fffff
MOV EDX,0x40000f
CMP ECX,EDX
JC 0x00133119
MOV ECX,0x40000f
LAB_00133119:
CMP ECX,0x400001
JNC 0x00133126
MOV ECX,0x400000
LAB_00133126:
MOV byte ptr [RBX + RAX*0x1],CL
INC RAX
JMP 0x001330e5
LAB_0013312e:
INC R13
SUB RBP,-0x80
ADD RBX,0x20
JMP 0x00133090
LAB_0013313e:
ADD R15,0x10
LEA RAX,[RSP + 0x1b0]
XOR ECX,ECX
MOV R12,qword ptr [RSP + 0x20]
MOV RBX,qword ptr [RSP + 0x78]
MOV RDI,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x28]
LAB_00133160:
CMP RCX,0xff
JA 0x00133195
XOR EDX,EDX
LAB_0013316b:
CMP RDX,0x20
JZ 0x00133187
MOV SIL,byte ptr [RAX + RDX*0x1]
SHL SIL,0x4
OR SIL,byte ptr [RAX + RDX*0x1 + -0x20]
MOV byte ptr [R15 + RDX*0x1],SIL
INC RDX
JMP 0x0013316b
LAB_00133187:
ADD R15,0x20
ADD RCX,0x40
ADD RAX,0x40
JMP 0x00133160
LAB_00133195:
MOV EAX,0x400
ADD R14,RAX
INC RDI
ADD RBX,RAX
ADD R8,0x90
MOV R15,qword ptr [RSP + 0x68]
JMP 0x00132e2c
LAB_001331b4:
MOV R14,qword ptr [RSP + 0x38]
LEA R15,[R15 + R14*0x4]
MOV RAX,qword ptr [RSP + 0x18]
ADD R12,RAX
MOV RCX,qword ptr [RSP + 0x60]
INC RCX
MOV RDX,qword ptr [RSP + 0x58]
ADD RDX,RAX
MOV RAX,RDX
MOV RBX,qword ptr [RSP + 0x40]
JMP 0x00132e00
LAB_001331e2:
IMUL R14,RBX
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
CALL 0x0011ee20
LAB_001331f4:
MOV RAX,qword ptr [RSP + 0x18]
IMUL RAX,RBX
ADD RSP,0x298
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
long quantize_q4_K(long param_1,long param_2,long param_3,long param_4,long param_5)
{
ushort *puVar1;
byte *pbVar2;
byte bVar3;
byte bVar4;
ushort uVar5;
ushort uVar6;
long lVar7;
ulong uVar8;
uint uVar9;
int1 *puVar10;
long lVar11;
long lVar12;
long lVar13;
float fVar14;
int4 uVar15;
float fVar16;
float fVar17;
byte local_2be;
byte local_2bd;
float local_2bc;
ulong local_2b8;
long local_2b0;
long local_2a8;
long local_2a0;
long local_298;
long local_290;
long local_288;
long local_280;
long local_278;
long local_270;
long local_268;
long local_260;
long local_258;
long local_250;
byte local_248 [16];
int4 local_238 [8];
int1 local_218 [32];
float local_1f8 [8];
int1 local_1d8 [32];
float local_1b8 [32];
int1 local_138 [32];
int1 local_118 [232];
local_2b0 = ggml_row_size(0xc,param_4);
local_288 = param_3;
local_280 = param_5;
if (param_5 == 0) {
quantize_row_q4_K_ref(param_1,param_2,param_4 * param_3);
}
else {
local_268 = 0;
local_258 = param_4 / 0x100;
if (param_4 / 0x100 < 1) {
local_258 = local_268;
}
local_278 = 0;
if (0 < param_3) {
local_278 = param_3;
}
local_2a0 = param_2 + 8;
local_290 = param_4;
for (; local_268 != local_278; local_268 = local_268 + 1) {
lVar13 = local_280;
local_2a8 = param_2;
local_270 = local_2a0;
local_260 = param_1;
for (local_298 = 0; local_298 != local_258; local_298 = local_298 + 1) {
fVar16 = 0.0;
for (lVar7 = 0; lVar7 != 0x100; lVar7 = lVar7 + 1) {
fVar17 = *(float *)(param_1 + lVar7 * 4);
fVar16 = fVar16 + fVar17 * fVar17;
}
fVar16 = (fVar16 + fVar16) * _DAT_0014f540;
local_2b8 = CONCAT44(local_2b8._4_4_,fVar16);
if (fVar16 < DAT_0014f518) {
sqrtf(fVar16);
fVar16 = (float)local_2b8;
}
lVar7 = param_1;
local_250 = lVar13;
for (lVar12 = 0; lVar12 != 8; lVar12 = lVar12 + 1) {
for (lVar11 = 0; lVar11 != 0x20; lVar11 = lVar11 + 1) {
fVar17 = *(float *)(lVar13 + lVar11 * 4);
fVar14 = *(float *)(lVar7 + lVar11 * 4);
fVar14 = fVar14 * fVar14 + fVar16;
if (fVar14 < DAT_0014f518) {
local_2bc = fVar17;
fVar14 = sqrtf(fVar14);
fVar16 = (float)local_2b8;
fVar17 = local_2bc;
}
else {
fVar14 = SQRT(fVar14);
}
local_1b8[lVar11] = fVar17 * fVar14;
}
fVar16 = 0.0;
for (lVar11 = 0; lVar11 != 0x20; lVar11 = lVar11 + 1) {
fVar16 = fVar16 + local_1b8[lVar11];
}
local_1f8[lVar12] = fVar16;
uVar15 = make_qkx3_quants(0x20,0xf,param_1 + lVar12 * 0x80,local_1b8,
local_138 + lVar12 * 0x20,local_1f8 + lVar12 + -8,local_1d8);
local_238[lVar12] = uVar15;
lVar7 = lVar7 + 0x80;
lVar13 = lVar13 + 0x80;
fVar16 = (float)local_2b8;
}
local_2bc = (float)make_qp_quants(8,0x3f,local_238,local_248 + 8,local_1f8);
uVar15 = make_qp_quants(8,0x3f,local_218,local_248,local_1f8);
lVar13 = local_2a8;
local_2b8 = CONCAT44(local_2b8._4_4_,uVar15);
for (uVar8 = 0; uVar8 != 8; uVar8 = uVar8 + 1) {
bVar3 = local_248[uVar8 + 8];
bVar4 = local_248[uVar8];
if (uVar8 < 4) {
*(byte *)(local_2a0 + -4 + uVar8) = bVar3;
*(byte *)(local_2a0 + uVar8) = bVar4;
}
else {
*(byte *)(local_2a0 + uVar8) = bVar4 << 4 | bVar3 & 0xf;
pbVar2 = (byte *)(local_2a0 + -8 + uVar8);
*pbVar2 = *pbVar2 | (bVar3 & 0x30) << 2;
pbVar2 = (byte *)(local_2a0 + -4 + uVar8);
*pbVar2 = *pbVar2 | (bVar4 & 0x30) << 2;
}
}
uVar5 = ggml_compute_fp32_to_fp16(local_2bc);
lVar12 = local_298 * 0x90;
puVar1 = (ushort *)(lVar13 + lVar12);
*puVar1 = uVar5;
uVar6 = ggml_compute_fp32_to_fp16((float)local_2b8);
puVar1[1] = uVar6;
local_2bc = *(float *)(PTR_ggml_table_f32_f16_0016cfa8 + (ulong)uVar5 * 4);
local_2b8 = (ulong)uVar6;
puVar10 = local_138;
lVar7 = param_1;
for (uVar8 = 0; uVar8 != 8; uVar8 = uVar8 + 1) {
get_scale_min_k4(uVar8 & 0xffffffff,puVar1 + 2,&local_2bd);
fVar16 = (float)local_2bd * local_2bc;
if ((fVar16 != DAT_0014f518) || (NAN(fVar16) || NAN(DAT_0014f518))) {
fVar17 = *(float *)(PTR_ggml_table_f32_f16_0016cfa8 + local_2b8 * 4);
for (lVar11 = 0; lVar11 != 0x20; lVar11 = lVar11 + 1) {
uVar9 = (uint)((*(float *)(lVar7 + lVar11 * 4) + (float)local_2be * fVar17) / fVar16 +
DAT_0014f538) & 0x7fffff;
if (0x40000e < uVar9) {
uVar9 = 0x40000f;
}
if (uVar9 < 0x400001) {
uVar9 = 0;
}
puVar10[lVar11] = (char)uVar9;
}
}
lVar7 = lVar7 + 0x80;
puVar10 = puVar10 + 0x20;
}
lVar13 = lVar13 + lVar12 + 0x10;
puVar10 = local_118;
for (uVar8 = 0; uVar8 < 0x100; uVar8 = uVar8 + 0x40) {
for (lVar7 = 0; lVar7 != 0x20; lVar7 = lVar7 + 1) {
*(int1 *)(lVar13 + lVar7) = puVar10[lVar7] << 4 | puVar10[lVar7 + -0x20];
}
lVar13 = lVar13 + 0x20;
puVar10 = puVar10 + 0x40;
}
param_1 = param_1 + 0x400;
lVar13 = local_250 + 0x400;
local_2a0 = local_2a0 + 0x90;
}
param_1 = local_260 + local_290 * 4;
param_2 = local_2a8 + local_2b0;
local_2a0 = local_270 + local_2b0;
}
}
return local_2b0 * local_288;
}
|
|
11,364 |
js_is_fast_array
|
bluesky950520[P]quickjs/quickjs.c
|
static BOOL js_is_fast_array(JSContext *ctx, JSValue obj)
{
/* Try and handle fast arrays explicitly */
if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
JSObject *p = JS_VALUE_GET_OBJ(obj);
if (p->class_id == JS_CLASS_ARRAY && p->fast_array) {
return TRUE;
}
}
return FALSE;
}
|
O0
|
c
|
js_is_fast_array:
movq %rsi, -0x18(%rsp)
movq %rdx, -0x10(%rsp)
movq %rdi, -0x20(%rsp)
movq -0x10(%rsp), %rax
cmpl $-0x1, %eax
jne 0xcd952
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x2, %eax
jne 0xcd950
movq -0x28(%rsp), %rax
movb 0x5(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xcd950
movl $0x1, -0x4(%rsp)
jmp 0xcd95a
jmp 0xcd952
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
|
js_is_fast_array:
mov [rsp+var_18], rsi
mov [rsp+var_10], rdx
mov [rsp+var_20], rdi
mov rax, [rsp+var_10]
cmp eax, 0FFFFFFFFh
jnz short loc_CD952
mov rax, [rsp+var_18]
mov [rsp+var_28], rax
mov rax, [rsp+var_28]
movzx eax, word ptr [rax+6]
cmp eax, 2
jnz short loc_CD950
mov rax, [rsp+var_28]
mov al, [rax+5]
shr al, 3
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_CD950
mov [rsp+var_4], 1
jmp short loc_CD95A
loc_CD950:
jmp short $+2
loc_CD952:
mov [rsp+var_4], 0
loc_CD95A:
mov eax, [rsp+var_4]
retn
|
_BOOL8 js_is_fast_array(long long a1, long long a2, int a3)
{
return a3 == -1 && *(_WORD *)(a2 + 6) == 2 && (*(_BYTE *)(a2 + 5) & 8) != 0;
}
|
js_is_fast_array:
MOV qword ptr [RSP + -0x18],RSI
MOV qword ptr [RSP + -0x10],RDX
MOV qword ptr [RSP + -0x20],RDI
MOV RAX,qword ptr [RSP + -0x10]
CMP EAX,-0x1
JNZ 0x001cd952
MOV RAX,qword ptr [RSP + -0x18]
MOV qword ptr [RSP + -0x28],RAX
MOV RAX,qword ptr [RSP + -0x28]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x2
JNZ 0x001cd950
MOV RAX,qword ptr [RSP + -0x28]
MOV AL,byte ptr [RAX + 0x5]
SHR AL,0x3
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001cd950
MOV dword ptr [RSP + -0x4],0x1
JMP 0x001cd95a
LAB_001cd950:
JMP 0x001cd952
LAB_001cd952:
MOV dword ptr [RSP + -0x4],0x0
LAB_001cd95a:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
int4 js_is_fast_array(int8 param_1,long param_2,int param_3)
{
int4 local_4;
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 2)) &&
((*(byte *)(param_2 + 5) >> 3 & 1) != 0)) {
local_4 = 1;
}
else {
local_4 = 0;
}
return local_4;
}
|
|
11,365 |
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>>>::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::__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>*, std::vector<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>, 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>>>>, __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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>*, std::vector<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>, 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>>>>)
|
monkey531[P]llama/common/./json.hpp
|
iterator erase(iterator first, iterator last)
{
if (first == last)
{
return first;
}
const auto elements_affected = std::distance(first, last);
const auto offset = std::distance(Container::begin(), first);
// This is the start situation. We need to delete elements_affected
// elements (3 in this example: e, f, g), and need to return an
// iterator past the last deleted element (h in this example).
// Note that offset is the distance from the start of the vector
// to first. We will need this later.
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// first last
// Since we cannot move const Keys, we re-construct them in place.
// We start at first and re-construct (viz. copy) the elements from
// the back of the vector. Example for first iteration:
// ,--------.
// v | destroy e and re-construct with h
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// it it + elements_affected
for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
{
it->~value_type(); // destroy but keep allocation
new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
}
// [ a, b, c, d, h, i, j, h, i, j ]
// ^ ^
// first last
// remove the unneeded elements at the end of the vector
Container::resize(this->size() - static_cast<size_type>(elements_affected));
// [ a, b, c, d, h, i, j ]
// ^ ^
// first last
// first is now pointing past the last deleted element, but we cannot
// use this iterator, because it may have been invalidated by the
// resize call. Instead, we can return begin() + offset.
return Container::begin() + offset;
}
|
O0
|
cpp
|
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>>>::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::__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>*, std::vector<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>, 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>>>>, __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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>*, std::vector<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>, 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>>>>):
subq $0x98, %rsp
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xd4380
testb $0x1, %al
jne 0xdc6f1
jmp 0xdc706
movq 0x88(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0xdc858
movq 0x88(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xdc8a0
movq 0x8(%rsp), %rdi
movq %rax, 0x70(%rsp)
callq 0xa1ae0
movq %rax, 0x50(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xdc8a0
movq %rax, 0x58(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0xdc870
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0xa1b50
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa1b10
testb $0x1, %al
jne 0xdc7b3
jmp 0xdc816
leaq 0x40(%rsp), %rdi
callq 0xa1b80
movq %rax, %rdi
callq 0xc7c30
leaq 0x40(%rsp), %rdi
callq 0xca440
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0xdc870
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xca440
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xdc8e0
leaq 0x40(%rsp), %rdi
callq 0xa1ef0
jmp 0xdc771
movq 0x8(%rsp), %rdi
callq 0xc9e90
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq 0x70(%rsp), %rsi
callq 0xdc920
movq 0x8(%rsp), %rdi
callq 0xa1ae0
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xdc9c0
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
nopl (%rax,%rax)
|
_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_:
sub rsp, 98h
mov [rsp+98h+var_10], rsi
mov [rsp+98h+var_18], rdx
mov [rsp+98h+var_20], rdi
mov rax, [rsp+98h+var_20]
mov [rsp+98h+var_90], rax
lea rdi, [rsp+98h+var_10]
lea rsi, [rsp+98h+var_18]
call _ZN9__gnu_cxxeqIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbRKNS_17__normal_iteratorIT_T0_EEST_; __gnu_cxx::operator==<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&,__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&)
test al, 1
jnz short loc_DC6F1
jmp short loc_DC706
loc_DC6F1:
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_8], rax
jmp loc_DC858
loc_DC706:
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_30], rax
mov rax, [rsp+98h+var_18]
mov [rsp+98h+var_38], rax
mov rdi, [rsp+98h+var_30]
mov rsi, [rsp+98h+var_38]
call _ZSt8distanceIN9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS4_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEEN5minja5ValueEES7_ISL_SaISL_EEEEENSt15iterator_traitsIT_E15difference_typeESR_SR_; std::distance<__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>>>,__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>>>)
mov rdi, [rsp+98h+var_90]
mov [rsp+98h+var_28], rax
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE5beginEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::begin(void)
mov [rsp+98h+var_48], rax
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_50], rax
mov rdi, [rsp+98h+var_48]
mov rsi, [rsp+98h+var_50]
call _ZSt8distanceIN9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS4_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEEN5minja5ValueEES7_ISL_SaISL_EEEEENSt15iterator_traitsIT_E15difference_typeESR_SR_; std::distance<__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>>>,__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>>>)
mov [rsp+98h+var_40], rax
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_58], rax
loc_DC771:
mov rax, [rsp+98h+var_58]
mov [rsp+98h+var_68], rax
mov rsi, [rsp+98h+var_28]
mov rdi, [rsp+98h+var_68]
call _ZSt4nextIN9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS4_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEEN5minja5ValueEES7_ISL_SaISL_EEEEET_SQ_NSt15iterator_traitsISQ_E15difference_typeE; std::next<__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>>>,std::iterator_traits<__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>>>>::difference_type)
mov rdi, [rsp+98h+var_90]
mov [rsp+98h+var_60], rax
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE3endEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::end(void)
mov [rsp+98h+var_70], rax
lea rdi, [rsp+98h+var_60]
lea rsi, [rsp+98h+var_70]
call _ZN9__gnu_cxxneIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbRKNS_17__normal_iteratorIT_T0_EEST_; __gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&,__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&)
test al, 1
jnz short loc_DC7B3
jmp short loc_DC816
loc_DC7B3:
lea rdi, [rsp+98h+var_58]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator->(void)
mov rdi, rax
call _ZNSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueEED2Ev; 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>::~pair()
lea rdi, [rsp+98h+var_58]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator*(void)
mov [rsp+98h+var_98], rax
mov rax, [rsp+98h+var_58]
mov [rsp+98h+var_80], rax
mov rsi, [rsp+98h+var_28]
mov rdi, [rsp+98h+var_80]
call _ZSt4nextIN9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS4_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEEN5minja5ValueEES7_ISL_SaISL_EEEEET_SQ_NSt15iterator_traitsISQ_E15difference_typeE; std::next<__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>>>,std::iterator_traits<__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>>>>::difference_type)
mov [rsp+98h+var_78], rax
lea rdi, [rsp+98h+var_78]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator*(void)
mov rdi, [rsp+98h+var_98]
mov rsi, rax
call _ZNSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueEEC2EOSI_; 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>::pair(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>&&)
lea rdi, [rsp+98h+var_58]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator++(void)
jmp loc_DC771
loc_DC816:
mov rdi, [rsp+98h+var_90]
call _ZNKSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE4sizeEv; 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>>::size(void)
mov rdi, [rsp+98h+var_90]
mov rsi, rax
sub rsi, [rsp+98h+var_28]
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE6resizeEm; 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>>::resize(ulong)
mov rdi, [rsp+98h+var_90]
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE5beginEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::begin(void)
mov [rsp+98h+var_88], rax
mov rsi, [rsp+98h+var_40]
lea rdi, [rsp+98h+var_88]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEplEl; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator+(long)
mov [rsp+98h+var_8], rax
loc_DC858:
mov rax, [rsp+98h+var_8]
add rsp, 98h
retn
|
long long 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 *a1,
long long a2,
long long a3)
{
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v7; // [rsp+0h] [rbp-98h]
_QWORD v8[2]; // [rsp+10h] [rbp-88h] BYREF
long long v9; // [rsp+20h] [rbp-78h] BYREF
_QWORD v10[2]; // [rsp+28h] [rbp-70h] BYREF
long long v11; // [rsp+38h] [rbp-60h] BYREF
_QWORD v12[2]; // [rsp+40h] [rbp-58h] BYREF
long long v13; // [rsp+50h] [rbp-48h]
long long v14; // [rsp+58h] [rbp-40h]
long long v15; // [rsp+60h] [rbp-38h]
long long v16; // [rsp+68h] [rbp-30h]
long long v17; // [rsp+70h] [rbp-28h]
_QWORD *v18; // [rsp+78h] [rbp-20h]
long long v19; // [rsp+80h] [rbp-18h] BYREF
long long v20; // [rsp+88h] [rbp-10h] BYREF
v20 = a2;
v19 = a3;
v18 = a1;
if ( __gnu_cxx::operator==<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>(
(long long)&v20,
(long long)&v19) )
{
return v20;
}
v16 = v20;
v15 = v19;
v17 = std::distance<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>>(
v20,
v19);
v13 = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::begin((long long)a1);
v12[1] = v20;
v14 = std::distance<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>>(
v13,
v20);
v12[0] = v20;
while ( 1 )
{
v10[1] = v12[0];
v11 = std::next<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>>(
v12[0],
v17);
v10[0] = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::end((long long)a1);
if ( !__gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>(
(long long)&v11,
(long long)v10) )
break;
v3 = __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator->((long long)v12);
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>::~pair(v3);
v7 = __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator*((long long)v12);
v8[1] = v12[0];
v9 = std::next<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>>(
v12[0],
v17);
v4 = __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator*((long long)&v9);
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>::pair(
v7,
v4);
__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator++(v12);
}
v5 = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::size(a1);
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::resize(
a1,
v5 - v17);
v8[0] = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::begin((long long)a1);
return __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator+(
v8,
v14);
}
|
erase:
SUB RSP,0x98
MOV qword ptr [RSP + 0x88],RSI
MOV qword ptr [RSP + 0x80],RDX
MOV qword ptr [RSP + 0x78],RDI
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x80]
CALL 0x001d4380
TEST AL,0x1
JNZ 0x001dc6f1
JMP 0x001dc706
LAB_001dc6f1:
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x90],RAX
JMP 0x001dc858
LAB_001dc706:
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x60]
CALL 0x001dc8a0
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x70],RAX
CALL 0x001a1ae0
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x001dc8a0
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x40],RAX
LAB_001dc771:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x30],RAX
MOV RSI,qword ptr [RSP + 0x70]
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001dc870
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x38],RAX
CALL 0x001a1b50
MOV qword ptr [RSP + 0x28],RAX
LEA RDI,[RSP + 0x38]
LEA RSI,[RSP + 0x28]
CALL 0x001a1b10
TEST AL,0x1
JNZ 0x001dc7b3
JMP 0x001dc816
LAB_001dc7b3:
LEA RDI,[RSP + 0x40]
CALL 0x001a1b80
MOV RDI,RAX
CALL 0x001c7c30
LEA RDI,[RSP + 0x40]
CALL 0x001ca440
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x18],RAX
MOV RSI,qword ptr [RSP + 0x70]
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001dc870
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x20]
CALL 0x001ca440
MOV RDI,qword ptr [RSP]
MOV RSI,RAX
CALL 0x001dc8e0
LEA RDI,[RSP + 0x40]
CALL 0x001a1ef0
JMP 0x001dc771
LAB_001dc816:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001c9e90
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
SUB RSI,qword ptr [RSP + 0x70]
CALL 0x001dc920
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001a1ae0
MOV qword ptr [RSP + 0x10],RAX
MOV RSI,qword ptr [RSP + 0x58]
LEA RDI,[RSP + 0x10]
CALL 0x001dc9c0
MOV qword ptr [RSP + 0x90],RAX
LAB_001dc858:
MOV RAX,qword ptr [RSP + 0x90]
ADD RSP,0x98
RET
|
/* 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(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>*,
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> > > >,
__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>*,
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> > > >) */
int8 __thiscall
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>>>
*this,int8 param_2,int8 param_3)
{
bool bVar1;
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>
*ppVar2;
pair *ppVar3;
long lVar4;
int8 local_88;
int8 local_80;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 local_58;
int8 local_50;
int8 local_48;
long local_40;
int8 local_38;
int8 local_30;
long local_28;
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>>>
*local_20;
int8 local_18;
int8 local_10;
int8 local_8;
local_20 = this;
local_18 = param_3;
local_10 = param_2;
bVar1 = __gnu_cxx::operator==((__normal_iterator *)&local_10,(__normal_iterator *)&local_18);
if (bVar1) {
local_8 = local_10;
}
else {
local_30 = local_10;
local_38 = local_18;
local_28 = std::
distance<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>>
(local_10,local_18);
local_48 = std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::begin((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this);
local_50 = local_10;
local_40 = std::
distance<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>>
(local_48,local_10);
local_58 = local_10;
while( true ) {
local_68 = local_58;
local_60 = std::
next<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>>
(local_58,local_28);
local_70 = std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::end((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this);
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_60,(__normal_iterator *)&local_70);
if (!bVar1) break;
ppVar2 = (pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>
*)__gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator->((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_58);
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>
::~pair(ppVar2);
ppVar2 = (pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>
*)__gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator*((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_58);
local_80 = local_58;
local_78 = std::
next<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>>
(local_58,local_28);
ppVar3 = (pair *)__gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator*((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_78);
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>
::pair(ppVar2,ppVar3);
__gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator++((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_58);
}
lVar4 = std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::size((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this);
std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::resize((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this,lVar4 - local_28);
local_88 = std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::begin((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this);
local_8 = __gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator+((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_88,local_40);
}
return local_8;
}
|
|
11,366 |
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>>>::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::__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>*, std::vector<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>, 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>>>>, __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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>*, std::vector<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>, 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>>>>)
|
monkey531[P]llama/common/./json.hpp
|
iterator erase(iterator first, iterator last)
{
if (first == last)
{
return first;
}
const auto elements_affected = std::distance(first, last);
const auto offset = std::distance(Container::begin(), first);
// This is the start situation. We need to delete elements_affected
// elements (3 in this example: e, f, g), and need to return an
// iterator past the last deleted element (h in this example).
// Note that offset is the distance from the start of the vector
// to first. We will need this later.
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// first last
// Since we cannot move const Keys, we re-construct them in place.
// We start at first and re-construct (viz. copy) the elements from
// the back of the vector. Example for first iteration:
// ,--------.
// v | destroy e and re-construct with h
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// it it + elements_affected
for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
{
it->~value_type(); // destroy but keep allocation
new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
}
// [ a, b, c, d, h, i, j, h, i, j ]
// ^ ^
// first last
// remove the unneeded elements at the end of the vector
Container::resize(this->size() - static_cast<size_type>(elements_affected));
// [ a, b, c, d, h, i, j ]
// ^ ^
// first last
// first is now pointing past the last deleted element, but we cannot
// use this iterator, because it may have been invalidated by the
// resize call. Instead, we can return begin() + offset.
return Container::begin() + offset;
}
|
O1
|
cpp
|
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>>>::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::__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>*, std::vector<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>, 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>>>>, __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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>*, std::vector<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>, 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>>>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0x57300
movq %rdx, %r15
movq %rdi, %r14
subq %rbx, %r15
movq %r15, %rbp
sarq $0x5, %rbp
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rbp
movq (%rdi), %rax
movq %rax, (%rsp)
movq %rbx, %r12
leaq (%r12,%r15), %r13
movq 0x8(%r14), %rsi
cmpq %rsi, %r13
je 0x572d9
movq %r12, %rdi
callq 0x4fb5c
movq %r12, %rdi
movq %r13, %rsi
callq 0x57312
addq $0x60, %r12
jmp 0x572b3
subq (%r14), %rsi
subq (%rsp), %rbx
sarq $0x5, %rsi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
subq %rbp, %rsi
movq %r14, %rdi
callq 0x5739e
addq (%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_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_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
cmp rsi, rdx
jz short loc_57300
mov r15, rdx
mov r14, rdi
sub r15, rbx
mov rbp, r15
sar rbp, 5
mov rax, 0AAAAAAAAAAAAAAABh
imul rbp, rax
mov rax, [rdi]
mov [rsp+38h+var_38], rax
mov r12, rbx
loc_572B3:
lea r13, [r12+r15]
mov rsi, [r14+8]
cmp r13, rsi
jz short loc_572D9
mov rdi, r12
call _ZNSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueEED2Ev; 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>::~pair()
mov rdi, r12
mov rsi, r13
call _ZNSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueEEC2EOSI_; 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>::pair(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>&&)
add r12, 60h ; '`'
jmp short loc_572B3
loc_572D9:
sub rsi, [r14]
sub rbx, [rsp+38h+var_38]
sar rsi, 5
mov rax, 0AAAAAAAAAAAAAAABh
imul rsi, rax
sub rsi, rbp
mov rdi, r14
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE6resizeEm; 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>>::resize(ulong)
add rbx, [r14]
loc_57300:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long 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(
long long *a1,
long long a2,
long long a3)
{
long long v3; // rbx
long long v4; // r15
unsigned long long v5; // rbp
long long i; // r12
long long v7; // rsi
long long v9; // [rsp+0h] [rbp-38h]
v3 = a2;
if ( a2 != a3 )
{
v4 = a3 - a2;
v5 = 0xAAAAAAAAAAAAAAABLL * ((a3 - a2) >> 5);
v9 = *a1;
for ( i = a2; ; i += 96LL )
{
v7 = a1[1];
if ( i + v4 == v7 )
break;
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>::~pair(i);
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>::pair(
i,
i + v4);
}
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::resize(
a1,
0xAAAAAAAAAAAAAAABLL * ((v7 - *a1) >> 5) - v5);
return *a1 + v3 - v9;
}
return v3;
}
|
erase:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
CMP RSI,RDX
JZ 0x00157300
MOV R15,RDX
MOV R14,RDI
SUB R15,RBX
MOV RBP,R15
SAR RBP,0x5
MOV RAX,-0x5555555555555555
IMUL RBP,RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP],RAX
MOV R12,RBX
LAB_001572b3:
LEA R13,[R12 + R15*0x1]
MOV RSI,qword ptr [R14 + 0x8]
CMP R13,RSI
JZ 0x001572d9
MOV RDI,R12
CALL 0x0014fb5c
MOV RDI,R12
MOV RSI,R13
CALL 0x00157312
ADD R12,0x60
JMP 0x001572b3
LAB_001572d9:
SUB RSI,qword ptr [R14]
SUB RBX,qword ptr [RSP]
SAR RSI,0x5
MOV RAX,-0x5555555555555555
IMUL RSI,RAX
SUB RSI,RBP
MOV RDI,R14
CALL 0x0015739e
ADD RBX,qword ptr [R14]
LAB_00157300:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* 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(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>*,
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> > > >,
__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>*,
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> > > >) */
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>
* __thiscall
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>>>
*this,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>
*param_2,
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>
*param_3)
{
long lVar1;
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>
*this_00;
if (param_2 != param_3) {
lVar1 = *(long *)this;
this_00 = param_2;
while( true ) {
if ((pair *)(this_00 + ((long)param_3 - (long)param_2)) == *(pair **)(this + 8)) break;
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>
::~pair(this_00);
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>
::pair(this_00,(pair *)(this_00 + ((long)param_3 - (long)param_2)));
this_00 = this_00 + 0x60;
}
std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::resize((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this,((long)*(pair **)(this + 8) - *(long *)this >> 5) * -0x5555555555555555 +
((long)param_3 - (long)param_2 >> 5) * 0x5555555555555555);
param_2 = param_2 + (*(long *)this - lVar1);
}
return param_2;
}
|
|
11,367 |
my_strnncollsp_8bit_bin
|
eloqsql/strings/ctype-bin.c
|
static int my_strnncollsp_8bit_bin(CHARSET_INFO * cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *end;
size_t length;
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (*a++ != *b++)
return ((int) a[-1] - (int) b[-1]);
}
return a_length == b_length ? 0 :
a_length < b_length ?
-my_strnncollsp_padspace_bin(b, b_length - length) :
my_strnncollsp_padspace_bin(a, a_length - length);
}
|
O3
|
c
|
my_strnncollsp_8bit_bin:
pushq %rbp
movq %rsp, %rbp
cmpq %r8, %rdx
movq %r8, %rdi
cmovbq %rdx, %rdi
leaq (%rsi,%rdi), %r9
cmpq %r9, %rsi
jae 0x4f661
movzbl (%rsi), %eax
incq %rsi
movzbl (%rcx), %r10d
incq %rcx
cmpb %r10b, %al
je 0x4f645
subl %r10d, %eax
jmp 0x4f668
xorl %eax, %eax
cmpq %r8, %rdx
jne 0x4f66a
popq %rbp
retq
jae 0x4f687
subq %rdi, %r8
je 0x4f668
xorl %edx, %edx
xorl %eax, %eax
cmpb $0x20, (%rcx,%rdx)
jb 0x4f6a2
jne 0x4f6a9
incq %rdx
cmpq %rdx, %r8
jne 0x4f675
jmp 0x4f668
subq %rdi, %rdx
je 0x4f668
xorl %ecx, %ecx
xorl %eax, %eax
cmpb $0x20, (%rsi,%rcx)
jb 0x4f6a9
jne 0x4f6a2
incq %rcx
cmpq %rcx, %rdx
jne 0x4f690
jmp 0x4f668
movl $0x1, %eax
jmp 0x4f668
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x4f668
|
my_strnncollsp_8bit_bin:
push rbp
mov rbp, rsp
cmp rdx, r8
mov rdi, r8
cmovb rdi, rdx
lea r9, [rsi+rdi]
loc_4F645:
cmp rsi, r9
jnb short loc_4F661
movzx eax, byte ptr [rsi]
inc rsi
movzx r10d, byte ptr [rcx]
inc rcx
cmp al, r10b
jz short loc_4F645
sub eax, r10d
jmp short loc_4F668
loc_4F661:
xor eax, eax
cmp rdx, r8
jnz short loc_4F66A
loc_4F668:
pop rbp
retn
loc_4F66A:
jnb short loc_4F687
sub r8, rdi
jz short loc_4F668
xor edx, edx
xor eax, eax
loc_4F675:
cmp byte ptr [rcx+rdx], 20h ; ' '
jb short loc_4F6A2
jnz short loc_4F6A9
inc rdx
cmp r8, rdx
jnz short loc_4F675
jmp short loc_4F668
loc_4F687:
sub rdx, rdi
jz short loc_4F668
xor ecx, ecx
xor eax, eax
loc_4F690:
cmp byte ptr [rsi+rcx], 20h ; ' '
jb short loc_4F6A9
jnz short loc_4F6A2
inc rcx
cmp rdx, rcx
jnz short loc_4F690
jmp short loc_4F668
loc_4F6A2:
mov eax, 1
jmp short loc_4F668
loc_4F6A9:
mov eax, 0FFFFFFFFh
jmp short loc_4F668
|
long long my_strnncollsp_8bit_bin(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5)
{
unsigned long long v5; // rdi
unsigned __int8 *v6; // r9
int v7; // eax
int v8; // r10d
long long result; // rax
unsigned long long v10; // r8
long long v11; // rdx
unsigned long long v12; // rdx
long long v13; // rcx
v5 = a5;
if ( a3 < a5 )
v5 = a3;
v6 = &a2[v5];
while ( a2 < v6 )
{
v7 = *a2++;
v8 = *a4++;
if ( (_BYTE)v7 != (_BYTE)v8 )
return (unsigned int)(v7 - v8);
}
result = 0LL;
if ( a3 != a5 )
{
if ( a3 >= a5 )
{
v12 = a3 - v5;
if ( v12 )
{
v13 = 0LL;
result = 0LL;
while ( a2[v13] >= 0x20u )
{
if ( a2[v13] != 32 )
return 1LL;
if ( v12 == ++v13 )
return result;
}
return 0xFFFFFFFFLL;
}
}
else
{
v10 = a5 - v5;
if ( v10 )
{
v11 = 0LL;
result = 0LL;
while ( a4[v11] >= 0x20u )
{
if ( a4[v11] != 32 )
return 0xFFFFFFFFLL;
if ( v10 == ++v11 )
return result;
}
return 1LL;
}
}
}
return result;
}
|
my_strnncollsp_8bit_bin:
PUSH RBP
MOV RBP,RSP
CMP RDX,R8
MOV RDI,R8
CMOVC RDI,RDX
LEA R9,[RSI + RDI*0x1]
LAB_0014f645:
CMP RSI,R9
JNC 0x0014f661
MOVZX EAX,byte ptr [RSI]
INC RSI
MOVZX R10D,byte ptr [RCX]
INC RCX
CMP AL,R10B
JZ 0x0014f645
SUB EAX,R10D
JMP 0x0014f668
LAB_0014f661:
XOR EAX,EAX
CMP RDX,R8
JNZ 0x0014f66a
LAB_0014f668:
POP RBP
RET
LAB_0014f66a:
JNC 0x0014f687
SUB R8,RDI
JZ 0x0014f668
XOR EDX,EDX
XOR EAX,EAX
LAB_0014f675:
CMP byte ptr [RCX + RDX*0x1],0x20
JC 0x0014f6a2
JNZ 0x0014f6a9
INC RDX
CMP R8,RDX
JNZ 0x0014f675
JMP 0x0014f668
LAB_0014f687:
SUB RDX,RDI
JZ 0x0014f668
XOR ECX,ECX
XOR EAX,EAX
LAB_0014f690:
CMP byte ptr [RSI + RCX*0x1],0x20
JC 0x0014f6a9
JNZ 0x0014f6a2
INC RCX
CMP RDX,RCX
JNZ 0x0014f690
JMP 0x0014f668
LAB_0014f6a2:
MOV EAX,0x1
JMP 0x0014f668
LAB_0014f6a9:
MOV EAX,0xffffffff
JMP 0x0014f668
|
int my_strnncollsp_8bit_bin
(int8 param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
long lVar4;
ulong uVar5;
uVar5 = param_5;
if (param_3 < param_5) {
uVar5 = param_3;
}
pbVar1 = param_2 + uVar5;
while (param_2 < pbVar1) {
bVar2 = *param_2;
param_2 = param_2 + 1;
bVar3 = *param_4;
param_4 = param_4 + 1;
if (bVar2 != bVar3) {
return (uint)bVar2 - (uint)bVar3;
}
}
if (param_3 == param_5) {
return 0;
}
if (param_3 < param_5) {
if (param_5 == uVar5) {
return 0;
}
lVar4 = 0;
while( true ) {
if (param_4[lVar4] < 0x20) {
return 1;
}
if (param_4[lVar4] != 0x20) break;
lVar4 = lVar4 + 1;
if (param_5 - uVar5 == lVar4) {
return 0;
}
}
return -1;
}
if (param_3 != uVar5) {
lVar4 = 0;
while( true ) {
if (param_2[lVar4] < 0x20) {
return -1;
}
if (param_2[lVar4] != 0x20) break;
lVar4 = lVar4 + 1;
if (param_3 - uVar5 == lVar4) {
return 0;
}
}
return 1;
}
return 0;
}
|
|
11,368 |
google::protobuf::SourceCodeInfo::_InternalSerialize(unsigned char*, google::protobuf::io::EpsCopyOutputStream*) const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc
|
uint8_t* SourceCodeInfo::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.SourceCodeInfo)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
// repeated .google.protobuf.SourceCodeInfo.Location location = 1;
for (unsigned i = 0,
n = static_cast<unsigned>(this->_internal_location_size()); i < n; i++) {
const auto& repfield = this->_internal_location(i);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
}
// @@protoc_insertion_point(serialize_to_array_end:google.protobuf.SourceCodeInfo)
return target;
}
|
O3
|
cpp
|
google::protobuf::SourceCodeInfo::_InternalSerialize(unsigned char*, google::protobuf::io::EpsCopyOutputStream*) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movl 0x18(%rdi), %ebp
testl %ebp, %ebp
je 0xf9251
xorl %r15d, %r15d
movq 0x20(%r14), %rcx
movslq %r15d, %r15
movq 0x8(%rcx,%r15,8), %rsi
movl 0x14(%rsi), %edx
movl $0x1, %edi
movq %rax, %rcx
movq %rbx, %r8
callq 0x8cace
incl %r15d
cmpl %r15d, %ebp
jne 0xf922a
movq 0x8(%r14), %rdi
testb $0x1, %dil
jne 0xf9266
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
andq $-0x4, %rdi
addq $0x8, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa6e1e
nop
|
_ZNK6google8protobuf14SourceCodeInfo18_InternalSerializeEPhPNS0_2io19EpsCopyOutputStreamE:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov rax, rsi
mov r14, rdi
mov ebp, [rdi+18h]
test ebp, ebp
jz short loc_F9251
xor r15d, r15d
loc_F922A:
mov rcx, [r14+20h]
movsxd r15, r15d
mov rsi, [rcx+r15*8+8]; int
mov edx, [rsi+14h]; google::protobuf::MessageLite *
mov edi, (offset dword_0+1); this
mov rcx, rax; int
mov r8, rbx; unsigned __int8 *
call _ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageEiRKNS0_11MessageLiteEiPhPNS0_2io19EpsCopyOutputStreamE; google::protobuf::internal::WireFormatLite::InternalWriteMessage(int,google::protobuf::MessageLite const&,int,uchar *,google::protobuf::io::EpsCopyOutputStream *)
inc r15d
cmp ebp, r15d
jnz short loc_F922A
loc_F9251:
mov rdi, [r14+8]
test dil, 1
jnz short loc_F9266
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_F9266:
and rdi, 0FFFFFFFFFFFFFFFCh
add rdi, 8; this
mov rsi, rax; google::protobuf::UnknownFieldSet *
mov rdx, rbx; unsigned __int8 *
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _ZN6google8protobuf8internal10WireFormat37InternalSerializeUnknownFieldsToArrayERKNS0_15UnknownFieldSetEPhPNS0_2io19EpsCopyOutputStreamE; google::protobuf::internal::WireFormat::InternalSerializeUnknownFieldsToArray(google::protobuf::UnknownFieldSet const&,uchar *,google::protobuf::io::EpsCopyOutputStream *)
|
unsigned __int8 * google::protobuf::SourceCodeInfo::_InternalSerialize(
google::protobuf::SourceCodeInfo *this,
unsigned __int8 *a2,
google::protobuf::io::EpsCopyOutputStream *a3,
google::protobuf::io::EpsCopyOutputStream *a4,
long long a5,
google::protobuf::io::EpsCopyOutputStream *a6)
{
unsigned __int8 *result; // rax
int v8; // ebp
int i; // r15d
long long v10; // rsi
long long v11; // rdi
result = a2;
v8 = *((_DWORD *)this + 6);
if ( v8 )
{
for ( i = 0; i != v8; ++i )
{
v10 = *(_QWORD *)(*((_QWORD *)this + 4) + 8LL * i + 8);
result = (unsigned __int8 *)google::protobuf::internal::WireFormatLite::InternalWriteMessage(
(google::protobuf::internal::WireFormatLite *)((char *)&dword_0 + 1),
v10,
(const google::protobuf::MessageLite *)*(unsigned int *)(v10 + 20),
(unsigned long long)result,
a3,
a6);
}
}
v11 = *((_QWORD *)this + 1);
if ( (v11 & 1) != 0 )
return google::protobuf::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
(google::protobuf::internal::WireFormat *)((v11 & 0xFFFFFFFFFFFFFFFCLL) + 8),
(const google::protobuf::UnknownFieldSet *)result,
a3,
a4);
return result;
}
|
_InternalSerialize:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV RAX,RSI
MOV R14,RDI
MOV EBP,dword ptr [RDI + 0x18]
TEST EBP,EBP
JZ 0x001f9251
XOR R15D,R15D
LAB_001f922a:
MOV RCX,qword ptr [R14 + 0x20]
MOVSXD R15,R15D
MOV RSI,qword ptr [RCX + R15*0x8 + 0x8]
MOV EDX,dword ptr [RSI + 0x14]
MOV EDI,0x1
MOV RCX,RAX
MOV R8,RBX
CALL 0x0018cace
INC R15D
CMP EBP,R15D
JNZ 0x001f922a
LAB_001f9251:
MOV RDI,qword ptr [R14 + 0x8]
TEST DIL,0x1
JNZ 0x001f9266
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001f9266:
AND RDI,-0x4
ADD RDI,0x8
MOV RSI,RAX
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001a6e1e
|
/* google::protobuf::SourceCodeInfo::_InternalSerialize(unsigned char*,
google::protobuf::io::EpsCopyOutputStream*) const */
void __thiscall
google::protobuf::SourceCodeInfo::_InternalSerialize
(SourceCodeInfo *this,uchar *param_1,EpsCopyOutputStream *param_2)
{
int iVar1;
MessageLite *pMVar2;
int iVar3;
iVar1 = *(int *)(this + 0x18);
if (iVar1 != 0) {
iVar3 = 0;
do {
pMVar2 = *(MessageLite **)(*(long *)(this + 0x20) + 8 + (long)iVar3 * 8);
param_1 = (uchar *)internal::WireFormatLite::InternalWriteMessage
(1,pMVar2,*(int *)(pMVar2 + 0x14),param_1,param_2);
iVar3 = iVar3 + 1;
} while (iVar1 != iVar3);
}
if ((*(ulong *)(this + 8) & 1) == 0) {
return;
}
internal::WireFormat::InternalSerializeUnknownFieldsToArray
((UnknownFieldSet *)((*(ulong *)(this + 8) & 0xfffffffffffffffc) + 8),param_1,param_2);
return;
}
|
|
11,369 |
pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::~BaseNode()
|
The-Pocket[P]PocketFlow-CPP/pocketflow.h
|
virtual ~BaseNode() override = default;
|
O1
|
c
|
pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::~BaseNode():
pushq %rbx
movq %rdi, %rbx
leaq 0x976f(%rip), %rax # 0x17ad0
movq %rax, (%rdi)
movq 0x68(%rdi), %rdi
leaq 0x78(%rbx), %rax
cmpq %rax, %rdi
je 0xe37c
movq (%rax), %rsi
incq %rsi
callq 0x5180
leaq 0x38(%rbx), %rdi
callq 0x7fec
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x90d0
|
_ZN10pocketflow8BaseNodeIiiED2Ev:
push rbx
mov rbx, rdi
lea rax, off_17AD0
mov [rdi], rax
mov rdi, [rdi+68h]; void *
lea rax, [rbx+78h]
cmp rdi, rax
jz short loc_E37C
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E37C:
lea rdi, [rbx+38h]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St10shared_ptrIN10pocketflow9IBaseNodeEEESt10_Select1stISC_ESt4lessIS5_ESaISC_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>,std::_Select1st<std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>>>::~_Rb_tree()
add rbx, 8
mov rdi, rbx
pop rbx
jmp _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St3anyESt10_Select1stIS9_ESt4lessIS5_ESaIS9_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,std::any>,std::_Select1st<std::pair<std::string const,std::any>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::any>>>::~_Rb_tree()
|
void pocketflow::BaseNode<int,int>::~BaseNode(_QWORD *a1)
{
_QWORD *v2; // rdi
*a1 = &off_17AD0;
v2 = (_QWORD *)a1[13];
if ( v2 != a1 + 15 )
operator delete(v2, a1[15] + 1LL);
std::_Rb_tree<std::string,std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>,std::_Select1st<std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>>>::~_Rb_tree((long long)(a1 + 7));
std::_Rb_tree<std::string,std::pair<std::string const,std::any>,std::_Select1st<std::pair<std::string const,std::any>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::any>>>::~_Rb_tree((long long)(a1 + 1));
}
|
~BaseNode:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x117ad0]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x68]
LEA RAX,[RBX + 0x78]
CMP RDI,RAX
JZ 0x0010e37c
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00105180
LAB_0010e37c:
LEA RDI,[RBX + 0x38]
CALL 0x00107fec
ADD RBX,0x8
MOV RDI,RBX
POP RBX
JMP 0x001090d0
|
/* pocketflow::BaseNode<int, int>::~BaseNode() */
void __thiscall pocketflow::BaseNode<int,int>::~BaseNode(BaseNode<int,int> *this)
{
*(int ***)this = &PTR__BaseNode_00117ad0;
if (*(BaseNode<int,int> **)(this + 0x68) != this + 0x78) {
operator_delete(*(BaseNode<int,int> **)(this + 0x68),*(long *)(this + 0x78) + 1);
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>,std::_Select1st<std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>>>
::~_Rb_tree((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>,std::_Select1st<std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>>>
*)(this + 0x38));
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::any>,std::_Select1st<std::pair<std::__cxx11::string_const,std::any>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::any>>>
::~_Rb_tree((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::any>,std::_Select1st<std::pair<std::__cxx11::string_const,std::any>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::any>>>
*)(this + 8));
return;
}
|
|
11,370 |
pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::~BaseNode()
|
The-Pocket[P]PocketFlow-CPP/pocketflow.h
|
virtual ~BaseNode() override = default;
|
O3
|
c
|
pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::~BaseNode():
pushq %rbx
movq %rdi, %rbx
leaq 0x980d(%rip), %rax # 0x17ad0
movq %rax, (%rdi)
movq 0x68(%rdi), %rdi
leaq 0x78(%rbx), %rax
cmpq %rax, %rdi
je 0xe2de
movq (%rax), %rsi
incq %rsi
callq 0x5180
leaq 0x38(%rbx), %rdi
callq 0x7f36
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x901c
|
_ZN10pocketflow8BaseNodeIiiED2Ev:
push rbx
mov rbx, rdi
lea rax, off_17AD0
mov [rdi], rax
mov rdi, [rdi+68h]; void *
lea rax, [rbx+78h]
cmp rdi, rax
jz short loc_E2DE
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E2DE:
lea rdi, [rbx+38h]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St10shared_ptrIN10pocketflow9IBaseNodeEEESt10_Select1stISC_ESt4lessIS5_ESaISC_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>,std::_Select1st<std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>>>::~_Rb_tree()
add rbx, 8
mov rdi, rbx
pop rbx
jmp _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St3anyESt10_Select1stIS9_ESt4lessIS5_ESaIS9_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,std::any>,std::_Select1st<std::pair<std::string const,std::any>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::any>>>::~_Rb_tree()
|
void pocketflow::BaseNode<int,int>::~BaseNode(_QWORD *a1)
{
_QWORD *v2; // rdi
*a1 = &off_17AD0;
v2 = (_QWORD *)a1[13];
if ( v2 != a1 + 15 )
operator delete(v2, a1[15] + 1LL);
std::_Rb_tree<std::string,std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>,std::_Select1st<std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::shared_ptr<pocketflow::IBaseNode>>>>::~_Rb_tree((long long)(a1 + 7));
std::_Rb_tree<std::string,std::pair<std::string const,std::any>,std::_Select1st<std::pair<std::string const,std::any>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::any>>>::~_Rb_tree((long long)(a1 + 1));
}
|
~BaseNode:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x117ad0]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x68]
LEA RAX,[RBX + 0x78]
CMP RDI,RAX
JZ 0x0010e2de
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00105180
LAB_0010e2de:
LEA RDI,[RBX + 0x38]
CALL 0x00107f36
ADD RBX,0x8
MOV RDI,RBX
POP RBX
JMP 0x0010901c
|
/* pocketflow::BaseNode<int, int>::~BaseNode() */
void __thiscall pocketflow::BaseNode<int,int>::~BaseNode(BaseNode<int,int> *this)
{
*(int ***)this = &PTR__BaseNode_00117ad0;
if (*(BaseNode<int,int> **)(this + 0x68) != this + 0x78) {
operator_delete(*(BaseNode<int,int> **)(this + 0x68),*(long *)(this + 0x78) + 1);
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>,std::_Select1st<std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>>>
::~_Rb_tree((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>,std::_Select1st<std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<pocketflow::IBaseNode>>>>
*)(this + 0x38));
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::any>,std::_Select1st<std::pair<std::__cxx11::string_const,std::any>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::any>>>
::~_Rb_tree((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::any>,std::_Select1st<std::pair<std::__cxx11::string_const,std::any>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::any>>>
*)(this + 8));
return;
}
|
|
11,371 |
PFS_memory_stat::count_free(unsigned long, PFS_memory_stat_delta*)
|
eloqsql/storage/perfschema/pfs_stat.h
|
inline PFS_memory_stat_delta *count_free(size_t size, PFS_memory_stat_delta *delta)
{
m_used= true;
m_free_count++;
m_alloc_count_capacity++;
m_free_size+= size;
m_alloc_size_capacity+= size;
if ((m_free_count_capacity >= 1) &&
(m_free_size_capacity >= size))
{
m_free_count_capacity--;
m_free_size_capacity-= size;
return NULL;
}
delta->reset();
if (m_free_count_capacity >= 1)
{
m_free_count_capacity--;
}
else
{
delta->m_free_count_delta= 1;
}
if (m_free_size_capacity >= size)
{
m_free_size_capacity-= size;
}
else
{
delta->m_free_size_delta= size - m_free_size_capacity;
m_free_size_capacity= 0;
}
return delta;
}
|
O0
|
c
|
PFS_memory_stat::count_free(unsigned long, PFS_memory_stat_delta*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x1, (%rax)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
cmpq $0x1, 0x30(%rax)
jb 0x522ed
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0x522ed
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rdx
movq 0x40(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x40(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x52366
movq -0x20(%rbp), %rdi
callq 0x523f0
movq -0x28(%rbp), %rax
cmpq $0x1, 0x30(%rax)
jb 0x52313
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x5231f
movq -0x20(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0x52342
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x40(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x40(%rax)
jmp 0x5235e
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdx
subq 0x40(%rax), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq $0x0, 0x40(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
|
_ZN15PFS_memory_stat10count_freeEmP21PFS_memory_stat_delta:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov byte ptr [rax], 1
mov rcx, [rax+10h]
add rcx, 1
mov [rax+10h], rcx
mov rcx, [rax+28h]
add rcx, 1
mov [rax+28h], rcx
mov rcx, [rbp+var_18]
add rcx, [rax+20h]
mov [rax+20h], rcx
mov rcx, [rbp+var_18]
add rcx, [rax+38h]
mov [rax+38h], rcx
cmp qword ptr [rax+30h], 1
jb short loc_522ED
mov rax, [rbp+var_28]
mov rax, [rax+40h]
cmp rax, [rbp+var_18]
jb short loc_522ED
mov rax, [rbp+var_28]
mov rcx, [rax+30h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+30h], rcx
mov rdx, [rbp+var_18]
mov rcx, [rax+40h]
sub rcx, rdx
mov [rax+40h], rcx
mov [rbp+var_8], 0
jmp short loc_52366
loc_522ED:
mov rdi, [rbp+var_20]; this
call _ZN21PFS_memory_stat_delta5resetEv; PFS_memory_stat_delta::reset(void)
mov rax, [rbp+var_28]
cmp qword ptr [rax+30h], 1
jb short loc_52313
mov rax, [rbp+var_28]
mov rcx, [rax+30h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+30h], rcx
jmp short loc_5231F
loc_52313:
mov rax, [rbp+var_20]
mov qword ptr [rax+8], 1
loc_5231F:
mov rax, [rbp+var_28]
mov rax, [rax+40h]
cmp rax, [rbp+var_18]
jb short loc_52342
mov rax, [rbp+var_28]
mov rdx, [rbp+var_18]
mov rcx, [rax+40h]
sub rcx, rdx
mov [rax+40h], rcx
jmp short loc_5235E
loc_52342:
mov rax, [rbp+var_28]
mov rdx, [rbp+var_18]
sub rdx, [rax+40h]
mov rcx, [rbp+var_20]
mov [rcx+18h], rdx
mov qword ptr [rax+40h], 0
loc_5235E:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_52366:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
PFS_memory_stat_delta * PFS_memory_stat::count_free(
PFS_memory_stat *this,
unsigned long long a2,
PFS_memory_stat_delta *a3)
{
*(_BYTE *)this = 1;
++*((_QWORD *)this + 2);
++*((_QWORD *)this + 5);
*((_QWORD *)this + 4) += a2;
*((_QWORD *)this + 7) += a2;
if ( *((_QWORD *)this + 6) && *((_QWORD *)this + 8) >= a2 )
{
--*((_QWORD *)this + 6);
*((_QWORD *)this + 8) -= a2;
return 0LL;
}
else
{
PFS_memory_stat_delta::reset(a3);
if ( *((_QWORD *)this + 6) )
--*((_QWORD *)this + 6);
else
*((_QWORD *)a3 + 1) = 1LL;
if ( *((_QWORD *)this + 8) < a2 )
{
*((_QWORD *)a3 + 3) = a2 - *((_QWORD *)this + 8);
*((_QWORD *)this + 8) = 0LL;
}
else
{
*((_QWORD *)this + 8) -= a2;
}
return a3;
}
}
|
count_free:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV byte ptr [RAX],0x1
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,0x1
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RAX + 0x28]
ADD RCX,0x1
MOV qword ptr [RAX + 0x28],RCX
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,qword ptr [RAX + 0x38]
MOV qword ptr [RAX + 0x38],RCX
CMP qword ptr [RAX + 0x30],0x1
JC 0x001522ed
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x40]
CMP RAX,qword ptr [RBP + -0x18]
JC 0x001522ed
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x30]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x30],RCX
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x40]
SUB RCX,RDX
MOV qword ptr [RAX + 0x40],RCX
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00152366
LAB_001522ed:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001523f0
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX + 0x30],0x1
JC 0x00152313
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x30]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x30],RCX
JMP 0x0015231f
LAB_00152313:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],0x1
LAB_0015231f:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x40]
CMP RAX,qword ptr [RBP + -0x18]
JC 0x00152342
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x40]
SUB RCX,RDX
MOV qword ptr [RAX + 0x40],RCX
JMP 0x0015235e
LAB_00152342:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x20]
MOV qword ptr [RCX + 0x18],RDX
MOV qword ptr [RAX + 0x40],0x0
LAB_0015235e:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_00152366:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
/* PFS_memory_stat::count_free(unsigned long, PFS_memory_stat_delta*) */
PFS_memory_stat_delta * __thiscall
PFS_memory_stat::count_free(PFS_memory_stat *this,ulong param_1,PFS_memory_stat_delta *param_2)
{
PFS_memory_stat_delta *local_10;
*this = (PFS_memory_stat)0x1;
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 1;
*(long *)(this + 0x28) = *(long *)(this + 0x28) + 1;
*(ulong *)(this + 0x20) = param_1 + *(long *)(this + 0x20);
*(ulong *)(this + 0x38) = param_1 + *(long *)(this + 0x38);
if ((*(long *)(this + 0x30) == 0) || (*(ulong *)(this + 0x40) < param_1)) {
PFS_memory_stat_delta::reset(param_2);
if (*(long *)(this + 0x30) == 0) {
*(int8 *)(param_2 + 8) = 1;
}
else {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + -1;
}
local_10 = param_2;
if (*(ulong *)(this + 0x40) < param_1) {
*(ulong *)(param_2 + 0x18) = param_1 - *(long *)(this + 0x40);
*(int8 *)(this + 0x40) = 0;
}
else {
*(ulong *)(this + 0x40) = *(long *)(this + 0x40) - param_1;
}
}
else {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + -1;
*(ulong *)(this + 0x40) = *(long *)(this + 0x40) - param_1;
local_10 = (PFS_memory_stat_delta *)0x0;
}
return local_10;
}
|
|
11,372 |
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>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t)
|
llama.cpp/common/json.hpp
|
basic_json(initializer_list_t init,
bool type_deduction = true,
value_t manual_type = value_t::array)
{
// check if each element is an array with two elements whose first
// element is a string
bool is_an_object = std::all_of(init.begin(), init.end(),
[](const detail::json_ref<basic_json>& element_ref)
{
// The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
// (many string types can be constructed from 0 via its null-pointer guise, so we get a
// broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
});
// adjust type if type deduction is not wanted
if (!type_deduction)
{
// if array is wanted, do not create an object though possible
if (manual_type == value_t::array)
{
is_an_object = false;
}
// if object is wanted but impossible, throw an exception
if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
{
JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
}
}
if (is_an_object)
{
// the initializer list is a list of pairs -> create object
m_data.m_type = value_t::object;
m_data.m_value = value_t::object;
for (auto& element_ref : init)
{
auto element = element_ref.moved_or_copied();
m_data.m_value.object->emplace(
std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
std::move((*element.m_data.m_value.array)[1]));
}
}
else
{
// the initializer list describes an array -> create array
m_data.m_type = value_t::array;
m_data.m_value.array = create<array_t>(init.begin(), init.end());
}
set_parents();
assert_invariant();
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax,8), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
movq %r12, %rsi
callq 0x8753e
cmpq %r12, %rax
sete %cl
testb %r13b, %r13b
jne 0x68105
cmpq %r12, %rax
sete %al
cmpb $0x2, %bpl
setne %cl
cmpb $0x1, %bpl
setne %dl
orb %al, %dl
je 0x681b0
andb %al, %cl
testb %cl, %cl
je 0x6817a
movb $0x1, (%rbx)
movl $0x20, %edi
callq 0x1c160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
testq %r15, %r15
je 0x68194
shlq $0x3, %r15
leaq (%r15,%r15,2), %r12
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x87498
movq 0x8(%rbx), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rdx), %rsi
addq $0x10, %rdx
callq 0x31554
movq %r15, %rdi
xorl %esi, %esi
callq 0x732fc
movq %r15, %rdi
callq 0x300e0
addq $0x18, %r14
addq $-0x18, %r12
jne 0x68138
jmp 0x68194
movb $0x2, (%rbx)
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x20(%rsp), %rsi
movq %r12, (%rsi)
callq 0x874ea
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x732fc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1c460
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x65662(%rip), %rsi # 0xcd830
leaq 0x65685(%rip), %rdx # 0xcd85a
movq %rsp, %rdi
callq 0x3fe82
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x12d, %esi # imm = 0x12D
xorl %ecx, %ecx
callq 0x34e2a
xorl %ebp, %ebp
leaq 0x95ce5(%rip), %rsi # 0xfdee0
leaq -0x3a9fc(%rip), %rdx # 0x2d806
movq %r14, %rdi
callq 0x1c7b0
jmp 0x68210
jmp 0x68210
jmp 0x68210
movq %rax, %r15
jmp 0x6825a
movq %rax, %r15
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x732fc
movq %r14, %rdi
callq 0x300e0
jmp 0x6825a
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x68248
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1c110
testb %bpl, %bpl
jne 0x68252
jmp 0x6825a
movq %rax, %r15
movq %r14, %rdi
callq 0x1caa0
movq %rbx, %rdi
callq 0x300e0
movq %r15, %rdi
callq 0x1c7d0
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE:
push rbp; __int64
push r15; int
push r14; void *
push r13; int
push r12; __int64
push rbx; int
sub rsp, 28h
mov ebp, r8d
mov r13d, ecx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
lea rax, [rdx+rdx*2]
lea r12, [rsi+rax*8]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rdi, rsi
mov rsi, r12
call _ZSt9__find_ifIPKN8nlohmann16json_abi_v3_11_36detail8json_refINS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEN9__gnu_cxx5__ops12_Iter_negateIZNSG_C1ESt16initializer_listISH_EbNS2_7value_tEEUlRSI_E_EEET_ST_ST_T0_St26random_access_iterator_tag; std::__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<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*,__gnu_cxx::__ops::_Iter_negate<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::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<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&)#1}>>(nlohmann::json_abi_v3_11_3::detail::json_ref<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::detail::json_ref<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*,__gnu_cxx::__ops::_Iter_negate<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::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<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&)#1}>,std::random_access_iterator_tag)
cmp rax, r12
setz cl
test r13b, r13b
jnz short loc_68105
cmp rax, r12
setz al
cmp bpl, 2
setnz cl
cmp bpl, 1
setnz dl
or dl, al
jz loc_681B0
and cl, al
loc_68105:
test cl, cl
jz short loc_6817A
mov byte ptr [rbx], 1
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [rbx+8], rax
test r15, r15
jz short loc_68194
shl r15, 3
lea r12, [r15+r15*2]
mov r15, rsp
loc_68138:
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<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>>::moved_or_copied(void)
mov rdi, [rbx+8]
mov rax, [rsp+58h+var_50]
mov rdx, [rax]
mov rsi, [rdx+8]
add rdx, 10h
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add r14, 18h
add r12, 0FFFFFFFFFFFFFFE8h
jnz short loc_68138
jmp short loc_68194
loc_6817A:
mov byte ptr [rbx], 2
mov rdi, rsp
mov [rdi], r14
lea rsi, [rsp+58h+var_38]
mov [rsi], r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJPKNS0_6detail8json_refISD_EESL_EEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::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>>,nlohmann::json_abi_v3_11_3::detail::json_ref<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::detail::json_ref<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::detail::json_ref<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::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const* &&)
mov [rbx+8], rax
loc_68194:
mov rdi, rbx
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)
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_681B0:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r12, [rsp+58h+var_48]
mov [r12-10h], r12
lea rsi, aCannotCreateOb; "cannot create object from initializer l"...
lea rdx, aCannotCreateOb+2Ah; ""
mov rdi, rsp
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 bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 12Dh; int
xor ecx, ecx
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_68210
jmp short loc_68210
jmp short $+2
loc_68210:
mov r15, rax
jmp short loc_6825A
mov r15, rax
mov r14, rsp
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_6825A
mov r15, rax
mov rdi, [rsp+58h+var_58]; void *
cmp rdi, r12
jz short loc_68248
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_68248:
test bpl, bpl
jnz short loc_68252
jmp short loc_6825A
mov r15, rax
loc_68252:
mov rdi, r14; void *
call ___cxa_free_exception
loc_6825A:
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, r15
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
long long a1,
char *a2,
long long a3,
char a4,
char a5)
{
char *v8; // r14
char *v9; // r12
long long v10; // rax
bool v11; // cl
bool v12; // al
long long v13; // rax
long long v14; // r12
nlohmann::json_abi_v3_11_3::detail::exception *exception; // r14
void *v17; // [rsp+0h] [rbp-58h] BYREF
long long v18; // [rsp+8h] [rbp-50h]
_QWORD v19[9]; // [rsp+10h] [rbp-48h] BYREF
v8 = a2;
v9 = &a2[24 * a3];
*(_OWORD *)a1 = 0LL;
v10 = std::__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<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*,__gnu_cxx::__ops::_Iter_negate<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::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<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>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<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&)#1}>>(
a2,
v9);
v11 = v10 == (_QWORD)v9;
if ( !a4 )
{
v12 = v10 == (_QWORD)v9;
if ( !v12 && a5 == 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v17 = v19;
std::string::_M_construct<char const*>((long long)&v17, "cannot create object from initializer list", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
exception,
301,
&v17);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v11 = v12 && a5 != 2;
}
if ( v11 )
{
*(_BYTE *)a1 = 1;
v13 = operator new(0x20uLL);
*(_OWORD *)v13 = 0LL;
*(_QWORD *)(v13 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v13;
if ( a3 )
{
v14 = 24 * a3;
do
{
nlohmann::json_abi_v3_11_3::detail::json_ref<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>>::moved_or_copied(
&v17,
v8);
nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
*(_QWORD **)(a1 + 8),
*(long long **)(*(_QWORD *)v18 + 8LL),
*(_QWORD *)v18 + 16LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v17,
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>::data::~data(&v17);
v8 += 24;
v14 -= 24LL;
}
while ( v14 );
}
}
else
{
*(_BYTE *)a1 = 2;
v17 = a2;
v19[2] = v9;
*(_QWORD *)(a1 + 8) = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::create<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>>,nlohmann::json_abi_v3_11_3::detail::json_ref<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*,nlohmann::json_abi_v3_11_3::detail::json_ref<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*>(&v17);
}
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a1,
1LL);
}
|
basic_json:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,R8D
MOV R13D,ECX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDX + RDX*0x2]
LEA R12,[RSI + RAX*0x8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_001680d1:
MOV RDI,RSI
MOV RSI,R12
CALL 0x0018753e
CMP RAX,R12
SETZ CL
TEST R13B,R13B
JNZ 0x00168105
CMP RAX,R12
SETZ AL
CMP BPL,0x2
SETNZ CL
CMP BPL,0x1
SETNZ DL
OR DL,AL
JZ 0x001681b0
AND CL,AL
LAB_00168105:
TEST CL,CL
JZ 0x0016817a
MOV byte ptr [RBX],0x1
LAB_0016810c:
MOV EDI,0x20
CALL 0x0011c160
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [RBX + 0x8],RAX
TEST R15,R15
JZ 0x00168194
SHL R15,0x3
LEA R12,[R15 + R15*0x2]
MOV R15,RSP
LAB_00168138:
MOV RDI,R15
MOV RSI,R14
CALL 0x00187498
MOV RDI,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RAX]
MOV RSI,qword ptr [RDX + 0x8]
ADD RDX,0x10
LAB_00168157:
CALL 0x00131554
MOV RDI,R15
XOR ESI,ESI
CALL 0x001732fc
MOV RDI,R15
CALL 0x001300e0
ADD R14,0x18
ADD R12,-0x18
JNZ 0x00168138
JMP 0x00168194
LAB_0016817a:
MOV byte ptr [RBX],0x2
MOV RDI,RSP
MOV qword ptr [RDI],R14
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI],R12
LAB_0016818b:
CALL 0x001874ea
LAB_00168190:
MOV qword ptr [RBX + 0x8],RAX
LAB_00168194:
MOV RDI,RBX
MOV ESI,0x1
CALL 0x001732fc
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001681b0:
MOV EDI,0x20
CALL 0x0011c460
MOV R14,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
LAB_001681c7:
LEA RSI,[0x1cd830]
LEA RDX,[0x1cd85a]
MOV RDI,RSP
CALL 0x0013fe82
MOV BPL,0x1
LAB_001681e0:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x12d
XOR ECX,ECX
CALL 0x00134e2a
XOR EBP,EBP
LEA RSI,[0x1fdee0]
LEA RDX,[0x12d806]
MOV RDI,R14
CALL 0x0011c7b0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > >, bool, nlohmann::json_abi_v3_11_3::detail::value_t) */
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>
::basic_json(int8 *param_1,json_ref *param_2,long param_3,char param_4,char param_5)
{
json_ref *pjVar1;
json_ref *pjVar2;
int8 *puVar3;
vector *pvVar4;
int8 uVar5;
bool bVar6;
json_ref *local_58;
long *local_50;
json_ref local_48 [16];
json_ref *local_38;
pjVar1 = param_2 + param_3 * 0x18;
*param_1 = 0;
param_1[1] = 0;
/* try { // try from 001680d1 to 001680db has its CatchHandler @ 0016820e */
pjVar2 = std::
__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<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*,__gnu_cxx::__ops::_Iter_negate<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>::_Iter_negate(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::_lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<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&)_1_>>
(param_2,pjVar1);
bVar6 = pjVar2 == pjVar1;
if (param_4 == '\0') {
if (param_5 == '\x01' && pjVar2 != pjVar1) {
uVar5 = __cxa_allocate_exception(0x20);
local_58 = local_48;
/* try { // try from 001681c7 to 001681dc has its CatchHandler @ 0016824f */
std::__cxx11::string::_M_construct<char_const*>
(&local_58,"cannot create object from initializer list","");
/* try { // try from 001681e0 to 00168209 has its CatchHandler @ 0016822f */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(uVar5,0x12d,&local_58,0);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,&detail::type_error::typeinfo,detail::exception::~exception);
}
bVar6 = param_5 != '\x02' && pjVar2 == pjVar1;
}
if (bVar6) {
*(int1 *)param_1 = 1;
/* try { // try from 0016810c to 00168115 has its CatchHandler @ 0016820c */
puVar3 = (int8 *)operator_new(0x20);
*puVar3 = 0;
puVar3[1] = 0;
puVar3[2] = 0;
param_1[1] = puVar3;
if (param_3 != 0) {
param_3 = param_3 * 0x18;
do {
/* try { // try from 00168138 to 00168142 has its CatchHandler @ 00168210 */
detail::
json_ref<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>>
::moved_or_copied();
/* try { // try from 00168157 to 0016815b has its CatchHandler @ 00168215 */
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::emplace((ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)param_1[1],*(string **)(*local_50 + 8),(basic_json *)(*local_50 + 0x10));
assert_invariant(SUB81(&local_58,0));
data::~data((data *)&local_58);
param_3 = param_3 + -0x18;
} while (param_3 != 0);
}
}
else {
*(int1 *)param_1 = 2;
local_58 = param_2;
local_38 = pjVar1;
/* try { // try from 0016818b to 0016818f has its CatchHandler @ 0016820a */
pvVar4 = create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,nlohmann::json_abi_v3_11_3::detail::json_ref<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*,nlohmann::json_abi_v3_11_3::detail::json_ref<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*>
(&local_58,&local_38);
param_1[1] = pvVar4;
}
assert_invariant(SUB81(param_1,0));
return;
}
|
|
11,373 |
init_queue
|
eloqsql/mysys/queues.c
|
int init_queue(QUEUE *queue, uint max_elements, uint offset_to_key,
my_bool max_at_top, int (*compare) (void *, uchar *, uchar *),
void *first_cmp_arg, uint offset_to_queue_pos,
uint auto_extent)
{
DBUG_ENTER("init_queue");
if ((queue->root= (uchar **) my_malloc(key_memory_QUEUE,
(max_elements + 1) * sizeof(void*),
MYF(MY_WME))) == 0)
DBUG_RETURN(1);
queue->elements= 0;
queue->compare= compare;
queue->first_cmp_arg= first_cmp_arg;
queue->max_elements= max_elements;
queue->offset_to_key= offset_to_key;
queue->offset_to_queue_pos= offset_to_queue_pos;
queue->auto_extent= auto_extent;
queue_set_max_at_top(queue, max_at_top);
DBUG_RETURN(0);
}
|
O0
|
c
|
init_queue:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movl 0x18(%rbp), %ecx
movl 0x10(%rbp), %ecx
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0xb8c314(%rip), %rax # 0xc832d0
movl (%rax), %edi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x3, %rsi
movl $0x10, %edx
callq 0xf3860
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xf6fee
jmp 0xf6fe5
movl $0x1, -0x4(%rbp)
jmp 0xf705b
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl 0x10(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl 0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movsbl -0x19(%rbp), %edx
movl $0x1, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
init_queue:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, cl
mov ecx, [rbp+arg_8]
mov ecx, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_19], al
mov [rbp+var_28], r8
mov [rbp+var_30], r9
lea rax, key_memory_QUEUE
mov edi, [rax]
mov eax, [rbp+var_14]
add eax, 1
mov eax, eax
mov esi, eax
shl rsi, 3
mov edx, 10h
call my_malloc
mov rcx, [rbp+var_10]
mov [rcx], rax
cmp rax, 0
jnz short loc_F6FEE
jmp short $+2
loc_F6FE5:
mov [rbp+var_4], 1
jmp short loc_F705B
loc_F6FEE:
mov rax, [rbp+var_10]
mov dword ptr [rax+10h], 0
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+28h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
mov ecx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax+18h], ecx
mov ecx, [rbp+arg_0]
mov rax, [rbp+var_10]
mov [rax+1Ch], ecx
mov ecx, [rbp+arg_8]
mov rax, [rbp+var_10]
mov [rax+20h], ecx
movsx edx, [rbp+var_19]
mov ecx, 1
mov eax, 0FFFFFFFFh
cmp edx, 0
cmovnz ecx, eax
mov rax, [rbp+var_10]
mov [rax+24h], ecx
mov [rbp+var_4], 0
loc_F705B:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long init_queue(long long a1, int a2, int a3, char a4, long long a5, long long a6, int a7, int a8)
{
long long v8; // rax
int v9; // ecx
v8 = my_malloc(key_memory_QUEUE, (const char *)(8LL * (unsigned int)(a2 + 1)), 16);
*(_QWORD *)a1 = v8;
if ( v8 )
{
*(_DWORD *)(a1 + 16) = 0;
*(_QWORD *)(a1 + 40) = a5;
*(_QWORD *)(a1 + 8) = a6;
*(_DWORD *)(a1 + 20) = a2;
*(_DWORD *)(a1 + 24) = a3;
*(_DWORD *)(a1 + 28) = a7;
*(_DWORD *)(a1 + 32) = a8;
v9 = 1;
if ( a4 )
v9 = -1;
*(_DWORD *)(a1 + 36) = v9;
return 0;
}
else
{
return 1;
}
}
|
init_queue:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,CL
MOV ECX,dword ptr [RBP + 0x18]
MOV ECX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV byte ptr [RBP + -0x19],AL
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0xd832d0]
MOV EDI,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV EAX,EAX
MOV ESI,EAX
SHL RSI,0x3
MOV EDX,0x10
CALL 0x001f3860
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x001f6fee
JMP 0x001f6fe5
LAB_001f6fe5:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001f705b
LAB_001f6fee:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x10],0x0
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x18],ECX
MOV ECX,dword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x1c],ECX
MOV ECX,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x20],ECX
MOVSX EDX,byte ptr [RBP + -0x19]
MOV ECX,0x1
MOV EAX,0xffffffff
CMP EDX,0x0
CMOVNZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x24],ECX
MOV dword ptr [RBP + -0x4],0x0
LAB_001f705b:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4
init_queue(long *param_1,int param_2,int4 param_3,char param_4,long param_5,long param_6,
int4 param_7,int4 param_8)
{
long lVar1;
int4 uVar2;
int4 local_c;
lVar1 = my_malloc(key_memory_QUEUE,(ulong)(param_2 + 1) << 3,0x10,param_7);
*param_1 = lVar1;
if (lVar1 == 0) {
local_c = 1;
}
else {
*(int4 *)(param_1 + 2) = 0;
param_1[5] = param_5;
param_1[1] = param_6;
*(int *)((long)param_1 + 0x14) = param_2;
*(int4 *)(param_1 + 3) = param_3;
*(int4 *)((long)param_1 + 0x1c) = param_7;
*(int4 *)(param_1 + 4) = param_8;
uVar2 = 1;
if (param_4 != '\0') {
uVar2 = 0xffffffff;
}
*(int4 *)((long)param_1 + 0x24) = uVar2;
local_c = 0;
}
return local_c;
}
|
|
11,374 |
pfs_start_rwlock_wrwait_v1
|
eloqsql/storage/perfschema/pfs.cc
|
PSI_rwlock_locker*
pfs_start_rwlock_wrwait_v1(PSI_rwlock_locker_state *state,
PSI_rwlock *rwlock,
PSI_rwlock_operation op,
const char *src_file, uint src_line)
{
assert((op == PSI_RWLOCK_WRITELOCK) ||
(op == PSI_RWLOCK_TRYWRITELOCK) ||
(op == PSI_RWLOCK_SHAREDEXCLUSIVELOCK) ||
(op == PSI_RWLOCK_TRYSHAREDEXCLUSIVELOCK) ||
(op == PSI_RWLOCK_EXCLUSIVELOCK) ||
(op == PSI_RWLOCK_TRYEXCLUSIVELOCK));
return pfs_start_rwlock_wait_v1(state, rwlock, op, src_file, src_line);
}
|
O3
|
cpp
|
pfs_start_rwlock_wrwait_v1:
pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x28cce
|
pfs_start_rwlock_wrwait_v1:
push rbp
mov rbp, rsp
pop rbp
jmp pfs_start_rwlock_wait_v1
|
long long pfs_start_rwlock_wrwait_v1(long long a1, long long a2, int a3, long long a4, int a5)
{
return pfs_start_rwlock_wait_v1(a1, a2, a3, a4, a5);
}
|
pfs_start_rwlock_wrwait_v1:
PUSH RBP
MOV RBP,RSP
POP RBP
JMP 0x00128cce
|
void pfs_start_rwlock_wrwait_v1(void)
{
pfs_start_rwlock_wait_v1();
return;
}
|
|
11,375 |
seal_template_obj
|
bluesky950520[P]quickjs/quickjs.c
|
static int seal_template_obj(JSContext *ctx, JSValue obj)
{
JSObject *p;
JSShapeProperty *prs;
p = JS_VALUE_GET_OBJ(obj);
prs = find_own_property1(p, JS_ATOM_length);
if (prs) {
if (js_update_property_flags(ctx, p, &prs,
prs->flags & ~(JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)))
return -1;
}
p->extensible = FALSE;
return 0;
}
|
O1
|
c
|
seal_template_obj:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x18(%rsi), %rax
movl 0x20(%rax), %ecx
notl %ecx
orl $-0x33, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
testl %edx, %edx
je 0x6a592
addq $0x40, %rax
xorl %ecx, %ecx
movl $0x3ffffff, %esi # imm = 0x3FFFFFF
movl %edx, %edx
leaq (%rax,%rdx,8), %rdx
addq $-0x8, %rdx
cmpl $0x32, 0x4(%rdx)
je 0x6a58d
movl (%rdx), %edx
andl %esi, %edx
jne 0x6a575
jmp 0x6a594
movq %rdx, %rcx
jmp 0x6a594
xorl %ecx, %ecx
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0x6a5b7
movl (%rcx), %ecx
shrl $0x1a, %ecx
andl $-0x4, %ecx
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq 0x2676e
testl %eax, %eax
jne 0x6a5bb
andb $-0x2, 0x5(%rbx)
addq $0x10, %rsp
popq %rbx
retq
|
seal_template_obj:
push rbx
sub rsp, 10h
mov rbx, rsi
mov rax, [rsi+18h]
mov ecx, [rax+20h]
not ecx
or ecx, 0FFFFFFCDh
movsxd rcx, ecx
mov edx, [rax+rcx*4]
test edx, edx
jz short loc_6A592
add rax, 40h ; '@'
xor ecx, ecx
mov esi, 3FFFFFFh
loc_6A575:
mov edx, edx
lea rdx, [rax+rdx*8]
add rdx, 0FFFFFFFFFFFFFFF8h
cmp dword ptr [rdx+4], 32h ; '2'
jz short loc_6A58D
mov edx, [rdx]
and edx, esi
jnz short loc_6A575
jmp short loc_6A594
loc_6A58D:
mov rcx, rdx
jmp short loc_6A594
loc_6A592:
xor ecx, ecx
loc_6A594:
mov [rsp+18h+var_10], rcx
test rcx, rcx
jz short loc_6A5B7
mov ecx, [rcx]
shr ecx, 1Ah
and ecx, 0FFFFFFFCh
lea rdx, [rsp+18h+var_10]
mov rsi, rbx
call js_update_property_flags
test eax, eax
jnz short loc_6A5BB
loc_6A5B7:
and byte ptr [rbx+5], 0FEh
loc_6A5BB:
add rsp, 10h
pop rbx
retn
|
long long seal_template_obj(long long a1, long long a2)
{
long long result; // rax
unsigned int v3; // edx
_DWORD *v4; // rcx
_DWORD *v5; // rdx
_DWORD *v6; // [rsp+8h] [rbp-10h] BYREF
result = *(_QWORD *)(a2 + 24);
v3 = *(_DWORD *)(result + 4LL * (int)(~*(_BYTE *)(result + 32) | 0xFFFFFFCD));
if ( v3 )
{
result += 64LL;
v4 = 0LL;
while ( 1 )
{
v5 = (_DWORD *)(result + 8LL * v3 - 8);
if ( v5[1] == 50 )
break;
v3 = *v5 & 0x3FFFFFF;
if ( !v3 )
goto LABEL_8;
}
v4 = v5;
}
else
{
v4 = 0LL;
}
LABEL_8:
v6 = v4;
if ( !v4 || (result = js_update_property_flags(a1, a2, &v6, (*v4 >> 26) & 0xFFFFFFFC), !(_DWORD)result) )
*(_BYTE *)(a2 + 5) &= ~1u;
return result;
}
| |||
11,376 |
seal_template_obj
|
bluesky950520[P]quickjs/quickjs.c
|
static int seal_template_obj(JSContext *ctx, JSValue obj)
{
JSObject *p;
JSShapeProperty *prs;
p = JS_VALUE_GET_OBJ(obj);
prs = find_own_property1(p, JS_ATOM_length);
if (prs) {
if (js_update_property_flags(ctx, p, &prs,
prs->flags & ~(JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)))
return -1;
}
p->extensible = FALSE;
return 0;
}
|
O2
|
c
|
seal_template_obj:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x18(%rsi), %rax
movl 0x20(%rax), %ecx
notl %ecx
orl $-0x33, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addq $0x40, %rax
movl $0x3ffffff, %ecx # imm = 0x3FFFFFF
testl %edx, %edx
je 0x59fce
movl %edx, %edx
leaq (%rax,%rdx,8), %rdx
addq $-0x8, %rdx
cmpl $0x32, 0x4(%rdx)
je 0x59fab
movl (%rdx), %edx
andl %ecx, %edx
jmp 0x59f91
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
je 0x59fce
movl (%rdx), %ecx
shrl $0x1a, %ecx
andl $-0x4, %ecx
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq 0x201fa
testl %eax, %eax
jne 0x59fd2
andb $-0x2, 0x5(%rbx)
addq $0x10, %rsp
popq %rbx
retq
|
seal_template_obj:
push rbx
sub rsp, 10h
mov rbx, rsi
mov rax, [rsi+18h]
mov ecx, [rax+20h]
not ecx
or ecx, 0FFFFFFCDh
movsxd rcx, ecx
mov edx, [rax+rcx*4]
add rax, 40h ; '@'
mov ecx, 3FFFFFFh
loc_59F91:
test edx, edx
jz short loc_59FCE
mov edx, edx
lea rdx, [rax+rdx*8]
add rdx, 0FFFFFFFFFFFFFFF8h
cmp dword ptr [rdx+4], 32h ; '2'
jz short loc_59FAB
mov edx, [rdx]
and edx, ecx
jmp short loc_59F91
loc_59FAB:
mov [rsp+18h+var_10], rdx
test rdx, rdx
jz short loc_59FCE
mov ecx, [rdx]
shr ecx, 1Ah
and ecx, 0FFFFFFFCh
lea rdx, [rsp+18h+var_10]
mov rsi, rbx
call js_update_property_flags
test eax, eax
jnz short loc_59FD2
loc_59FCE:
and byte ptr [rbx+5], 0FEh
loc_59FD2:
add rsp, 10h
pop rbx
retn
|
long long seal_template_obj(long long a1, long long a2)
{
long long v2; // rax
unsigned int v3; // edx
long long result; // rax
_DWORD *v5; // rdx
_DWORD *v6; // [rsp+8h] [rbp-10h] BYREF
v2 = *(_QWORD *)(a2 + 24);
v3 = *(_DWORD *)(v2 + 4LL * (int)(~*(_BYTE *)(v2 + 32) | 0xFFFFFFCD));
result = v2 + 64;
while ( 1 )
{
if ( !v3 )
goto LABEL_7;
v5 = (_DWORD *)(result + 8LL * v3 - 8);
if ( v5[1] == 50 )
break;
v3 = *v5 & 0x3FFFFFF;
}
v6 = v5;
if ( !v5 || (result = js_update_property_flags(a1, a2, &v6, (*v5 >> 26) & 0xFFFFFFFC), !(_DWORD)result) )
LABEL_7:
*(_BYTE *)(a2 + 5) &= ~1u;
return result;
}
|
seal_template_obj:
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV RAX,qword ptr [RSI + 0x18]
MOV ECX,dword ptr [RAX + 0x20]
NOT ECX
OR ECX,0xffffffcd
MOVSXD RCX,ECX
MOV EDX,dword ptr [RAX + RCX*0x4]
ADD RAX,0x40
MOV ECX,0x3ffffff
LAB_00159f91:
TEST EDX,EDX
JZ 0x00159fce
MOV EDX,EDX
LEA RDX,[RAX + RDX*0x8]
ADD RDX,-0x8
CMP dword ptr [RDX + 0x4],0x32
JZ 0x00159fab
MOV EDX,dword ptr [RDX]
AND EDX,ECX
JMP 0x00159f91
LAB_00159fab:
MOV qword ptr [RSP + 0x8],RDX
TEST RDX,RDX
JZ 0x00159fce
MOV ECX,dword ptr [RDX]
SHR ECX,0x1a
AND ECX,0xfffffffc
LEA RDX,[RSP + 0x8]
MOV RSI,RBX
CALL 0x001201fa
TEST EAX,EAX
JNZ 0x00159fd2
LAB_00159fce:
AND byte ptr [RBX + 0x5],0xfe
LAB_00159fd2:
ADD RSP,0x10
POP RBX
RET
|
void seal_template_obj(int8 param_1,long param_2)
{
long lVar1;
long lVar2;
int iVar3;
uint uVar4;
uint *local_10;
lVar2 = *(long *)(param_2 + 0x18);
uVar4 = *(uint *)(lVar2 + (long)(int)(~*(uint *)(lVar2 + 0x20) | 0xffffffcd) * 4);
do {
if (uVar4 == 0) {
LAB_00159fce:
*(byte *)(param_2 + 5) = *(byte *)(param_2 + 5) & 0xfe;
return;
}
lVar1 = lVar2 + 0x40 + (ulong)uVar4 * 8;
local_10 = (uint *)(lVar1 + -8);
if (*(int *)(lVar1 + -4) == 0x32) {
if ((local_10 != (uint *)0x0) &&
(iVar3 = js_update_property_flags(param_1,param_2,&local_10,*local_10 >> 0x1a & 0xfffffffc)
, iVar3 != 0)) {
return;
}
goto LAB_00159fce;
}
uVar4 = *local_10 & 0x3ffffff;
} while( true );
}
|
|
11,377 |
google::protobuf::strto32_adaptor(char const*, char**, int)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/strutil.cc
|
int32_t strto32_adaptor(const char *nptr, char **endptr, int base) {
const int saved_errno = errno;
errno = 0;
const long result = strtol(nptr, endptr, base);
if (errno == ERANGE && result == LONG_MIN) {
return std::numeric_limits<int32_t>::min();
} else if (errno == ERANGE && result == LONG_MAX) {
return std::numeric_limits<int32_t>::max();
} else if (errno == 0 && result < std::numeric_limits<int32_t>::min()) {
errno = ERANGE;
return std::numeric_limits<int32_t>::min();
} else if (errno == 0 && result > std::numeric_limits<int32_t>::max()) {
errno = ERANGE;
return std::numeric_limits<int32_t>::max();
}
if (errno == 0)
errno = saved_errno;
return static_cast<int32_t>(result);
}
|
O0
|
cpp
|
google::protobuf::strto32_adaptor(char const*, char**, int):
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
callq 0x13060
movl (%rax), %eax
movl %eax, 0x28(%rsp)
callq 0x13060
movl $0x0, (%rax)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x13630
movq %rax, 0x20(%rsp)
callq 0x13060
cmpl $0x22, (%rax)
jne 0x289d9
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, 0x20(%rsp)
jne 0x289d9
callq 0x305b0
movl %eax, 0x44(%rsp)
jmp 0x28aaa
callq 0x13060
cmpl $0x22, (%rax)
jne 0x28a02
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, 0x20(%rsp)
jne 0x28a02
callq 0x305c0
movl %eax, 0x44(%rsp)
jmp 0x28aaa
callq 0x13060
cmpl $0x0, (%rax)
jne 0x28a40
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x305b0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x28a40
callq 0x13060
movl $0x22, (%rax)
callq 0x305b0
movl %eax, 0x44(%rsp)
jmp 0x28aaa
callq 0x13060
cmpl $0x0, (%rax)
jne 0x28a7e
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x305c0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0x28a7e
callq 0x13060
movl $0x22, (%rax)
callq 0x305c0
movl %eax, 0x44(%rsp)
jmp 0x28aaa
jmp 0x28a80
jmp 0x28a82
jmp 0x28a84
callq 0x13060
cmpl $0x0, (%rax)
jne 0x28aa1
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x13060
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZN6google8protobuf15strto32_adaptorEPKcPPci:
sub rsp, 48h
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_1C], edx
call ___errno_location
mov eax, [rax]
mov [rsp+48h+var_20], eax
call ___errno_location
mov dword ptr [rax], 0
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_18]
mov edx, [rsp+48h+var_1C]
call _strtol
mov [rsp+48h+var_28], rax
call ___errno_location
cmp dword ptr [rax], 22h ; '"'
jnz short loc_289D9
mov rax, 8000000000000000h
cmp [rsp+48h+var_28], rax
jnz short loc_289D9
call _ZNSt14numeric_limitsIiE3minEv; std::numeric_limits<int>::min(void)
mov [rsp+48h+var_4], eax
jmp loc_28AAA
loc_289D9:
call ___errno_location
cmp dword ptr [rax], 22h ; '"'
jnz short loc_28A02
mov rax, 7FFFFFFFFFFFFFFFh
cmp [rsp+48h+var_28], rax
jnz short loc_28A02
call _ZNSt14numeric_limitsIiE3maxEv; std::numeric_limits<int>::max(void)
mov [rsp+48h+var_4], eax
jmp loc_28AAA
loc_28A02:
call ___errno_location
cmp dword ptr [rax], 0
jnz short loc_28A40
mov rax, [rsp+48h+var_28]
mov [rsp+48h+var_30], rax
call _ZNSt14numeric_limitsIiE3minEv; std::numeric_limits<int>::min(void)
mov ecx, eax
mov rax, [rsp+48h+var_30]
movsxd rcx, ecx
cmp rax, rcx
jge short loc_28A40
call ___errno_location
mov dword ptr [rax], 22h ; '"'
call _ZNSt14numeric_limitsIiE3minEv; std::numeric_limits<int>::min(void)
mov [rsp+48h+var_4], eax
jmp short loc_28AAA
loc_28A40:
call ___errno_location
cmp dword ptr [rax], 0
jnz short loc_28A7E
mov rax, [rsp+48h+var_28]
mov [rsp+48h+var_38], rax
call _ZNSt14numeric_limitsIiE3maxEv; std::numeric_limits<int>::max(void)
mov ecx, eax
mov rax, [rsp+48h+var_38]
movsxd rcx, ecx
cmp rax, rcx
jle short loc_28A7E
call ___errno_location
mov dword ptr [rax], 22h ; '"'
call _ZNSt14numeric_limitsIiE3maxEv; std::numeric_limits<int>::max(void)
mov [rsp+48h+var_4], eax
jmp short loc_28AAA
loc_28A7E:
jmp short $+2
loc_28A80:
jmp short $+2
loc_28A82:
jmp short $+2
loc_28A84:
call ___errno_location
cmp dword ptr [rax], 0
jnz short loc_28AA1
mov eax, [rsp+48h+var_20]
mov [rsp+48h+var_3C], eax
call ___errno_location
mov ecx, [rsp+48h+var_3C]
mov [rax], ecx
loc_28AA1:
mov rax, [rsp+48h+var_28]
mov [rsp+48h+var_4], eax
loc_28AAA:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
|
long long google::protobuf::strto32_adaptor(google::protobuf *this, const char *a2, char **a3)
{
long long v4; // [rsp+20h] [rbp-28h]
int v5; // [rsp+28h] [rbp-20h]
unsigned int v6; // [rsp+2Ch] [rbp-1Ch]
v6 = (unsigned int)a3;
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)__errno_location() = 0;
v4 = strtol(this, a2, v6);
if ( *(_DWORD *)__errno_location() == 34 && v4 == 0x8000000000000000LL )
{
return (unsigned int)std::numeric_limits<int>::min();
}
else if ( *(_DWORD *)__errno_location() == 34 && v4 == 0x7FFFFFFFFFFFFFFFLL )
{
return (unsigned int)std::numeric_limits<int>::max();
}
else if ( *(_DWORD *)__errno_location() || v4 >= (int)std::numeric_limits<int>::min() )
{
if ( *(_DWORD *)__errno_location() || v4 <= (int)std::numeric_limits<int>::max() )
{
if ( !*(_DWORD *)__errno_location() )
*(_DWORD *)__errno_location() = v5;
return (unsigned int)v4;
}
else
{
*(_DWORD *)__errno_location() = 34;
return (unsigned int)std::numeric_limits<int>::max();
}
}
else
{
*(_DWORD *)__errno_location() = 34;
return (unsigned int)std::numeric_limits<int>::min();
}
}
|
strto32_adaptor:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RDI
MOV qword ptr [RSP + 0x30],RSI
MOV dword ptr [RSP + 0x2c],EDX
CALL 0x00113060
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x28],EAX
CALL 0x00113060
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x30]
MOV EDX,dword ptr [RSP + 0x2c]
CALL 0x00113630
MOV qword ptr [RSP + 0x20],RAX
CALL 0x00113060
CMP dword ptr [RAX],0x22
JNZ 0x001289d9
MOV RAX,-0x8000000000000000
CMP qword ptr [RSP + 0x20],RAX
JNZ 0x001289d9
CALL 0x001305b0
MOV dword ptr [RSP + 0x44],EAX
JMP 0x00128aaa
LAB_001289d9:
CALL 0x00113060
CMP dword ptr [RAX],0x22
JNZ 0x00128a02
MOV RAX,0x7fffffffffffffff
CMP qword ptr [RSP + 0x20],RAX
JNZ 0x00128a02
CALL 0x001305c0
MOV dword ptr [RSP + 0x44],EAX
JMP 0x00128aaa
LAB_00128a02:
CALL 0x00113060
CMP dword ptr [RAX],0x0
JNZ 0x00128a40
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x18],RAX
CALL 0x001305b0
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x18]
MOVSXD RCX,ECX
CMP RAX,RCX
JGE 0x00128a40
CALL 0x00113060
MOV dword ptr [RAX],0x22
CALL 0x001305b0
MOV dword ptr [RSP + 0x44],EAX
JMP 0x00128aaa
LAB_00128a40:
CALL 0x00113060
CMP dword ptr [RAX],0x0
JNZ 0x00128a7e
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001305c0
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,ECX
CMP RAX,RCX
JLE 0x00128a7e
CALL 0x00113060
MOV dword ptr [RAX],0x22
CALL 0x001305c0
MOV dword ptr [RSP + 0x44],EAX
JMP 0x00128aaa
LAB_00128a7e:
JMP 0x00128a80
LAB_00128a80:
JMP 0x00128a82
LAB_00128a82:
JMP 0x00128a84
LAB_00128a84:
CALL 0x00113060
CMP dword ptr [RAX],0x0
JNZ 0x00128aa1
MOV EAX,dword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0xc],EAX
CALL 0x00113060
MOV ECX,dword ptr [RSP + 0xc]
MOV dword ptr [RAX],ECX
LAB_00128aa1:
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x44],EAX
LAB_00128aaa:
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
/* google::protobuf::strto32_adaptor(char const*, char**, int) */
int4 google::protobuf::strto32_adaptor(char *param_1,char **param_2,int param_3)
{
int iVar1;
int iVar2;
int4 uVar3;
int *piVar4;
long lVar5;
int4 local_4;
piVar4 = __errno_location();
iVar1 = *piVar4;
piVar4 = __errno_location();
*piVar4 = 0;
lVar5 = strtol(param_1,param_2,param_3);
piVar4 = __errno_location();
if ((*piVar4 == 0x22) && (lVar5 == -0x8000000000000000)) {
local_4 = std::numeric_limits<int>::min();
}
else {
piVar4 = __errno_location();
if ((*piVar4 == 0x22) && (lVar5 == 0x7fffffffffffffff)) {
local_4 = std::numeric_limits<int>::max();
}
else {
piVar4 = __errno_location();
if ((*piVar4 == 0) && (iVar2 = std::numeric_limits<int>::min(), lVar5 < iVar2)) {
piVar4 = __errno_location();
*piVar4 = 0x22;
uVar3 = std::numeric_limits<int>::min();
return uVar3;
}
piVar4 = __errno_location();
if ((*piVar4 == 0) && (iVar2 = std::numeric_limits<int>::max(), iVar2 < lVar5)) {
piVar4 = __errno_location();
*piVar4 = 0x22;
uVar3 = std::numeric_limits<int>::max();
return uVar3;
}
piVar4 = __errno_location();
if (*piVar4 == 0) {
piVar4 = __errno_location();
*piVar4 = iVar1;
}
local_4 = (int4)lVar5;
}
}
return local_4;
}
|
|
11,378 |
google::protobuf::strto32_adaptor(char const*, char**, int)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/strutil.cc
|
int32_t strto32_adaptor(const char *nptr, char **endptr, int base) {
const int saved_errno = errno;
errno = 0;
const long result = strtol(nptr, endptr, base);
if (errno == ERANGE && result == LONG_MIN) {
return std::numeric_limits<int32_t>::min();
} else if (errno == ERANGE && result == LONG_MAX) {
return std::numeric_limits<int32_t>::max();
} else if (errno == 0 && result < std::numeric_limits<int32_t>::min()) {
errno = ERANGE;
return std::numeric_limits<int32_t>::min();
} else if (errno == 0 && result > std::numeric_limits<int32_t>::max()) {
errno = ERANGE;
return std::numeric_limits<int32_t>::max();
}
if (errno == 0)
errno = saved_errno;
return static_cast<int32_t>(result);
}
|
O3
|
cpp
|
google::protobuf::strto32_adaptor(char const*, char**, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
callq 0xf060
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xf470
movl (%rbx), %edx
cmpl $0x22, %edx
sete %sil
leaq 0x1(%r13), %rcx
cmpq %rcx, %rax
sete %dil
movl $0x80000000, %ecx # imm = 0x80000000
testb %dil, %sil
jne 0x1873b
cmpl $0x22, %edx
sete %sil
cmpq %r13, %rax
sete %dil
testb %dil, %sil
je 0x1871e
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
jmp 0x1873b
testl %edx, %edx
je 0x18726
movl %eax, %ecx
jmp 0x1873b
movabsq $-0x80000001, %rdx # imm = 0xFFFFFFFF7FFFFFFF
cmpq %rdx, %rax
jg 0x1874c
movl $0x22, (%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x80000000, %ecx # imm = 0x80000000
cmpq %rcx, %rax
jl 0x1875e
movl $0x22, (%rbx)
jmp 0x18717
movl %r12d, (%rbx)
jmp 0x18722
|
_ZN6google8protobuf15strto32_adaptorEPKcPPci:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, edx
mov r14, rsi
mov r15, rdi
mov r13, 7FFFFFFFFFFFFFFFh
call ___errno_location
mov rbx, rax
mov r12d, [rax]
mov dword ptr [rax], 0
mov rdi, r15
mov rsi, r14
mov edx, ebp
call _strtol
mov edx, [rbx]
cmp edx, 22h ; '"'
setz sil
lea rcx, [r13+1]
cmp rax, rcx
setz dil
mov ecx, 80000000h
test sil, dil
jnz short loc_1873B
cmp edx, 22h ; '"'
setz sil
cmp rax, r13
setz dil
test sil, dil
jz short loc_1871E
loc_18717:
mov ecx, 7FFFFFFFh
jmp short loc_1873B
loc_1871E:
test edx, edx
jz short loc_18726
loc_18722:
mov ecx, eax
jmp short loc_1873B
loc_18726:
mov rdx, 0FFFFFFFF7FFFFFFFh
cmp rax, rdx
jg short loc_1874C
mov dword ptr [rbx], 22h ; '"'
loc_1873B:
mov eax, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1874C:
mov ecx, 80000000h
cmp rax, rcx
jl short loc_1875E
mov dword ptr [rbx], 22h ; '"'
jmp short loc_18717
loc_1875E:
mov [rbx], r12d
jmp short loc_18722
|
long long google::protobuf::strto32_adaptor(google::protobuf *this, const char *a2, char **a3)
{
unsigned int v3; // ebp
int *v4; // rbx
int v5; // r12d
long long v6; // rax
int v7; // edx
unsigned int v8; // ecx
v3 = (unsigned int)a3;
v4 = (int *)__errno_location(this);
v5 = *v4;
*v4 = 0;
v6 = strtol(this, a2, v3);
v7 = *v4;
v8 = 0x80000000;
if ( v6 != 0x8000000000000000LL || *v4 != 34 )
{
if ( v6 == 0x7FFFFFFFFFFFFFFFLL && v7 == 34 )
return 0x7FFFFFFF;
if ( !v7 )
{
if ( v6 <= (long long)0xFFFFFFFF7FFFFFFFLL )
{
*v4 = 34;
return v8;
}
if ( v6 >= 0x80000000LL )
{
*v4 = 34;
return 0x7FFFFFFF;
}
*v4 = v5;
}
return (unsigned int)v6;
}
return v8;
}
|
strto32_adaptor:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV R14,RSI
MOV R15,RDI
MOV R13,0x7fffffffffffffff
CALL 0x0010f060
MOV RBX,RAX
MOV R12D,dword ptr [RAX]
MOV dword ptr [RAX],0x0
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBP
CALL 0x0010f470
MOV EDX,dword ptr [RBX]
CMP EDX,0x22
SETZ SIL
LEA RCX,[R13 + 0x1]
CMP RAX,RCX
SETZ DIL
MOV ECX,0x80000000
TEST SIL,DIL
JNZ 0x0011873b
CMP EDX,0x22
SETZ SIL
CMP RAX,R13
SETZ DIL
TEST SIL,DIL
JZ 0x0011871e
LAB_00118717:
MOV ECX,0x7fffffff
JMP 0x0011873b
LAB_0011871e:
TEST EDX,EDX
JZ 0x00118726
LAB_00118722:
MOV ECX,EAX
JMP 0x0011873b
LAB_00118726:
MOV RDX,-0x80000001
CMP RAX,RDX
JG 0x0011874c
MOV dword ptr [RBX],0x22
LAB_0011873b:
MOV EAX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011874c:
MOV ECX,0x80000000
CMP RAX,RCX
JL 0x0011875e
MOV dword ptr [RBX],0x22
JMP 0x00118717
LAB_0011875e:
MOV dword ptr [RBX],R12D
JMP 0x00118722
|
/* google::protobuf::strto32_adaptor(char const*, char**, int) */
ulong google::protobuf::strto32_adaptor(char *param_1,char **param_2,int param_3)
{
int iVar1;
int iVar2;
int *piVar3;
ulong uVar4;
piVar3 = __errno_location();
iVar1 = *piVar3;
*piVar3 = 0;
uVar4 = strtol(param_1,param_2,param_3);
iVar2 = *piVar3;
if (iVar2 == 0x22 && uVar4 == 0x8000000000000000) {
return 0x80000000;
}
if (iVar2 == 0x22 && uVar4 == 0x7fffffffffffffff) {
LAB_00118717:
uVar4 = 0x7fffffff;
}
else {
if (iVar2 == 0) {
if ((long)uVar4 < -0x80000000) {
*piVar3 = 0x22;
return 0x80000000;
}
if (0x7fffffff < (long)uVar4) {
*piVar3 = 0x22;
goto LAB_00118717;
}
*piVar3 = iVar1;
}
uVar4 = uVar4 & 0xffffffff;
}
return uVar4;
}
|
|
11,379 |
int OpenSubdiv::v3_6_0::Far::PatchMap::transformUVToTriQuadrant<double>(double const&, double&, double&, bool&)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/patchMap.h
|
int inline
PatchMap::transformUVToTriQuadrant(T const & median, T & u, T & v, bool & rotated) {
if (!rotated) {
if (u >= median) {
u -= median;
return 1;
}
if (v >= median) {
v -= median;
return 2;
}
if ((u + v) >= median) {
rotated = true;
return 3;
}
return 0;
} else {
if (u < median) {
v -= median;
return 1;
}
if (v < median) {
u -= median;
return 2;
}
u -= median;
v -= median;
if ((u + v) < median) {
rotated = false;
return 3;
}
return 0;
}
}
|
O0
|
c
|
int OpenSubdiv::v3_6_0::Far::PatchMap::transformUVToTriQuadrant<double>(double const&, double&, double&, bool&):
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, (%rax)
jne 0x13bfc6
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jb 0x13bf57
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x13c09c
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jb 0x13bf8d
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x13c09c
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
addsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jb 0x13bfba
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x13c09c
movl $0x0, -0x4(%rbp)
jmp 0x13c09c
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x13c000
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x13c09c
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x13c037
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x13c09c
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x20(%rbp), %rax
addsd (%rax), %xmm1
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x13c095
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x13c09c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
_ZN10OpenSubdiv6v3_6_03Far8PatchMap24transformUVToTriQuadrantIdEEiRKT_RS4_S7_Rb:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_28]
test byte ptr [rax], 1
jnz loc_13BFC6
mov rax, [rbp+var_18]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_10]
ucomisd xmm0, qword ptr [rax]
jb short loc_13BF57
mov rax, [rbp+var_10]
movsd xmm1, qword ptr [rax]
mov rax, [rbp+var_18]
movsd xmm0, qword ptr [rax]
subsd xmm0, xmm1
movsd qword ptr [rax], xmm0
mov [rbp+var_4], 1
jmp loc_13C09C
loc_13BF57:
mov rax, [rbp+var_20]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_10]
ucomisd xmm0, qword ptr [rax]
jb short loc_13BF8D
mov rax, [rbp+var_10]
movsd xmm1, qword ptr [rax]
mov rax, [rbp+var_20]
movsd xmm0, qword ptr [rax]
subsd xmm0, xmm1
movsd qword ptr [rax], xmm0
mov [rbp+var_4], 2
jmp loc_13C09C
loc_13BF8D:
mov rax, [rbp+var_18]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_20]
addsd xmm0, qword ptr [rax]
mov rax, [rbp+var_10]
ucomisd xmm0, qword ptr [rax]
jb short loc_13BFBA
mov rax, [rbp+var_28]
mov byte ptr [rax], 1
mov [rbp+var_4], 3
jmp loc_13C09C
loc_13BFBA:
mov [rbp+var_4], 0
jmp loc_13C09C
loc_13BFC6:
mov rax, [rbp+var_18]
movsd xmm1, qword ptr [rax]
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax]
ucomisd xmm0, xmm1
jbe short loc_13C000
mov rax, [rbp+var_10]
movsd xmm1, qword ptr [rax]
mov rax, [rbp+var_20]
movsd xmm0, qword ptr [rax]
subsd xmm0, xmm1
movsd qword ptr [rax], xmm0
mov [rbp+var_4], 1
jmp loc_13C09C
loc_13C000:
mov rax, [rbp+var_20]
movsd xmm1, qword ptr [rax]
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax]
ucomisd xmm0, xmm1
jbe short loc_13C037
mov rax, [rbp+var_10]
movsd xmm1, qword ptr [rax]
mov rax, [rbp+var_18]
movsd xmm0, qword ptr [rax]
subsd xmm0, xmm1
movsd qword ptr [rax], xmm0
mov [rbp+var_4], 2
jmp short loc_13C09C
loc_13C037:
mov rax, [rbp+var_10]
movsd xmm1, qword ptr [rax]
mov rax, [rbp+var_18]
movsd xmm0, qword ptr [rax]
subsd xmm0, xmm1
movsd qword ptr [rax], xmm0
mov rax, [rbp+var_10]
movsd xmm1, qword ptr [rax]
mov rax, [rbp+var_20]
movsd xmm0, qword ptr [rax]
subsd xmm0, xmm1
movsd qword ptr [rax], xmm0
mov rax, [rbp+var_18]
movsd xmm1, qword ptr [rax]
mov rax, [rbp+var_20]
addsd xmm1, qword ptr [rax]
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax]
ucomisd xmm0, xmm1
jbe short loc_13C095
mov rax, [rbp+var_28]
mov byte ptr [rax], 0
mov [rbp+var_4], 3
jmp short loc_13C09C
loc_13C095:
mov [rbp+var_4], 0
loc_13C09C:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchMap::transformUVToTriQuadrant<double>(
double *a1,
double *a2,
double *a3,
_BYTE *a4)
{
if ( (*a4 & 1) != 0 )
{
if ( *a1 <= *a2 )
{
if ( *a1 <= *a3 )
{
*a2 = *a2 - *a1;
*a3 = *a3 - *a1;
if ( *a1 <= *a2 + *a3 )
{
return 0;
}
else
{
*a4 = 0;
return 3;
}
}
else
{
*a2 = *a2 - *a1;
return 2;
}
}
else
{
*a3 = *a3 - *a1;
return 1;
}
}
else if ( *a2 < *a1 )
{
if ( *a3 < *a1 )
{
if ( *a2 + *a3 < *a1 )
{
return 0;
}
else
{
*a4 = 1;
return 3;
}
}
else
{
*a3 = *a3 - *a1;
return 2;
}
}
else
{
*a2 = *a2 - *a1;
return 1;
}
}
| |||
11,380 |
int OpenSubdiv::v3_6_0::Far::PatchMap::transformUVToTriQuadrant<double>(double const&, double&, double&, bool&)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/patchMap.h
|
int inline
PatchMap::transformUVToTriQuadrant(T const & median, T & u, T & v, bool & rotated) {
if (!rotated) {
if (u >= median) {
u -= median;
return 1;
}
if (v >= median) {
v -= median;
return 2;
}
if ((u + v) >= median) {
rotated = true;
return 3;
}
return 0;
} else {
if (u < median) {
v -= median;
return 1;
}
if (v < median) {
u -= median;
return 2;
}
u -= median;
v -= median;
if ((u + v) < median) {
rotated = false;
return 3;
}
return 0;
}
}
|
O2
|
c
|
int OpenSubdiv::v3_6_0::Far::PatchMap::transformUVToTriQuadrant<double>(double const&, double&, double&, bool&):
movsd (%rsi), %xmm1
movsd (%rdi), %xmm0
cmpb $0x0, (%rcx)
je 0x7b12b
ucomisd %xmm1, %xmm0
movsd (%rdx), %xmm2
jbe 0x7b14a
subsd %xmm0, %xmm2
movsd %xmm2, (%rdx)
jmp 0x7b181
ucomisd %xmm0, %xmm1
jae 0x7b179
movsd (%rdx), %xmm2
ucomisd %xmm0, %xmm2
jae 0x7b185
addsd %xmm2, %xmm1
ucomisd %xmm0, %xmm1
jb 0x7b191
movb $0x1, (%rcx)
jmp 0x7b175
ucomisd %xmm2, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rsi)
ja 0x7b18d
movsd (%rdx), %xmm0
subsd (%rdi), %xmm0
movsd %xmm0, (%rdx)
addsd (%rsi), %xmm0
movsd (%rdi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7b191
movb $0x0, (%rcx)
pushq $0x3
jmp 0x7b18f
subsd %xmm0, %xmm1
movsd %xmm1, (%rsi)
pushq $0x1
jmp 0x7b18f
subsd %xmm0, %xmm2
movsd %xmm2, (%rdx)
pushq $0x2
popq %rax
retq
xorl %eax, %eax
retq
|
_ZN10OpenSubdiv6v3_6_03Far8PatchMap24transformUVToTriQuadrantIdEEiRKT_RS4_S7_Rb:
movsd xmm1, qword ptr [rsi]
movsd xmm0, qword ptr [rdi]
cmp byte ptr [rcx], 0
jz short loc_7B12B
ucomisd xmm0, xmm1
movsd xmm2, qword ptr [rdx]
jbe short loc_7B14A
subsd xmm2, xmm0
movsd qword ptr [rdx], xmm2
jmp short loc_7B181
loc_7B12B:
ucomisd xmm1, xmm0
jnb short loc_7B179
movsd xmm2, qword ptr [rdx]
ucomisd xmm2, xmm0
jnb short loc_7B185
addsd xmm1, xmm2
ucomisd xmm1, xmm0
jb short loc_7B191
mov byte ptr [rcx], 1
jmp short loc_7B175
loc_7B14A:
ucomisd xmm0, xmm2
subsd xmm1, xmm0
movsd qword ptr [rsi], xmm1
ja short loc_7B18D
movsd xmm0, qword ptr [rdx]
subsd xmm0, qword ptr [rdi]
movsd qword ptr [rdx], xmm0
addsd xmm0, qword ptr [rsi]
movsd xmm1, qword ptr [rdi]
ucomisd xmm1, xmm0
jbe short loc_7B191
mov byte ptr [rcx], 0
loc_7B175:
push 3
jmp short loc_7B18F
loc_7B179:
subsd xmm1, xmm0
movsd qword ptr [rsi], xmm1
loc_7B181:
push 1
jmp short loc_7B18F
loc_7B185:
subsd xmm2, xmm0
movsd qword ptr [rdx], xmm2
loc_7B18D:
push 2
loc_7B18F:
pop rax
retn
loc_7B191:
xor eax, eax
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchMap::transformUVToTriQuadrant<double>(
double *a1,
double *a2,
double *a3,
_BYTE *a4)
{
double v4; // xmm1_8
double v5; // xmm0_8
double v6; // xmm2_8
double v7; // xmm2_8
double v8; // xmm0_8
v4 = *a2;
v5 = *a1;
if ( *a4 )
{
v6 = *a3;
if ( v5 > v4 )
{
*a3 = v6 - v5;
return 1LL;
}
*a2 = v4 - v5;
if ( v5 <= v6 )
{
v8 = *a3 - *a1;
*a3 = v8;
if ( *a1 > v8 + *a2 )
{
*a4 = 0;
return 3LL;
}
return 0LL;
}
return 2LL;
}
if ( v4 >= v5 )
{
*a2 = v4 - v5;
return 1LL;
}
v7 = *a3;
if ( *a3 >= v5 )
{
*a3 = v7 - v5;
return 2LL;
}
if ( v4 + v7 >= v5 )
{
*a4 = 1;
return 3LL;
}
return 0LL;
}
|
transformUVToTriQuadrant<double>:
MOVSD XMM1,qword ptr [RSI]
MOVSD XMM0,qword ptr [RDI]
CMP byte ptr [RCX],0x0
JZ 0x0017b12b
UCOMISD XMM0,XMM1
MOVSD XMM2,qword ptr [RDX]
JBE 0x0017b14a
SUBSD XMM2,XMM0
MOVSD qword ptr [RDX],XMM2
JMP 0x0017b181
LAB_0017b12b:
UCOMISD XMM1,XMM0
JNC 0x0017b179
MOVSD XMM2,qword ptr [RDX]
UCOMISD XMM2,XMM0
JNC 0x0017b185
ADDSD XMM1,XMM2
UCOMISD XMM1,XMM0
JC 0x0017b191
MOV byte ptr [RCX],0x1
JMP 0x0017b175
LAB_0017b14a:
UCOMISD XMM0,XMM2
SUBSD XMM1,XMM0
MOVSD qword ptr [RSI],XMM1
JA 0x0017b18d
MOVSD XMM0,qword ptr [RDX]
SUBSD XMM0,qword ptr [RDI]
MOVSD qword ptr [RDX],XMM0
ADDSD XMM0,qword ptr [RSI]
MOVSD XMM1,qword ptr [RDI]
UCOMISD XMM1,XMM0
JBE 0x0017b191
MOV byte ptr [RCX],0x0
LAB_0017b175:
PUSH 0x3
JMP 0x0017b18f
LAB_0017b179:
SUBSD XMM1,XMM0
MOVSD qword ptr [RSI],XMM1
LAB_0017b181:
PUSH 0x1
JMP 0x0017b18f
LAB_0017b185:
SUBSD XMM2,XMM0
MOVSD qword ptr [RDX],XMM2
LAB_0017b18d:
PUSH 0x2
LAB_0017b18f:
POP RAX
RET
LAB_0017b191:
XOR EAX,EAX
RET
|
/* int OpenSubdiv::v3_6_0::Far::PatchMap::transformUVToTriQuadrant<double>(double const&, double&,
double&, bool&) */
int OpenSubdiv::v3_6_0::Far::PatchMap::transformUVToTriQuadrant<double>
(double *param_1,double *param_2,double *param_3,bool *param_4)
{
double dVar1;
double dVar2;
double dVar3;
dVar1 = *param_2;
dVar2 = *param_1;
if (*param_4 == false) {
if (dVar1 < dVar2) {
dVar3 = *param_3;
if (dVar2 <= dVar3) {
*param_3 = dVar3 - dVar2;
return 2;
}
if (dVar2 <= dVar1 + dVar3) {
*param_4 = true;
return 3;
}
return 0;
}
*param_2 = dVar1 - dVar2;
}
else {
dVar3 = *param_3;
if (dVar2 <= dVar1) {
*param_2 = dVar1 - dVar2;
if (dVar3 < dVar2) {
return 2;
}
dVar1 = *param_3;
dVar2 = *param_1;
*param_3 = dVar1 - dVar2;
if ((dVar1 - dVar2) + *param_2 < *param_1) {
*param_4 = false;
return 3;
}
return 0;
}
*param_3 = dVar3 - dVar2;
}
return 1;
}
|
|
11,381 |
PFS_account::aggregate_memory(bool, PFS_user*, PFS_host*)
|
eloqsql/storage/perfschema/pfs_account.cc
|
void PFS_account::aggregate_memory(bool alive, PFS_user *safe_user, PFS_host *safe_host)
{
if (read_instr_class_memory_stats() == NULL)
return;
if (likely(safe_user != NULL && safe_host != NULL))
{
/*
Aggregate MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME
- MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME
in parallel.
*/
aggregate_all_memory(alive,
write_instr_class_memory_stats(),
safe_user->write_instr_class_memory_stats(),
safe_host->write_instr_class_memory_stats());
return;
}
if (safe_user != NULL)
{
/*
Aggregate MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME
- MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME
in parallel.
*/
aggregate_all_memory(alive,
write_instr_class_memory_stats(),
safe_user->write_instr_class_memory_stats(),
global_instr_class_memory_array);
return;
}
if (safe_host != NULL)
{
/*
Aggregate MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME
*/
aggregate_all_memory(alive,
write_instr_class_memory_stats(),
safe_host->write_instr_class_memory_stats());
return;
}
/*
Aggregate MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME
*/
aggregate_all_memory(alive,
write_instr_class_memory_stats(),
global_instr_class_memory_array);
return;
}
|
O3
|
cpp
|
PFS_account::aggregate_memory(bool, PFS_user*, PFS_host*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x28(%rdi), %rbx
testq %rbx, %rbx
setne %al
andb 0x4(%rdi), %al
cmpb $0x1, %al
jne 0x3f31d
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %r14d
testq %rdx, %rdx
je 0x3f326
testq %r15, %r15
je 0x3f326
testb $0x1, 0x4(%r12)
jne 0x3f2e9
movq %r12, %rdi
callq 0x40362
movb $0x1, 0x4(%r12)
movq 0x28(%r12), %r12
cmpb $0x0, 0x4(%r15)
jne 0x3f302
movq %r15, %rdi
callq 0x40362
movb $0x1, 0x4(%r15)
movq 0x28(%r15), %rcx
movzbl %r14b, %edi
movq %rbx, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31cbb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testq %r12, %r12
je 0x3f359
testb $0x1, 0x4(%r12)
jne 0x3f341
movq %r12, %rdi
callq 0x40362
movb $0x1, 0x4(%r12)
movq 0x28(%r12), %rdx
leaq 0x38db83(%rip), %rax # 0x3cced0
movq (%rax), %rcx
movzbl %r14b, %edi
movq %rbx, %rsi
jmp 0x3f310
testq %r15, %r15
je 0x3f378
testb $0x1, 0x4(%r15)
jne 0x3f372
movq %r15, %rdi
callq 0x40362
movb $0x1, 0x4(%r15)
movq 0x28(%r15), %rdx
jmp 0x3f382
leaq 0x38db51(%rip), %rax # 0x3cced0
movq (%rax), %rdx
movzbl %r14b, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31b36
|
_ZN11PFS_account16aggregate_memoryEbP8PFS_userP8PFS_host:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, [rdi+28h]
test rbx, rbx
setnz al
and al, [rdi+4]
cmp al, 1
jnz short loc_3F31D
mov r15, rcx
mov r12, rdx
mov r14d, esi
test rdx, rdx
jz short loc_3F326
test r15, r15
jz short loc_3F326
test byte ptr [r12+4], 1
jnz short loc_3F2E9
mov rdi, r12; this
call _ZN20PFS_connection_slice19rebase_memory_statsEv; PFS_connection_slice::rebase_memory_stats(void)
mov byte ptr [r12+4], 1
loc_3F2E9:
mov r12, [r12+28h]
cmp byte ptr [r15+4], 0
jnz short loc_3F302
mov rdi, r15; this
call _ZN20PFS_connection_slice19rebase_memory_statsEv; PFS_connection_slice::rebase_memory_stats(void)
mov byte ptr [r15+4], 1
loc_3F302:
mov rcx, [r15+28h]; PFS_memory_stat *
movzx edi, r14b; bool
mov rsi, rbx; PFS_memory_stat *
mov rdx, r12; PFS_memory_stat *
loc_3F310:
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _Z20aggregate_all_memorybP15PFS_memory_statS0_S0_; aggregate_all_memory(bool,PFS_memory_stat *,PFS_memory_stat *,PFS_memory_stat *)
loc_3F31D:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_3F326:
test r12, r12
jz short loc_3F359
test byte ptr [r12+4], 1
jnz short loc_3F341
mov rdi, r12; this
call _ZN20PFS_connection_slice19rebase_memory_statsEv; PFS_connection_slice::rebase_memory_stats(void)
mov byte ptr [r12+4], 1
loc_3F341:
mov rdx, [r12+28h]
lea rax, global_instr_class_memory_array
mov rcx, [rax]
movzx edi, r14b
mov rsi, rbx
jmp short loc_3F310
loc_3F359:
test r15, r15
jz short loc_3F378
test byte ptr [r15+4], 1
jnz short loc_3F372
mov rdi, r15; this
call _ZN20PFS_connection_slice19rebase_memory_statsEv; PFS_connection_slice::rebase_memory_stats(void)
mov byte ptr [r15+4], 1
loc_3F372:
mov rdx, [r15+28h]
jmp short loc_3F382
loc_3F378:
lea rax, global_instr_class_memory_array
mov rdx, [rax]
loc_3F382:
movzx edi, r14b
mov rsi, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _Z20aggregate_all_memorybP15PFS_memory_statS0_; aggregate_all_memory(bool,PFS_memory_stat *,PFS_memory_stat *)
|
unsigned __int8 PFS_account::aggregate_memory(
PFS_account *this,
unsigned __int8 a2,
PFS_memory_stat **a3,
PFS_memory_stat **a4)
{
PFS_memory_stat *v4; // rbx
unsigned __int8 result; // al
PFS_memory_stat *v8; // r12
PFS_memory_stat *v9; // rdx
v4 = (PFS_memory_stat *)*((_QWORD *)this + 5);
result = *((_BYTE *)this + 4) & (v4 != 0LL);
if ( result == 1 )
{
if ( a3 && a4 )
{
if ( (*((_BYTE *)a3 + 4) & 1) == 0 )
{
PFS_connection_slice::rebase_memory_stats((PFS_connection_slice *)a3);
*((_BYTE *)a3 + 4) = 1;
}
v8 = a3[5];
if ( !*((_BYTE *)a4 + 4) )
{
PFS_connection_slice::rebase_memory_stats((PFS_connection_slice *)a4);
*((_BYTE *)a4 + 4) = 1;
}
return aggregate_all_memory(a2, v4, v8, a4[5]);
}
else if ( a3 )
{
if ( (*((_BYTE *)a3 + 4) & 1) == 0 )
{
PFS_connection_slice::rebase_memory_stats((PFS_connection_slice *)a3);
*((_BYTE *)a3 + 4) = 1;
}
return aggregate_all_memory(a2, v4, a3[5], global_instr_class_memory_array);
}
else
{
if ( a4 )
{
if ( (*((_BYTE *)a4 + 4) & 1) == 0 )
{
PFS_connection_slice::rebase_memory_stats((PFS_connection_slice *)a4);
*((_BYTE *)a4 + 4) = 1;
}
v9 = a4[5];
}
else
{
v9 = global_instr_class_memory_array;
}
return (unsigned __int8)aggregate_all_memory(a2, v4, v9);
}
}
return result;
}
|
aggregate_memory:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,qword ptr [RDI + 0x28]
TEST RBX,RBX
SETNZ AL
AND AL,byte ptr [RDI + 0x4]
CMP AL,0x1
JNZ 0x0013f31d
MOV R15,RCX
MOV R12,RDX
MOV R14D,ESI
TEST RDX,RDX
JZ 0x0013f326
TEST R15,R15
JZ 0x0013f326
TEST byte ptr [R12 + 0x4],0x1
JNZ 0x0013f2e9
MOV RDI,R12
CALL 0x00140362
MOV byte ptr [R12 + 0x4],0x1
LAB_0013f2e9:
MOV R12,qword ptr [R12 + 0x28]
CMP byte ptr [R15 + 0x4],0x0
JNZ 0x0013f302
MOV RDI,R15
CALL 0x00140362
MOV byte ptr [R15 + 0x4],0x1
LAB_0013f302:
MOV RCX,qword ptr [R15 + 0x28]
MOVZX EDI,R14B
MOV RSI,RBX
MOV RDX,R12
LAB_0013f310:
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00131cbb
LAB_0013f31d:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0013f326:
TEST R12,R12
JZ 0x0013f359
TEST byte ptr [R12 + 0x4],0x1
JNZ 0x0013f341
MOV RDI,R12
CALL 0x00140362
MOV byte ptr [R12 + 0x4],0x1
LAB_0013f341:
MOV RDX,qword ptr [R12 + 0x28]
LEA RAX,[0x4cced0]
MOV RCX,qword ptr [RAX]
MOVZX EDI,R14B
MOV RSI,RBX
JMP 0x0013f310
LAB_0013f359:
TEST R15,R15
JZ 0x0013f378
TEST byte ptr [R15 + 0x4],0x1
JNZ 0x0013f372
MOV RDI,R15
CALL 0x00140362
MOV byte ptr [R15 + 0x4],0x1
LAB_0013f372:
MOV RDX,qword ptr [R15 + 0x28]
JMP 0x0013f382
LAB_0013f378:
LEA RAX,[0x4cced0]
MOV RDX,qword ptr [RAX]
LAB_0013f382:
MOVZX EDI,R14B
MOV RSI,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00131b36
|
/* PFS_account::aggregate_memory(bool, PFS_user*, PFS_host*) */
void __thiscall
PFS_account::aggregate_memory(PFS_account *this,bool param_1,PFS_user *param_2,PFS_host *param_3)
{
PFS_memory_stat *pPVar1;
PFS_memory_stat *pPVar2;
PFS_memory_stat *pPVar3;
pPVar1 = *(PFS_memory_stat **)(this + 0x28);
if ((pPVar1 != (PFS_memory_stat *)0x0 & (byte)this[4]) != 1) {
return;
}
if ((param_2 == (PFS_user *)0x0) || (param_3 == (PFS_host *)0x0)) {
if (param_2 == (PFS_user *)0x0) {
pPVar3 = global_instr_class_memory_array;
if (param_3 != (PFS_host *)0x0) {
if (((byte)param_3[4] & 1) == 0) {
PFS_connection_slice::rebase_memory_stats((PFS_connection_slice *)param_3);
param_3[4] = (PFS_host)0x1;
}
pPVar3 = *(PFS_memory_stat **)(param_3 + 0x28);
}
aggregate_all_memory(param_1,pPVar1,pPVar3);
return;
}
if (((byte)param_2[4] & 1) == 0) {
PFS_connection_slice::rebase_memory_stats((PFS_connection_slice *)param_2);
param_2[4] = (PFS_user)0x1;
}
pPVar3 = *(PFS_memory_stat **)(param_2 + 0x28);
pPVar2 = global_instr_class_memory_array;
}
else {
if (((byte)param_2[4] & 1) == 0) {
PFS_connection_slice::rebase_memory_stats((PFS_connection_slice *)param_2);
param_2[4] = (PFS_user)0x1;
}
pPVar3 = *(PFS_memory_stat **)(param_2 + 0x28);
if (param_3[4] == (PFS_host)0x0) {
PFS_connection_slice::rebase_memory_stats((PFS_connection_slice *)param_3);
param_3[4] = (PFS_host)0x1;
}
pPVar2 = *(PFS_memory_stat **)(param_3 + 0x28);
}
aggregate_all_memory(param_1,pPVar1,pPVar3,pPVar2);
return;
}
|
|
11,382 |
end_pagecache
|
eloqsql/storage/maria/ma_pagecache.c
|
void end_pagecache(PAGECACHE *pagecache, my_bool cleanup)
{
DBUG_ENTER("end_pagecache");
DBUG_PRINT("enter", ("key_cache: %p", pagecache));
if (!pagecache->inited)
DBUG_VOID_RETURN;
if (pagecache->disk_blocks > 0)
{
#ifndef DBUG_OFF
check_pagecache_is_cleaned_up(pagecache);
#endif
if (pagecache->block_mem)
{
my_large_free(pagecache->block_mem, pagecache->mem_size);
pagecache->block_mem= NULL;
my_free(pagecache->block_root);
pagecache->block_root= NULL;
}
pagecache->disk_blocks= -1;
/* Reset blocks_changed to be safe if flush_all_key_blocks is called */
pagecache->blocks_changed= 0;
}
DBUG_PRINT("status", ("used: %zu changed: %zu w_requests: %llu "
"writes: %llu r_requests: %llu reads: %llu",
pagecache->blocks_used,
pagecache->global_blocks_changed,
pagecache->global_cache_w_requests,
pagecache->global_cache_write,
pagecache->global_cache_r_requests,
pagecache->global_cache_read));
if (cleanup)
{
my_hash_free(&pagecache->files_in_flush);
mysql_mutex_destroy(&pagecache->cache_lock);
pagecache->inited= pagecache->can_be_used= 0;
PAGECACHE_DEBUG_CLOSE;
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
end_pagecache:
cmpb $0x0, 0x1a8(%rdi)
je 0x4be88
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpq $0x0, 0x40(%rdi)
jle 0x4be2c
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x4be1c
movq (%rbx), %rsi
callq 0xa77db
xorl %r15d, %r15d
movq %r15, 0xb0(%rbx)
movq 0xa8(%rbx), %rdi
callq 0x9f90e
movq %r15, 0xa8(%rbx)
movq $-0x1, 0x40(%rbx)
movq $0x0, 0x58(%rbx)
testb %r14b, %r14b
je 0x4be7e
leaq 0x1b0(%rbx), %rdi
callq 0x93521
leaq 0xc8(%rbx), %r14
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x4be68
leaq 0x3391b9(%rip), %rax # 0x385010
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x108(%rbx)
movq %r14, %rdi
callq 0x290d0
xorl %eax, %eax
movb %al, 0x1aa(%rbx)
movb %al, 0x1a8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
end_pagecache:
cmp byte ptr [rdi+1A8h], 0
jz locret_4BE88
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, esi
mov rbx, rdi
cmp qword ptr [rdi+40h], 0
jle short loc_4BE2C
mov rdi, [rbx+0B0h]
test rdi, rdi
jz short loc_4BE1C
mov rsi, [rbx]
call my_large_free
xor r15d, r15d
mov [rbx+0B0h], r15
mov rdi, [rbx+0A8h]
call my_free
mov [rbx+0A8h], r15
loc_4BE1C:
mov qword ptr [rbx+40h], 0FFFFFFFFFFFFFFFFh
mov qword ptr [rbx+58h], 0
loc_4BE2C:
test r14b, r14b
jz short loc_4BE7E
lea rdi, [rbx+1B0h]
call my_hash_free
lea r14, [rbx+0C8h]
mov rdi, [rbx+108h]
test rdi, rdi
jz short loc_4BE68
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+108h], 0
loc_4BE68:
mov rdi, r14
call _pthread_mutex_destroy
xor eax, eax
mov [rbx+1AAh], al
mov [rbx+1A8h], al
loc_4BE7E:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_4BE88:
retn
|
long long end_pagecache(long long a1, char a2, double a3)
{
long long v4; // rdi
long long result; // rax
long long v6; // rdi
if ( *(_BYTE *)(a1 + 424) )
{
if ( *(long long *)(a1 + 64) > 0 )
{
v4 = *(_QWORD *)(a1 + 176);
if ( v4 )
{
my_large_free(v4, *(_QWORD *)a1);
*(_QWORD *)(a1 + 176) = 0LL;
result = my_free(*(_QWORD *)(a1 + 168));
*(_QWORD *)(a1 + 168) = 0LL;
}
*(_QWORD *)(a1 + 64) = -1LL;
*(_QWORD *)(a1 + 88) = 0LL;
}
if ( a2 )
{
my_hash_free(a1 + 432);
v6 = *(_QWORD *)(a1 + 264);
if ( v6 )
{
((void ( *)(long long))PSI_server[9])(v6);
*(_QWORD *)(a1 + 264) = 0LL;
}
pthread_mutex_destroy(a1 + 200, a3);
result = 0LL;
*(_BYTE *)(a1 + 426) = 0;
*(_BYTE *)(a1 + 424) = 0;
}
}
return result;
}
|
end_pagecache:
CMP byte ptr [RDI + 0x1a8],0x0
JZ 0x0014be88
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,ESI
MOV RBX,RDI
CMP qword ptr [RDI + 0x40],0x0
JLE 0x0014be2c
MOV RDI,qword ptr [RBX + 0xb0]
TEST RDI,RDI
JZ 0x0014be1c
MOV RSI,qword ptr [RBX]
CALL 0x001a77db
XOR R15D,R15D
MOV qword ptr [RBX + 0xb0],R15
MOV RDI,qword ptr [RBX + 0xa8]
CALL 0x0019f90e
MOV qword ptr [RBX + 0xa8],R15
LAB_0014be1c:
MOV qword ptr [RBX + 0x40],-0x1
MOV qword ptr [RBX + 0x58],0x0
LAB_0014be2c:
TEST R14B,R14B
JZ 0x0014be7e
LEA RDI,[RBX + 0x1b0]
CALL 0x00193521
LEA R14,[RBX + 0xc8]
MOV RDI,qword ptr [RBX + 0x108]
TEST RDI,RDI
JZ 0x0014be68
LEA RAX,[0x485010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x108],0x0
LAB_0014be68:
MOV RDI,R14
CALL 0x001290d0
XOR EAX,EAX
MOV byte ptr [RBX + 0x1aa],AL
MOV byte ptr [RBX + 0x1a8],AL
LAB_0014be7e:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_0014be88:
RET
|
void end_pagecache(int8 *param_1,char param_2)
{
if (*(char *)(param_1 + 0x35) != '\0') {
if (0 < (long)param_1[8]) {
if (param_1[0x16] != 0) {
my_large_free(param_1[0x16],*param_1);
param_1[0x16] = 0;
my_free(param_1[0x15]);
param_1[0x15] = 0;
}
param_1[8] = 0xffffffffffffffff;
param_1[0xb] = 0;
}
if (param_2 != '\0') {
my_hash_free(param_1 + 0x36);
if (param_1[0x21] != 0) {
(**(code **)(PSI_server + 0x48))();
param_1[0x21] = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x19));
*(int1 *)((long)param_1 + 0x1aa) = 0;
*(int1 *)(param_1 + 0x35) = 0;
}
}
return;
}
|
|
11,383 |
sha256_init_Zpad
|
corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/hash_to_field.c
|
static void sha256_init_Zpad(SHA256_CTX *ctx)
{
ctx->h[0] = 0xda5698beU;
ctx->h[1] = 0x17b9b469U;
ctx->h[2] = 0x62335799U;
ctx->h[3] = 0x779fbecaU;
ctx->h[4] = 0x8ce5d491U;
ctx->h[5] = 0xc0d26243U;
ctx->h[6] = 0xbafef9eaU;
ctx->h[7] = 0x1837a9d8U;
ctx->N = 64;
vec_zero(ctx->buf, sizeof(ctx->buf));
ctx->off = 0;
}
|
O0
|
c
|
sha256_init_Zpad:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xda5698be, (%rax) # imm = 0xDA5698BE
movq -0x8(%rbp), %rax
movl $0x17b9b469, 0x4(%rax) # imm = 0x17B9B469
movq -0x8(%rbp), %rax
movl $0x62335799, 0x8(%rax) # imm = 0x62335799
movq -0x8(%rbp), %rax
movl $0x779fbeca, 0xc(%rax) # imm = 0x779FBECA
movq -0x8(%rbp), %rax
movl $0x8ce5d491, 0x10(%rax) # imm = 0x8CE5D491
movq -0x8(%rbp), %rax
movl $0xc0d26243, 0x14(%rax) # imm = 0xC0D26243
movq -0x8(%rbp), %rax
movl $0xbafef9ea, 0x18(%rax) # imm = 0xBAFEF9EA
movq -0x8(%rbp), %rax
movl $0x1837a9d8, 0x1c(%rax) # imm = 0x1837A9D8
movq -0x8(%rbp), %rax
movq $0x40, 0x20(%rax)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x40, %esi
callq 0x23310
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
sha256_init_Zpad:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov dword ptr [rax], 0DA5698BEh
mov rax, [rbp+var_8]
mov dword ptr [rax+4], 17B9B469h
mov rax, [rbp+var_8]
mov dword ptr [rax+8], 62335799h
mov rax, [rbp+var_8]
mov dword ptr [rax+0Ch], 779FBECAh
mov rax, [rbp+var_8]
mov dword ptr [rax+10h], 8CE5D491h
mov rax, [rbp+var_8]
mov dword ptr [rax+14h], 0C0D26243h
mov rax, [rbp+var_8]
mov dword ptr [rax+18h], 0BAFEF9EAh
mov rax, [rbp+var_8]
mov dword ptr [rax+1Ch], 1837A9D8h
mov rax, [rbp+var_8]
mov qword ptr [rax+20h], 40h ; '@'
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
mov esi, 40h ; '@'
call vec_zero
mov rax, [rbp+var_8]
mov qword ptr [rax+68h], 0
add rsp, 10h
pop rbp
retn
|
long long sha256_init_Zpad(long long a1)
{
long long result; // rax
*(_DWORD *)a1 = -631859010;
*(_DWORD *)(a1 + 4) = 398046313;
*(_DWORD *)(a1 + 8) = 1647531929;
*(_DWORD *)(a1 + 12) = 2006957770;
*(_DWORD *)(a1 + 16) = -1931094895;
*(_DWORD *)(a1 + 20) = -1059954109;
*(_DWORD *)(a1 + 24) = -1157694998;
*(_DWORD *)(a1 + 28) = 406301144;
*(_QWORD *)(a1 + 32) = 64LL;
vec_zero(a1 + 40, 0x40uLL);
result = a1;
*(_QWORD *)(a1 + 104) = 0LL;
return result;
}
|
sha256_init_Zpad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],0xda5698be
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x4],0x17b9b469
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8],0x62335799
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xc],0x779fbeca
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x10],0x8ce5d491
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x14],0xc0d26243
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x18],0xbafef9ea
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x1c],0x1837a9d8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],0x40
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
MOV ESI,0x40
CALL 0x00123310
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],0x0
ADD RSP,0x10
POP RBP
RET
|
void sha256_init_Zpad(int4 *param_1)
{
*param_1 = 0xda5698be;
param_1[1] = 0x17b9b469;
param_1[2] = 0x62335799;
param_1[3] = 0x779fbeca;
param_1[4] = 0x8ce5d491;
param_1[5] = 0xc0d26243;
param_1[6] = 0xbafef9ea;
param_1[7] = 0x1837a9d8;
*(int8 *)(param_1 + 8) = 0x40;
vec_zero(param_1 + 10,0x40);
*(int8 *)(param_1 + 0x1a) = 0;
return;
}
|
|
11,384 |
mi_munmap_file
|
eloqsql/storage/myisam/mi_dynrec.c
|
int mi_munmap_file(MI_INFO *info)
{
int ret;
DBUG_ENTER("mi_unmap_file");
if ((ret= my_munmap((void*) info->s->file_map, info->s->mmaped_length)))
DBUG_RETURN(ret);
info->s->file_read= mi_nommap_pread;
info->s->file_write= mi_nommap_pwrite;
info->s->file_map= 0;
info->s->mmaped_length= 0;
DBUG_RETURN(0);
}
|
O0
|
c
|
mi_munmap_file:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x270(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x4d0(%rax), %rsi
callq 0x2a4d0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xa869f
jmp 0xa8697
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa86f4
movq -0x10(%rbp), %rax
movq (%rax), %rax
leaq 0x53(%rip), %rcx # 0xa8700
movq %rcx, 0x2e0(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
leaq 0x9e(%rip), %rcx # 0xa8760
movq %rcx, 0x2e8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x270(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x4d0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
mi_munmap_file:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdi, [rax+270h]
mov rax, [rbp+var_10]
mov rax, [rax]
mov rsi, [rax+4D0h]
call _munmap
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_A869F
jmp short $+2
loc_A8697:
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
jmp short loc_A86F4
loc_A869F:
mov rax, [rbp+var_10]
mov rax, [rax]
lea rcx, mi_nommap_pread
mov [rax+2E0h], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
lea rcx, mi_nommap_pwrite
mov [rax+2E8h], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov qword ptr [rax+270h], 0
mov rax, [rbp+var_10]
mov rax, [rax]
mov qword ptr [rax+4D0h], 0
mov [rbp+var_4], 0
loc_A86F4:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long mi_munmap_file(long long a1)
{
unsigned int v2; // [rsp+Ch] [rbp-14h]
v2 = munmap(*(_QWORD *)(*(_QWORD *)a1 + 624LL), *(_QWORD *)(*(_QWORD *)a1 + 1232LL));
if ( v2 )
{
return v2;
}
else
{
*(_QWORD *)(*(_QWORD *)a1 + 736LL) = mi_nommap_pread;
*(_QWORD *)(*(_QWORD *)a1 + 744LL) = mi_nommap_pwrite;
*(_QWORD *)(*(_QWORD *)a1 + 624LL) = 0LL;
*(_QWORD *)(*(_QWORD *)a1 + 1232LL) = 0LL;
return 0;
}
}
|
mi_munmap_file:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x270]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x4d0]
CALL 0x0012a4d0
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x001a869f
JMP 0x001a8697
LAB_001a8697:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001a86f4
LAB_001a869f:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
LEA RCX,[0x1a8700]
MOV qword ptr [RAX + 0x2e0],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
LEA RCX,[0x1a8760]
MOV qword ptr [RAX + 0x2e8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x270],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x4d0],0x0
MOV dword ptr [RBP + -0x4],0x0
LAB_001a86f4:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int mi_munmap_file(long *param_1)
{
int local_c;
local_c = munmap(*(void **)(*param_1 + 0x270),*(size_t *)(*param_1 + 0x4d0));
if (local_c == 0) {
*(code **)(*param_1 + 0x2e0) = mi_nommap_pread;
*(code **)(*param_1 + 0x2e8) = mi_nommap_pwrite;
*(int8 *)(*param_1 + 0x270) = 0;
*(int8 *)(*param_1 + 0x4d0) = 0;
local_c = 0;
}
return local_c;
}
|
|
11,385 |
bf_get_exp_min
|
bluesky950520[P]quickjs/libbf.c
|
slimb_t bf_get_exp_min(const bf_t *a)
{
slimb_t i;
limb_t v;
int k;
for(i = 0; i < a->len; i++) {
v = a->tab[i];
if (v != 0) {
k = ctz(v);
return a->expn - (a->len - i) * LIMB_BITS + k;
}
}
return 0;
}
|
O0
|
c
|
bf_get_exp_min:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0xe8c4e
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xe8c3c
movq 0x8(%rsp), %rdi
callq 0xe8c70
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rcx
subq 0x10(%rsp), %rcx
shlq $0x6, %rcx
subq %rcx, %rax
movslq 0x4(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0xe8c57
jmp 0xe8c3e
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xe8bd2
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
bf_get_exp_min:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], 0
loc_E8BD2:
mov rax, [rsp+28h+var_18]
mov rcx, [rsp+28h+var_10]
cmp rax, [rcx+18h]
jnb short loc_E8C4E
mov rax, [rsp+28h+var_10]
mov rax, [rax+20h]
mov rcx, [rsp+28h+var_18]
mov rax, [rax+rcx*8]
mov [rsp+28h+var_20], rax
cmp [rsp+28h+var_20], 0
jz short loc_E8C3C
mov rdi, [rsp+28h+var_20]
call ctz
mov [rsp+28h+var_24], eax
mov rax, [rsp+28h+var_10]
mov rax, [rax+10h]
mov rcx, [rsp+28h+var_10]
mov rcx, [rcx+18h]
sub rcx, [rsp+28h+var_18]
shl rcx, 6
sub rax, rcx
movsxd rcx, [rsp+28h+var_24]
add rax, rcx
mov [rsp+28h+var_8], rax
jmp short loc_E8C57
loc_E8C3C:
jmp short $+2
loc_E8C3E:
mov rax, [rsp+28h+var_18]
add rax, 1
mov [rsp+28h+var_18], rax
jmp short loc_E8BD2
loc_E8C4E:
mov [rsp+28h+var_8], 0
loc_E8C57:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
|
long long bf_get_exp_min(_QWORD *a1)
{
long long v2; // [rsp+8h] [rbp-20h]
unsigned long long i; // [rsp+10h] [rbp-18h]
for ( i = 0LL; i < a1[3]; ++i )
{
v2 = *(_QWORD *)(a1[4] + 8 * i);
if ( v2 )
return (int)ctz(v2) + a1[2] - ((a1[3] - i) << 6);
}
return 0LL;
}
|
bf_get_exp_min:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],0x0
LAB_001e8bd2:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RCX + 0x18]
JNC 0x001e8c4e
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JZ 0x001e8c3c
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001e8c70
MOV dword ptr [RSP + 0x4],EAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RCX + 0x18]
SUB RCX,qword ptr [RSP + 0x10]
SHL RCX,0x6
SUB RAX,RCX
MOVSXD RCX,dword ptr [RSP + 0x4]
ADD RAX,RCX
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001e8c57
LAB_001e8c3c:
JMP 0x001e8c3e
LAB_001e8c3e:
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x1
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001e8bd2
LAB_001e8c4e:
MOV qword ptr [RSP + 0x20],0x0
LAB_001e8c57:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
long bf_get_exp_min(long param_1)
{
long lVar1;
int iVar2;
ulong local_18;
local_18 = 0;
while( true ) {
if (*(ulong *)(param_1 + 0x18) <= local_18) {
return 0;
}
lVar1 = *(long *)(*(long *)(param_1 + 0x20) + local_18 * 8);
if (lVar1 != 0) break;
local_18 = local_18 + 1;
}
iVar2 = ctz(lVar1);
return *(long *)(param_1 + 0x10) + (*(long *)(param_1 + 0x18) - local_18) * -0x40 + (long)iVar2;
}
|
|
11,386 |
my_string_repertoire
|
eloqsql/strings/ctype.c
|
my_repertoire_t
my_string_repertoire(CHARSET_INFO *cs, const char *str, size_t length)
{
if (cs->mbminlen == 1 && !(cs->state & MY_CS_NONASCII))
{
return my_string_repertoire_8bit(cs, str, length);
}
else
{
const char *strend= str + length;
my_wc_t wc;
int chlen;
for (;
(chlen= my_ci_mb_wc(cs, &wc, (uchar*) str, (uchar*) strend)) > 0;
str+= chlen)
{
if (wc > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
}
return MY_REPERTOIRE_ASCII;
}
|
O3
|
c
|
my_string_repertoire:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x1, 0x98(%rdi)
jne 0xd18eb
testb $0x20, 0xd(%r15)
jne 0xd18eb
movl $0x1, %eax
testq %rbx, %rbx
jle 0xd1951
addq %r14, %rbx
cmpb $0x0, (%r14)
js 0xd195e
incq %r14
cmpq %rbx, %r14
jb 0xd18db
jmp 0xd1951
addq %r14, %rbx
movq 0xb8(%r15), %rax
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
testl %eax, %eax
setg %cl
jle 0xd1947
cmpq $0x7f, -0x28(%rbp)
ja 0xd1947
leaq -0x28(%rbp), %r12
movq %r14, %rcx
movl %eax, %r14d
addq %rcx, %r14
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
testl %eax, %eax
setg %cl
jle 0xd1947
cmpq $0x80, -0x28(%rbp)
jb 0xd1917
movzbl %cl, %eax
leal 0x1(,%rax,2), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x3, %eax
jmp 0xd1951
|
my_string_repertoire:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
cmp dword ptr [rdi+98h], 1
jnz short loc_D18EB
test byte ptr [r15+0Dh], 20h
jnz short loc_D18EB
mov eax, 1
test rbx, rbx
jle short loc_D1951
add rbx, r14
loc_D18DB:
cmp byte ptr [r14], 0
js short loc_D195E
inc r14
cmp r14, rbx
jb short loc_D18DB
jmp short loc_D1951
loc_D18EB:
add rbx, r14
mov rax, [r15+0B8h]
lea rsi, [rbp+var_28]
mov rdi, r15
mov rdx, r14
mov rcx, rbx
call qword ptr [rax+28h]
test eax, eax
setnle cl
jle short loc_D1947
cmp [rbp+var_28], 7Fh
ja short loc_D1947
lea r12, [rbp+var_28]
loc_D1917:
mov rcx, r14
mov r14d, eax
add r14, rcx
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r12
mov rdx, r14
mov rcx, rbx
call qword ptr [rax+28h]
test eax, eax
setnle cl
jle short loc_D1947
cmp [rbp+var_28], 80h
jb short loc_D1917
loc_D1947:
movzx eax, cl
lea eax, ds:1[rax*2]
loc_D1951:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_D195E:
mov eax, 3
jmp short loc_D1951
|
long long my_string_repertoire(long long a1, char *a2, long long a3)
{
char *v3; // r14
long long result; // rax
char *v5; // rbx
int v6; // eax
bool v7; // cl
_QWORD v8[5]; // [rsp+8h] [rbp-28h] BYREF
v3 = a2;
if ( *(_DWORD *)(a1 + 152) != 1 || (*(_BYTE *)(a1 + 13) & 0x20) != 0 )
{
v5 = &a2[a3];
v6 = (*(long long ( **)(long long, _QWORD *, char *, char *))(*(_QWORD *)(a1 + 184) + 40LL))(
a1,
v8,
a2,
&a2[a3]);
v7 = v6 > 0;
if ( v6 > 0 && v8[0] <= 0x7FuLL )
{
do
{
v3 += (unsigned int)v6;
v6 = (*(long long ( **)(long long, _QWORD *, char *, char *))(*(_QWORD *)(a1 + 184) + 40LL))(
a1,
v8,
v3,
v5);
v7 = v6 > 0;
}
while ( v6 > 0 && v8[0] < 0x80uLL );
}
return 2 * (unsigned int)v7 + 1;
}
else
{
result = 1LL;
if ( a3 > 0 )
{
while ( *v3 >= 0 )
{
if ( ++v3 >= &a2[a3] )
return result;
}
return 3LL;
}
}
return result;
}
|
my_string_repertoire:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
CMP dword ptr [RDI + 0x98],0x1
JNZ 0x001d18eb
TEST byte ptr [R15 + 0xd],0x20
JNZ 0x001d18eb
MOV EAX,0x1
TEST RBX,RBX
JLE 0x001d1951
ADD RBX,R14
LAB_001d18db:
CMP byte ptr [R14],0x0
JS 0x001d195e
INC R14
CMP R14,RBX
JC 0x001d18db
JMP 0x001d1951
LAB_001d18eb:
ADD RBX,R14
MOV RAX,qword ptr [R15 + 0xb8]
LEA RSI,[RBP + -0x28]
MOV RDI,R15
MOV RDX,R14
MOV RCX,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
SETG CL
JLE 0x001d1947
CMP qword ptr [RBP + -0x28],0x7f
JA 0x001d1947
LEA R12,[RBP + -0x28]
LAB_001d1917:
MOV RCX,R14
MOV R14D,EAX
ADD R14,RCX
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
MOV RCX,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
SETG CL
JLE 0x001d1947
CMP qword ptr [RBP + -0x28],0x80
JC 0x001d1917
LAB_001d1947:
MOVZX EAX,CL
LEA EAX,[0x1 + RAX*0x2]
LAB_001d1951:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001d195e:
MOV EAX,0x3
JMP 0x001d1951
|
char my_string_repertoire(long param_1,char *param_2,long param_3)
{
char cVar1;
uint uVar2;
bool bVar3;
char *pcVar4;
ulong local_30;
if ((*(int *)(param_1 + 0x98) == 1) && ((*(byte *)(param_1 + 0xd) & 0x20) == 0)) {
cVar1 = '\x01';
if (0 < param_3) {
pcVar4 = param_2 + param_3;
do {
if (*param_2 < '\0') {
return '\x03';
}
param_2 = param_2 + 1;
} while (param_2 < pcVar4);
}
}
else {
pcVar4 = param_2 + param_3;
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x28))(param_1,&local_30,param_2,pcVar4);
bVar3 = 0 < (int)uVar2;
if ((0 < (int)uVar2) && (local_30 < 0x80)) {
do {
param_2 = param_2 + uVar2;
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x28))(param_1,&local_30,param_2,pcVar4);
bVar3 = 0 < (int)uVar2;
if ((int)uVar2 < 1) break;
} while (local_30 < 0x80);
}
cVar1 = bVar3 * '\x02' + '\x01';
}
return cVar1;
}
|
|
11,387 |
httplib::ThreadPool::enqueue(std::function<void ()>)
|
monkey531[P]llama/examples/server/httplib.h
|
bool enqueue(std::function<void()> fn) override {
{
std::unique_lock<std::mutex> lock(mutex_);
if (max_queued_requests_ > 0 && jobs_.size() >= max_queued_requests_) {
return false;
}
jobs_.push_back(std::move(fn));
}
cond_.notify_one();
return true;
}
|
O0
|
c
|
httplib::ThreadPool::enqueue(std::function<void ()>):
subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rsi
movq %rsi, 0x10(%rsp)
addq $0x78, %rsi
leaq 0x30(%rsp), %rdi
callq 0xa9ec0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jbe 0xa93ef
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xab1e0
movq 0x10(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jb 0xa93ef
movb $0x0, 0x57(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0xa940c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xab210
jmp 0xa9404
movl $0x0, 0x2c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xaa020
movl 0x2c(%rsp), %eax
testl %eax, %eax
je 0xa9422
jmp 0xa9420
jmp 0xa9451
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0x64c90
movb $0x1, 0x57(%rsp)
jmp 0xa9451
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xaa020
jmp 0xa945c
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x64e40
nopw %cs:(%rax,%rax)
|
_ZN7httplib10ThreadPool7enqueueESt8functionIFvvEE:
sub rsp, 58h
mov [rsp+58h+var_50], rsi
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov rsi, [rsp+58h+var_10]
mov [rsp+58h+var_48], rsi
add rsi, 78h ; 'x'
lea rdi, [rsp+58h+var_28]
call _ZNSt11unique_lockISt5mutexEC2ERS0_; std::unique_lock<std::mutex>::unique_lock(std::mutex&)
mov rax, [rsp+58h+var_48]
cmp qword ptr [rax+40h], 0
jbe short loc_A93EF
mov rdi, [rsp+58h+var_48]
add rdi, 20h ; ' '
call _ZNKSt7__cxx114listISt8functionIFvvEESaIS3_EE4sizeEv; std::list<std::function<void ()(void)>>::size(void)
mov rcx, [rsp+58h+var_48]
cmp rax, [rcx+40h]
jb short loc_A93EF
mov [rsp+58h+var_1], 0
mov [rsp+58h+var_2C], 1
jmp short loc_A940C
loc_A93EF:
mov rsi, [rsp+58h+var_50]
mov rdi, [rsp+58h+var_48]
add rdi, 20h ; ' '
call _ZNSt7__cxx114listISt8functionIFvvEESaIS3_EE9push_backEOS3_; std::list<std::function<void ()(void)>>::push_back(std::function<void ()(void)>&&)
jmp short $+2
loc_A9404:
mov [rsp+58h+var_2C], 0
loc_A940C:
lea rdi, [rsp+58h+var_28]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov eax, [rsp+58h+var_2C]
test eax, eax
jz short loc_A9422
jmp short $+2
loc_A9420:
jmp short loc_A9451
loc_A9422:
mov rdi, [rsp+58h+var_48]
add rdi, 48h ; 'H'; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
mov [rsp+58h+var_1], 1
jmp short loc_A9451
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
lea rdi, [rsp+arg_28]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
jmp short loc_A945C
loc_A9451:
mov al, [rsp+58h+var_1]
and al, 1
add rsp, 58h
retn
loc_A945C:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
|
char httplib::ThreadPool::enqueue(long long a1, long long a2)
{
int v3; // [rsp+2Ch] [rbp-2Ch]
_BYTE v4[16]; // [rsp+30h] [rbp-28h] BYREF
long long v5; // [rsp+40h] [rbp-18h]
long long v6; // [rsp+48h] [rbp-10h]
char v7; // [rsp+57h] [rbp-1h]
v6 = a1;
v5 = a2;
std::unique_lock<std::mutex>::unique_lock(v4, a1 + 120);
if ( *(_QWORD *)(a1 + 64)
&& (unsigned long long)std::list<std::function<void ()(void)>>::size(a1 + 32) >= *(_QWORD *)(a1 + 64) )
{
v7 = 0;
v3 = 1;
}
else
{
std::list<std::function<void ()(void)>>::push_back(a1 + 32, a2);
v3 = 0;
}
std::unique_lock<std::mutex>::~unique_lock(v4);
if ( !v3 )
{
std::condition_variable::notify_one((std::condition_variable *)(a1 + 72));
v7 = 1;
}
return v7 & 1;
}
|
enqueue:
SUB RSP,0x58
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP + 0x48],RDI
MOV qword ptr [RSP + 0x40],RSI
MOV RSI,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x10],RSI
ADD RSI,0x78
LEA RDI,[RSP + 0x30]
CALL 0x001a9ec0
MOV RAX,qword ptr [RSP + 0x10]
CMP qword ptr [RAX + 0x40],0x0
JBE 0x001a93ef
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x20
CALL 0x001ab1e0
MOV RCX,qword ptr [RSP + 0x10]
CMP RAX,qword ptr [RCX + 0x40]
JC 0x001a93ef
MOV byte ptr [RSP + 0x57],0x0
MOV dword ptr [RSP + 0x2c],0x1
JMP 0x001a940c
LAB_001a93ef:
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x20
LAB_001a93fd:
CALL 0x001ab210
LAB_001a9402:
JMP 0x001a9404
LAB_001a9404:
MOV dword ptr [RSP + 0x2c],0x0
LAB_001a940c:
LEA RDI,[RSP + 0x30]
CALL 0x001aa020
MOV EAX,dword ptr [RSP + 0x2c]
TEST EAX,EAX
JZ 0x001a9422
JMP 0x001a9420
LAB_001a9420:
JMP 0x001a9451
LAB_001a9422:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x48
CALL 0x00164c90
MOV byte ptr [RSP + 0x57],0x1
JMP 0x001a9451
LAB_001a9451:
MOV AL,byte ptr [RSP + 0x57]
AND AL,0x1
ADD RSP,0x58
RET
|
/* httplib::ThreadPool::enqueue(std::function<void ()>) */
ulong __thiscall httplib::ThreadPool::enqueue(ThreadPool *this,function *param_2)
{
bool bVar1;
ulong uVar2;
int8 uVar3;
unique_lock<std::mutex> local_28 [16];
function *local_18;
ThreadPool *local_10;
int1 local_1;
local_18 = param_2;
local_10 = this;
std::unique_lock<std::mutex>::unique_lock(local_28,(mutex *)(this + 0x78));
if ((*(long *)(this + 0x40) == 0) ||
(uVar2 = std::__cxx11::list<std::function<void()>,std::allocator<std::function<void()>>>::size
((list<std::function<void()>,std::allocator<std::function<void()>>> *)
(this + 0x20)), uVar2 < *(ulong *)(this + 0x40))) {
/* try { // try from 001a93fd to 001a9401 has its CatchHandler @ 001a9437 */
std::__cxx11::list<std::function<void()>,std::allocator<std::function<void()>>>::push_back
((list<std::function<void()>,std::allocator<std::function<void()>>> *)(this + 0x20),
param_2);
bVar1 = false;
}
else {
local_1 = 0;
bVar1 = true;
}
std::unique_lock<std::mutex>::~unique_lock(local_28);
uVar3 = 0;
if (!bVar1) {
uVar3 = std::condition_variable::notify_one();
local_1 = 1;
}
return CONCAT71((int7)((ulong)uVar3 >> 8),local_1) & 0xffffffffffffff01;
}
|
|
11,388 |
httplib::ThreadPool::enqueue(std::function<void ()>)
|
monkey531[P]llama/examples/server/httplib.h
|
bool enqueue(std::function<void()> fn) override {
{
std::unique_lock<std::mutex> lock(mutex_);
if (max_queued_requests_ > 0 && jobs_.size() >= max_queued_requests_) {
return false;
}
jobs_.push_back(std::move(fn));
}
cond_.notify_one();
return true;
}
|
O2
|
c
|
httplib::ThreadPool::enqueue(std::function<void ()>):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x406d4
movq 0x30(%rbx), %r15
movq 0x40(%rbx), %r12
decq %r12
cmpq %r15, %r12
jb 0x403e3
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x409d6
leaq 0x8(%rsp), %rdi
callq 0x40774
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x28590
jmp 0x403ed
leaq 0x8(%rsp), %rdi
callq 0x40774
cmpq %r15, %r12
setae %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40774
movq %rbx, %rdi
callq 0x293c0
|
_ZN7httplib10ThreadPool7enqueueESt8functionIFvvEE:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r14, rsi
mov rbx, rdi
lea rsi, [rdi+78h]
lea rdi, [rsp+38h+var_30]
call _ZNSt11unique_lockISt5mutexEC2ERS0_; std::unique_lock<std::mutex>::unique_lock(std::mutex&)
mov r15, [rbx+30h]
mov r12, [rbx+40h]
dec r12
cmp r12, r15
jb short loc_403E3
lea rdi, [rbx+20h]
mov rsi, r14
call _ZNSt7__cxx114listISt8functionIFvvEESaIS3_EE9push_backEOS3_; std::list<std::function<void ()(void)>>::push_back(std::function<void ()(void)>&&)
lea rdi, [rsp+38h+var_30]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
add rbx, 48h ; 'H'
mov rdi, rbx; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
jmp short loc_403ED
loc_403E3:
lea rdi, [rsp+38h+var_30]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
loc_403ED:
cmp r12, r15
setnb al
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov rdi, rbx
call __Unwind_Resume
|
bool httplib::ThreadPool::enqueue(_QWORD *a1, long long a2)
{
unsigned long long v2; // r15
unsigned long long v3; // r12
_BYTE v5[48]; // [rsp+8h] [rbp-30h] BYREF
std::unique_lock<std::mutex>::unique_lock(v5, a1 + 15);
v2 = a1[6];
v3 = a1[8] - 1LL;
if ( v3 < v2 )
{
std::unique_lock<std::mutex>::~unique_lock(v5);
}
else
{
std::list<std::function<void ()(void)>>::push_back(a1 + 4, a2);
std::unique_lock<std::mutex>::~unique_lock(v5);
std::condition_variable::notify_one((std::condition_variable *)(a1 + 9));
}
return v3 >= v2;
}
|
enqueue:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RDI + 0x78]
LEA RDI,[RSP + 0x8]
CALL 0x001406d4
MOV R15,qword ptr [RBX + 0x30]
MOV R12,qword ptr [RBX + 0x40]
DEC R12
CMP R12,R15
JC 0x001403e3
LEA RDI,[RBX + 0x20]
LAB_001403c3:
MOV RSI,R14
CALL 0x001409d6
LAB_001403cb:
LEA RDI,[RSP + 0x8]
CALL 0x00140774
ADD RBX,0x48
MOV RDI,RBX
CALL 0x00128590
JMP 0x001403ed
LAB_001403e3:
LEA RDI,[RSP + 0x8]
CALL 0x00140774
LAB_001403ed:
CMP R12,R15
SETNC AL
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
/* httplib::ThreadPool::enqueue(std::function<void ()>) */
bool __thiscall httplib::ThreadPool::enqueue(ThreadPool *this,function *param_2)
{
ulong uVar1;
long lVar2;
unique_lock<std::mutex> local_30 [16];
std::unique_lock<std::mutex>::unique_lock(local_30,(mutex *)(this + 0x78));
uVar1 = *(ulong *)(this + 0x30);
lVar2 = *(long *)(this + 0x40);
if (lVar2 - 1U < uVar1) {
std::unique_lock<std::mutex>::~unique_lock(local_30);
}
else {
/* try { // try from 001403c3 to 001403ca has its CatchHandler @ 001403ff */
std::__cxx11::list<std::function<void()>,std::allocator<std::function<void()>>>::push_back
((list<std::function<void()>,std::allocator<std::function<void()>>> *)(this + 0x20),
param_2);
std::unique_lock<std::mutex>::~unique_lock(local_30);
std::condition_variable::notify_one();
}
return uVar1 <= lVar2 - 1U;
}
|
|
11,389 |
aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::Shutdown()
|
aimrt_mujoco_sim/_deps/aimrt-src/src/plugins/time_manipulator_plugin/time_manipulator_executor.cc
|
void TimeManipulatorExecutor::Shutdown() {
if (std::atomic_exchange(&state_, State::kShutdown) == State::kShutdown)
return;
if (timer_thread_ptr_ && timer_thread_ptr_->joinable())
timer_thread_ptr_->join();
timer_thread_ptr_.reset();
timing_task_map_.clear();
timing_wheel_vec_.clear();
get_executor_func_ = nullptr;
}
|
O3
|
cpp
|
aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::Shutdown():
pushq %r14
pushq %rbx
pushq %rax
movl $0x3, %eax
xchgl %eax, 0xb0(%rdi)
cmpl $0x3, %eax
je 0x9a1e2
movq %rdi, %rbx
leaq 0x1d8(%rdi), %r14
movq 0x1d8(%rdi), %rdi
testq %rdi, %rdi
je 0x9a18f
cmpq $0x0, (%rdi)
je 0x9a18f
callq 0x83960
movq %r14, %rdi
xorl %esi, %esi
callq 0x81020
leaq 0x1a0(%rbx), %rdi
callq 0x9b902
leaq 0x180(%rbx), %rdi
movq 0x180(%rbx), %rsi
callq 0xa4dd4
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x9a1e2
leaq 0xb8(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0xc8, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x8b40b
|
_ZN5aimrt7plugins23time_manipulator_plugin23TimeManipulatorExecutor8ShutdownEv:
push r14
push rbx
push rax
mov eax, 3
xchg eax, [rdi+0B0h]
cmp eax, 3
jz short loc_9A1E2
mov rbx, rdi
lea r14, [rdi+1D8h]
mov rdi, [rdi+1D8h]; this
test rdi, rdi
jz short loc_9A18F
cmp qword ptr [rdi], 0
jz short loc_9A18F
call __ZNSt6thread4joinEv; std::thread::join(void)
loc_9A18F:
mov rdi, r14
xor esi, esi
call __ZNSt15__uniq_ptr_implISt6threadSt14default_deleteIS0_EE5resetEPS0_; std::__uniq_ptr_impl<std::thread,std::default_delete<std::thread>>::reset(std::thread*)
lea rdi, [rbx+1A0h]
call _ZNSt10_HashtableImSt4pairIKmNSt7__cxx114listIN5aimrt7plugins23time_manipulator_plugin23TimeManipulatorExecutor17TaskWithTimestampESaIS8_EEEESaISB_ENSt8__detail10_Select1stESt8equal_toImESt4hashImENSD_18_Mod_range_hashingENSD_20_Default_ranged_hashENSD_20_Prime_rehash_policyENSD_17_Hashtable_traitsILb0ELb0ELb1EEEE5clearEv; std::_Hashtable<ulong,std::pair<ulong const,std::list<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp>>,std::allocator<std::pair<ulong const,std::list<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp>>>,std::__detail::_Select1st,std::equal_to<ulong>,std::hash<ulong>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::clear(void)
lea rdi, [rbx+180h]
mov rsi, [rbx+180h]
call _ZNSt6vectorIN5aimrt7plugins23time_manipulator_plugin23TimeManipulatorExecutor15TimingWheelToolESaIS4_EE15_M_erase_at_endEPS4_; std::vector<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TimingWheelTool>::_M_erase_at_end(aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TimingWheelTool*)
mov rax, [rbx+0C8h]
test rax, rax
jz short loc_9A1E2
lea rdi, [rbx+0B8h]
mov rsi, rdi
mov edx, 3
call rax
add rbx, 0C8h
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_9A1E2:
add rsp, 8
pop rbx
pop r14
retn
mov rdi, rax
call __clang_call_terminate
|
long long aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::Shutdown(
aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor *this)
{
long long result; // rax
char *v3; // r14
std::thread *v4; // rdi
result = (unsigned int)_InterlockedExchange((volatile __int32 *)this + 44, 3);
if ( (_DWORD)result != 3 )
{
v3 = (char *)this + 472;
v4 = (std::thread *)*((_QWORD *)this + 59);
if ( v4 && *(_QWORD *)v4 )
std::thread::join(v4);
std::__uniq_ptr_impl<std::thread,std::default_delete<std::thread>>::reset(v3, 0LL);
std::_Hashtable<unsigned long,std::pair<unsigned long const,std::list<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp>>,std::allocator<std::pair<unsigned long const,std::list<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp>>>,std::__detail::_Select1st,std::equal_to<unsigned long>,std::hash<unsigned long>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::clear((char *)this + 416);
std::vector<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TimingWheelTool>::_M_erase_at_end(
(char *)this + 384,
*((_QWORD *)this + 48));
result = *((_QWORD *)this + 25);
if ( result )
{
result = ((long long ( *)(char *, char *, long long))result)((char *)this + 184, (char *)this + 184, 3LL);
*(_OWORD *)((char *)this + 200) = 0LL;
}
}
return result;
}
|
Shutdown:
PUSH R14
PUSH RBX
PUSH RAX
MOV EAX,0x3
XCHG dword ptr [RDI + 0xb0],EAX
CMP EAX,0x3
JZ 0x0019a1e2
MOV RBX,RDI
LEA R14,[RDI + 0x1d8]
MOV RDI,qword ptr [RDI + 0x1d8]
TEST RDI,RDI
JZ 0x0019a18f
CMP qword ptr [RDI],0x0
JZ 0x0019a18f
CALL 0x00183960
LAB_0019a18f:
MOV RDI,R14
XOR ESI,ESI
CALL 0x00181020
LEA RDI,[RBX + 0x1a0]
CALL 0x0019b902
LEA RDI,[RBX + 0x180]
MOV RSI,qword ptr [RBX + 0x180]
CALL 0x001a4dd4
MOV RAX,qword ptr [RBX + 0xc8]
TEST RAX,RAX
JZ 0x0019a1e2
LEA RDI,[RBX + 0xb8]
LAB_0019a1cb:
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
ADD RBX,0xc8
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_0019a1e2:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::Shutdown() */
void __thiscall
aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::Shutdown
(TimeManipulatorExecutor *this)
{
int iVar1;
LOCK();
iVar1 = *(int *)(this + 0xb0);
*(int *)(this + 0xb0) = 3;
UNLOCK();
if (iVar1 != 3) {
if ((*(long **)(this + 0x1d8) != (long *)0x0) && (**(long **)(this + 0x1d8) != 0)) {
std::thread::join();
}
std::__uniq_ptr_impl<std::thread,std::default_delete<std::thread>>::reset
((__uniq_ptr_impl<std::thread,std::default_delete<std::thread>> *)(this + 0x1d8),
(thread *)0x0);
std::
_Hashtable<unsigned_long,std::pair<unsigned_long_const,std::__cxx11::list<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp,std::allocator<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp>>>,std::allocator<std::pair<unsigned_long_const,std::__cxx11::list<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp,std::allocator<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp>>>>,std::__detail::_Select1st,std::equal_to<unsigned_long>,std::hash<unsigned_long>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::clear((_Hashtable<unsigned_long,std::pair<unsigned_long_const,std::__cxx11::list<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp,std::allocator<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp>>>,std::allocator<std::pair<unsigned_long_const,std::__cxx11::list<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp,std::allocator<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TaskWithTimestamp>>>>,std::__detail::_Select1st,std::equal_to<unsigned_long>,std::hash<unsigned_long>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)(this + 0x1a0));
std::
vector<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TimingWheelTool,std::allocator<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TimingWheelTool>>
::_M_erase_at_end((vector<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TimingWheelTool,std::allocator<aimrt::plugins::time_manipulator_plugin::TimeManipulatorExecutor::TimingWheelTool>>
*)(this + 0x180),*(TimingWheelTool **)(this + 0x180));
if (*(code **)(this + 200) != (code *)0x0) {
/* try { // try from 0019a1cb to 0019a1d4 has its CatchHandler @ 0019a1ea */
(**(code **)(this + 200))(this + 0xb8,this + 0xb8,3);
*(int8 *)(this + 200) = 0;
*(int8 *)(this + 0xd0) = 0;
}
}
return;
}
|
|
11,390 |
rtree_delete_key
|
eloqsql/storage/myisam/rt_key.c
|
int rtree_delete_key(MI_INFO *info, uchar *page_buf, uchar *key,
uint key_length, uint nod_flag)
{
uint16 page_size = mi_getint(page_buf);
uchar *key_start;
key_start= key - nod_flag;
if (!nod_flag)
key_length += info->s->base.rec_reflength;
memmove(key_start, key + key_length, page_size - key_length -
(key - page_buf));
page_size-= key_length + nod_flag;
mi_putint(page_buf, page_size, nod_flag);
return 0;
}
|
O0
|
c
|
rtree_delete_key:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
movw %ax, -0x22(%rbp)
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0xee5af
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x178(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
addq %rax, %rsi
movzwl -0x22(%rbp), %eax
subl -0x1c(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
subq %rax, %rdx
callq 0x2a160
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
movzwl -0x22(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x22(%rbp)
movl -0x20(%rbp), %edx
xorl %eax, %eax
movl $0x8000, %ecx # imm = 0x8000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movzwl -0x22(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0x32(%rbp)
movzwl -0x32(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x38(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
|
rtree_delete_key:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_20], r8d
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
and eax, 7FFFh
mov [rbp+var_22], ax
mov rax, [rbp+var_18]
mov ecx, [rbp+var_20]
mov edx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_30], rax
cmp [rbp+var_20], 0
jnz short loc_EE5AF
mov rax, [rbp+var_8]
mov rax, [rax]
mov eax, [rax+178h]
add eax, [rbp+var_1C]
mov [rbp+var_1C], eax
loc_EE5AF:
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_18]
mov eax, [rbp+var_1C]
add rsi, rax
movzx eax, [rbp+var_22]
sub eax, [rbp+var_1C]
mov eax, eax
mov edx, eax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
sub rdx, rax
call _memmove
mov ecx, [rbp+var_1C]
add ecx, [rbp+var_20]
movzx eax, [rbp+var_22]
sub eax, ecx
mov [rbp+var_22], ax
mov edx, [rbp+var_20]
xor eax, eax
mov ecx, 8000h
cmp edx, 0
cmovnz eax, ecx
movzx ecx, [rbp+var_22]
add eax, ecx
mov [rbp+var_32], ax
movzx eax, [rbp+var_32]
mov [rbp+var_38], eax
mov eax, [rbp+var_38]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov eax, [rbp+var_38]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
xor eax, eax
add rsp, 40h
pop rbp
retn
|
long long rtree_delete_key(long long a1, long long a2, long long a3, unsigned int a4, unsigned int a5)
{
__int16 v5; // ax
unsigned __int16 v7; // [rsp+1Eh] [rbp-22h]
__int16 v8; // [rsp+1Eh] [rbp-22h]
unsigned int v10; // [rsp+24h] [rbp-1Ch]
v10 = a4;
v7 = _byteswap_ushort(*(_WORD *)a2) & 0x7FFF;
if ( !a5 )
v10 = a4 + *(_DWORD *)(*(_QWORD *)a1 + 376LL);
memmove(a3 - a5, v10 + a3, v7 - v10 - (a3 - a2));
v8 = v7 - (a5 + v10);
v5 = 0;
if ( a5 )
v5 = 0x8000;
*(_BYTE *)(a2 + 1) = v8 + v5;
*(_BYTE *)a2 = (unsigned __int16)(v8 + v5) >> 8;
return 0LL;
}
|
rtree_delete_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV dword ptr [RBP + -0x20],R8D
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
AND EAX,0x7fff
MOV word ptr [RBP + -0x22],AX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x20]
MOV EDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
CMP dword ptr [RBP + -0x20],0x0
JNZ 0x001ee5af
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x178]
ADD EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x1c],EAX
LAB_001ee5af:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x1c]
ADD RSI,RAX
MOVZX EAX,word ptr [RBP + -0x22]
SUB EAX,dword ptr [RBP + -0x1c]
MOV EAX,EAX
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
SUB RDX,RAX
CALL 0x0012a160
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,dword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RBP + -0x22]
SUB EAX,ECX
MOV word ptr [RBP + -0x22],AX
MOV EDX,dword ptr [RBP + -0x20]
XOR EAX,EAX
MOV ECX,0x8000
CMP EDX,0x0
CMOVNZ EAX,ECX
MOVZX ECX,word ptr [RBP + -0x22]
ADD EAX,ECX
MOV word ptr [RBP + -0x32],AX
MOVZX EAX,word ptr [RBP + -0x32]
MOV dword ptr [RBP + -0x38],EAX
MOV EAX,dword ptr [RBP + -0x38]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x38]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
XOR EAX,EAX
ADD RSP,0x40
POP RBP
RET
|
int8 rtree_delete_key(long *param_1,byte *param_2,long param_3,uint param_4,uint param_5)
{
ushort uVar1;
short sVar2;
uint local_24;
uVar1 = (ushort)param_2[1] | (*param_2 & 0x7f) << 8;
local_24 = param_4;
if (param_5 == 0) {
local_24 = *(int *)(*param_1 + 0x178) + param_4;
}
memmove((void *)(param_3 - (ulong)param_5),(void *)(param_3 + (ulong)local_24),
(ulong)(uVar1 - local_24) - (param_3 - (long)param_2));
sVar2 = 0;
if (param_5 != 0) {
sVar2 = -0x8000;
}
sVar2 = sVar2 + (uVar1 - ((short)local_24 + (short)param_5));
param_2[1] = (byte)sVar2;
*param_2 = (byte)((ushort)sVar2 >> 8);
return 0;
}
|
|
11,391 |
rtree_delete_key
|
eloqsql/storage/myisam/rt_key.c
|
int rtree_delete_key(MI_INFO *info, uchar *page_buf, uchar *key,
uint key_length, uint nod_flag)
{
uint16 page_size = mi_getint(page_buf);
uchar *key_start;
key_start= key - nod_flag;
if (!nod_flag)
key_length += info->s->base.rec_reflength;
memmove(key_start, key + key_length, page_size - key_length -
(key - page_buf));
page_size-= key_length + nod_flag;
mi_putint(page_buf, page_size, nod_flag);
return 0;
}
|
O3
|
c
|
rtree_delete_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %r14d
movq %rsi, %rbx
movzbl 0x1(%rsi), %eax
movzbl (%rsi), %r12d
testl %r8d, %r8d
je 0xa6277
movl $0x8000, %r13d # imm = 0x8000
jmp 0xa6284
movq (%rdi), %rcx
addl 0x178(%rcx), %r14d
xorl %r13d, %r13d
movl %r15d, %ecx
movq %rdx, %rdi
subq %rcx, %rdi
andl $0x7f, %r12d
shll $0x8, %r12d
orl %eax, %r12d
movl %r14d, %esi
addq %rdx, %rsi
movl %r12d, %ecx
subl %r14d, %ecx
movq %rbx, %rax
subq %rdx, %rax
addq %rcx, %rax
movq %rax, %rdx
callq 0x2a150
addl %r15d, %r14d
subl %r14d, %r12d
movl %r13d, %eax
addl %r12d, %eax
movb %r12b, 0x1(%rbx)
movb %ah, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
rtree_delete_key:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15d, r8d
mov r14d, ecx
mov rbx, rsi
movzx eax, byte ptr [rsi+1]
movzx r12d, byte ptr [rsi]
test r8d, r8d
jz short loc_A6277
mov r13d, 8000h
jmp short loc_A6284
loc_A6277:
mov rcx, [rdi]
add r14d, [rcx+178h]
xor r13d, r13d
loc_A6284:
mov ecx, r15d
mov rdi, rdx
sub rdi, rcx
and r12d, 7Fh
shl r12d, 8
or r12d, eax
mov esi, r14d
add rsi, rdx
mov ecx, r12d
sub ecx, r14d
mov rax, rbx
sub rax, rdx
add rax, rcx
mov rdx, rax
call _memmove
add r14d, r15d
sub r12d, r14d
mov eax, r13d
add eax, r12d
mov [rbx+1], r12b
mov [rbx], ah
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long rtree_delete_key(long long a1, _BYTE *a2, long long a3, unsigned int a4, unsigned int a5)
{
__int16 v5; // r15
unsigned int v6; // r14d
__int16 v7; // r13
int v8; // r12d
v5 = a5;
v6 = a4;
if ( a5 )
{
v7 = 0x8000;
}
else
{
v6 = *(_DWORD *)(*(_QWORD *)a1 + 376LL) + a4;
v7 = 0;
}
v8 = (unsigned __int8)a2[1] | ((*a2 & 0x7F) << 8);
memmove(a3 - a5, a3 + v6, &a2[v8 - v6 - a3]);
LOWORD(v8) = v8 - (v5 + v6);
a2[1] = v8;
*a2 = (unsigned __int16)(v8 + v7) >> 8;
return 0LL;
}
|
rtree_delete_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15D,R8D
MOV R14D,ECX
MOV RBX,RSI
MOVZX EAX,byte ptr [RSI + 0x1]
MOVZX R12D,byte ptr [RSI]
TEST R8D,R8D
JZ 0x001a6277
MOV R13D,0x8000
JMP 0x001a6284
LAB_001a6277:
MOV RCX,qword ptr [RDI]
ADD R14D,dword ptr [RCX + 0x178]
XOR R13D,R13D
LAB_001a6284:
MOV ECX,R15D
MOV RDI,RDX
SUB RDI,RCX
AND R12D,0x7f
SHL R12D,0x8
OR R12D,EAX
MOV ESI,R14D
ADD RSI,RDX
MOV ECX,R12D
SUB ECX,R14D
MOV RAX,RBX
SUB RAX,RDX
ADD RAX,RCX
MOV RDX,RAX
CALL 0x0012a150
ADD R14D,R15D
SUB R12D,R14D
MOV EAX,R13D
ADD EAX,R12D
MOV byte ptr [RBX + 0x1],R12B
MOV byte ptr [RBX],AH
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 rtree_delete_key(long *param_1,byte *param_2,long param_3,uint param_4,uint param_5)
{
uint uVar1;
int iVar2;
int iVar3;
ulong uVar4;
uVar4 = (ulong)param_4;
if (param_5 == 0) {
uVar4 = (ulong)(param_4 + *(int *)(*param_1 + 0x178));
iVar3 = 0;
}
else {
iVar3 = 0x8000;
}
uVar1 = (*param_2 & 0x7f) << 8 | (uint)param_2[1];
memmove((void *)(param_3 - (ulong)param_5),(void *)(uVar4 + param_3),
(size_t)(param_2 + ((ulong)(uVar1 - (int)uVar4) - param_3)));
iVar2 = uVar1 - ((int)uVar4 + param_5);
param_2[1] = (byte)iVar2;
*param_2 = (byte)((uint)(iVar3 + iVar2) >> 8);
return 0;
}
|
|
11,392 |
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 0x34664
cmpl $0x2658, -0x8(%rbp) # imm = 0x2658
jg 0x34664
movl -0x8(%rbp), %eax
subl $0x2121, %eax # imm = 0x2121
movslq %eax, %rcx
leaq 0xc92f5(%rip), %rax # 0xfd950
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x346c5
cmpl $0x2721, -0x8(%rbp) # imm = 0x2721
jl 0x34691
cmpl $0x296f, -0x8(%rbp) # imm = 0x296F
jg 0x34691
movl -0x8(%rbp), %eax
subl $0x2721, %eax # imm = 0x2721
movslq %eax, %rcx
leaq 0xc9d38(%rip), %rax # 0xfe3c0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x346c5
cmpl $0x3021, -0x8(%rbp) # imm = 0x3021
jl 0x346be
cmpl $0x777e, -0x8(%rbp) # imm = 0x777E
jg 0x346be
movl -0x8(%rbp), %eax
subl $0x3021, %eax # imm = 0x3021
movslq %eax, %rcx
leaq 0xca1ab(%rip), %rax # 0xfe860
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x346c5
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_34664
cmp [rbp+var_8], 2658h
jg short loc_34664
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_346C5
loc_34664:
cmp [rbp+var_8], 2721h
jl short loc_34691
cmp [rbp+var_8], 296Fh
jg short loc_34691
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_346C5
loc_34691:
cmp [rbp+var_8], 3021h
jl short loc_346BE
cmp [rbp+var_8], 777Eh
jg short loc_346BE
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_346C5
loc_346BE:
mov [rbp+var_4], 0
loc_346C5:
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 0x00134664
CMP dword ptr [RBP + -0x8],0x2658
JG 0x00134664
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2121
MOVSXD RCX,EAX
LEA RAX,[0x1fd950]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001346c5
LAB_00134664:
CMP dword ptr [RBP + -0x8],0x2721
JL 0x00134691
CMP dword ptr [RBP + -0x8],0x296f
JG 0x00134691
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2721
MOVSXD RCX,EAX
LEA RAX,[0x1fe3c0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001346c5
LAB_00134691:
CMP dword ptr [RBP + -0x8],0x3021
JL 0x001346be
CMP dword ptr [RBP + -0x8],0x777e
JG 0x001346be
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3021
MOVSXD RCX,EAX
LEA RAX,[0x1fe860]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001346c5
LAB_001346be:
MOV dword ptr [RBP + -0x4],0x0
LAB_001346c5:
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;
}
|
|
11,393 |
freeze_size
|
eloqsql/mysys/array.c
|
void freeze_size(DYNAMIC_ARRAY *array)
{
uint elements;
/*
Do nothing if we are using a static buffer
*/
if (array->malloc_flags & MY_INIT_BUFFER_USED)
return;
elements= MY_MAX(array->elements, 1);
if (array->buffer && array->max_element > elements)
{
array->buffer=(uchar*) my_realloc(array->m_psi_key, array->buffer,
elements * array->size_of_element,
MYF(MY_WME | array->malloc_flags));
array->max_element= elements;
}
}
|
O0
|
c
|
freeze_size:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0x6cb52
jmp 0x6cbd0
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jbe 0x6cb68
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x6cb72
movl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6cb72
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6cbd0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
jbe 0x6cbd0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x10, %rcx
callq 0x8ab00
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
freeze_size:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+20h]
and rax, 100h
cmp rax, 0
jz short loc_6CB52
jmp short loc_6CBD0
loc_6CB52:
mov rax, [rbp+var_8]
cmp dword ptr [rax+8], 1
jbe short loc_6CB68
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov [rbp+var_10], eax
jmp short loc_6CB72
loc_6CB68:
mov eax, 1
mov [rbp+var_10], eax
jmp short $+2
loc_6CB72:
mov eax, [rbp+var_10]
mov [rbp+var_C], eax
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_6CBD0
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
cmp eax, [rbp+var_C]
jbe short loc_6CBD0
mov rax, [rbp+var_8]
mov edi, [rax+18h]
mov rax, [rbp+var_8]
mov rsi, [rax]
mov eax, [rbp+var_C]
mov rcx, [rbp+var_8]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
or rcx, 10h
call my_realloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax], rcx
mov ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rax+0Ch], ecx
loc_6CBD0:
add rsp, 10h
pop rbp
retn
|
long long freeze_size(long long a1)
{
long long result; // rax
unsigned int v2; // [rsp+0h] [rbp-10h]
result = *(_QWORD *)(a1 + 32) & 0x100LL;
if ( !result )
{
if ( *(_DWORD *)(a1 + 8) <= 1u )
v2 = 1;
else
v2 = *(_DWORD *)(a1 + 8);
result = a1;
if ( *(_QWORD *)a1 )
{
result = *(unsigned int *)(a1 + 12);
if ( (unsigned int)result > v2 )
{
*(_QWORD *)a1 = my_realloc(
*(unsigned int *)(a1 + 24),
*(_QWORD *)a1,
*(_DWORD *)(a1 + 20) * v2,
*(_QWORD *)(a1 + 32) | 0x10LL);
result = a1;
*(_DWORD *)(a1 + 12) = v2;
}
}
}
return result;
}
|
freeze_size:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,0x100
CMP RAX,0x0
JZ 0x0016cb52
JMP 0x0016cbd0
LAB_0016cb52:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x8],0x1
JBE 0x0016cb68
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0016cb72
LAB_0016cb68:
MOV EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0016cb72
LAB_0016cb72:
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x0016cbd0
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
CMP EAX,dword ptr [RBP + -0xc]
JBE 0x0016cbd0
MOV RAX,qword ptr [RBP + -0x8]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
OR RCX,0x10
CALL 0x0018ab00
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xc],ECX
LAB_0016cbd0:
ADD RSP,0x10
POP RBP
RET
|
void freeze_size(long *param_1)
{
long lVar1;
uint local_18;
if ((param_1[4] & 0x100U) == 0) {
if (*(uint *)(param_1 + 1) < 2) {
local_18 = 1;
}
else {
local_18 = *(uint *)(param_1 + 1);
}
if ((*param_1 != 0) && (local_18 < *(uint *)((long)param_1 + 0xc))) {
lVar1 = my_realloc((int)param_1[3],*param_1,local_18 * *(int *)((long)param_1 + 0x14),
param_1[4] | 0x10);
*param_1 = lVar1;
*(uint *)((long)param_1 + 0xc) = local_18;
}
}
return;
}
|
|
11,394 |
minja::Value::operator<(minja::Value const&) const
|
monkey531[P]llama/common/minja.hpp
|
bool operator<(const Value & other) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_number() && other.is_number()) return get<double>() < other.get<double>();
if (is_string() && other.is_string()) return get<std::string>() < other.get<std::string>();
throw std::runtime_error("Cannot compare values: " + dump() + " < " + other.dump());
}
|
O2
|
cpp
|
minja::Value::operator<(minja::Value const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x62ad6
testb %al, %al
jne 0x6fd89
movb 0x40(%r15), %al
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0x6fd25
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x2, %al
ja 0x6fdb9
movq %r15, %rdi
callq 0x62408
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x62408
ucomisd (%rsp), %xmm0
seta %bl
jmp 0x6fd79
cmpb $0x3, %al
jne 0x6fdb9
cmpb $0x3, 0x40(%r14)
jne 0x6fdb9
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x62f20
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x62f20
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x70248
movl %eax, %ebx
movq %r15, %rdi
callq 0x24158
movq %r14, %rdi
callq 0x24158
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %rbx
leaq 0x42d6f(%rip), %rsi # 0xb2b0a
movq %rax, %rdi
callq 0x23310
movq 0x8c246(%rip), %rsi # 0xfbff0
movq 0x8c1a7(%rip), %rdx # 0xfbf58
movq %rbx, %rdi
callq 0x23e90
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x624ec
leaq 0x43922(%rip), %rsi # 0xb36ff
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x57b16
leaq 0x43921(%rip), %rdx # 0xb3717
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x37958
leaq 0x48(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x624ec
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x389bb
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23dc0
xorl %ebp, %ebp
movq 0x8c1a9(%rip), %rsi # 0xfbff0
movq 0x8c10a(%rip), %rdx # 0xfbf58
movq %rbx, %rdi
callq 0x23e90
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x24158
jmp 0x6fe6b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x24158
jmp 0x6fe7d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x24158
jmp 0x6fe8f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x88(%rsp), %rdi
callq 0x24158
jmp 0x6fea4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rdi
callq 0x24158
testb %bpl, %bpl
jne 0x6fec9
jmp 0x6fed1
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x24158
jmp 0x6fed1
jmp 0x6fec6
movq %rax, %r14
movq %rbx, %rdi
callq 0x23660
movq %r14, %rdi
callq 0x23f10
nop
|
_ZNK5minja5ValueltERKS0_:
push rbp
push r15
push r14
push rbx
sub rsp, 0A8h
mov r14, rsi
mov r15, rdi
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jnz loc_6FD89
mov al, [r15+40h]
lea ecx, [rax-5]
cmp cl, 2
ja short loc_6FD25
mov al, [r14+40h]
add al, 0FBh
cmp al, 2
ja loc_6FDB9
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+0C8h+var_C8], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
ucomisd xmm0, [rsp+0C8h+var_C8]
setnbe bl
jmp short loc_6FD79
loc_6FD25:
cmp al, 3
jnz loc_6FDB9
cmp byte ptr [r14+40h], 3
jnz loc_6FDB9
lea rdi, [rsp+0C8h+var_C0]
mov rsi, r15
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea rdi, [rsp+0C8h+var_A0]
mov rsi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea r14, [rsp+0C8h+var_C0]
lea r15, [rsp+0C8h+var_A0]
mov rdi, r14
mov rsi, r15
call _ZStltIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EESA_; std::operator<<char>(std::string const&,std::string const&)
mov ebx, eax
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_6FD79:
mov eax, ebx
add rsp, 0A8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_6FD89:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
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, rbx; void *
call ___cxa_throw
loc_6FDB9:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0C8h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r15
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aCannotCompareV; "Cannot compare values: "
lea rdi, [rsp+0C8h+var_40]
lea rdx, [rsp+0C8h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rdx, asc_B3717; " < "
lea rdi, [rsp+0C8h+var_A0]
lea rsi, [rsp+0C8h+var_40]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+0C8h+var_80]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rdi, [rsp+0C8h+var_C0]
lea rsi, [rsp+0C8h+var_A0]
lea rdx, [rsp+0C8h+var_80]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
mov bpl, 1
lea rsi, [rsp+0C8h+var_C0]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+0C8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6FE6B
mov r14, rax
mov bpl, 1
loc_6FE6B:
lea rdi, [rsp+0C8h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6FE7D
mov r14, rax
mov bpl, 1
loc_6FE7D:
lea rdi, [rsp+0C8h+var_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6FE8F
mov r14, rax
mov bpl, 1
loc_6FE8F:
lea rdi, [rsp+0C8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6FEA4
mov r14, rax
mov bpl, 1
loc_6FEA4:
lea rdi, [rsp+0C8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_6FEC9
jmp short loc_6FED1
mov r14, rax
lea rdi, [rsp+0C8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6FED1
jmp short $+2
loc_6FEC6:
mov r14, rax
loc_6FEC9:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_6FED1:
mov rdi, r14
call __Unwind_Resume
|
long long minja::Value::operator<(minja::Value *a1, minja::Value *a2)
{
unsigned int v2; // ebx
char v3; // al
std::runtime_error *exception; // rbx
void *v6; // rbx
_BYTE v7[32]; // [rsp+8h] [rbp-C0h] BYREF
_QWORD v8[4]; // [rsp+28h] [rbp-A0h] BYREF
_QWORD v9[4]; // [rsp+48h] [rbp-80h] BYREF
_BYTE v10[32]; // [rsp+68h] [rbp-60h] BYREF
_BYTE v11[64]; // [rsp+88h] [rbp-40h] BYREF
if ( minja::Value::is_null(a1) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = *((_BYTE *)a1 + 64);
if ( (unsigned __int8)(v3 - 5) > 2u )
{
if ( v3 == 3 && *((_BYTE *)a2 + 64) == 3 )
{
minja::Value::get<std::string>((long long)v7, a1);
minja::Value::get<std::string>((long long)v8, a2);
v2 = std::operator<<char>(v7, v8);
std::string::~string(v8);
std::string::~string(v7);
return v2;
}
LABEL_10:
v6 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Cannot compare values: ", (long long)v10);
std::operator+<char>((long long)v8, (long long)v11, (long long)" < ");
minja::Value::dump[abi:cxx11]((long long)v9, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v7, v8, v9);
std::runtime_error::runtime_error(v6, v7);
__cxa_throw(
v6,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (unsigned __int8)(*((_BYTE *)a2 + 64) - 5) > 2u )
goto LABEL_10;
minja::Value::get<double>(a1);
minja::Value::get<double>(a2);
LOBYTE(v2) = 0;
return v2;
}
|
operator<:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV R14,RSI
MOV R15,RDI
CALL 0x00162ad6
TEST AL,AL
JNZ 0x0016fd89
MOV AL,byte ptr [R15 + 0x40]
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x0016fd25
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x2
JA 0x0016fdb9
MOV RDI,R15
CALL 0x00162408
MOVSD qword ptr [RSP],XMM0
MOV RDI,R14
CALL 0x00162408
UCOMISD XMM0,qword ptr [RSP]
SETA BL
JMP 0x0016fd79
LAB_0016fd25:
CMP AL,0x3
JNZ 0x0016fdb9
CMP byte ptr [R14 + 0x40],0x3
JNZ 0x0016fdb9
LEA RDI,[RSP + 0x8]
MOV RSI,R15
CALL 0x00162f20
LAB_0016fd45:
LEA RDI,[RSP + 0x28]
MOV RSI,R14
CALL 0x00162f20
LAB_0016fd52:
LEA R14,[RSP + 0x8]
LEA R15,[RSP + 0x28]
MOV RDI,R14
MOV RSI,R15
CALL 0x00170248
MOV EBX,EAX
MOV RDI,R15
CALL 0x00124158
MOV RDI,R14
CALL 0x00124158
LAB_0016fd79:
MOV EAX,EBX
ADD RSP,0xa8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0016fd89:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_0016fd94:
LEA RSI,[0x1b2b0a]
MOV RDI,RAX
CALL 0x00123310
LAB_0016fda3:
MOV RSI,qword ptr [0x001fbff0]
MOV RDX,qword ptr [0x001fbf58]
MOV RDI,RBX
CALL 0x00123e90
LAB_0016fdb9:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_0016fdc4:
LEA RDI,[RSP + 0x68]
PUSH -0x1
POP RDX
MOV RSI,R15
XOR ECX,ECX
CALL 0x001624ec
LAB_0016fdd6:
LEA RSI,[0x1b36ff]
LEA RDI,[RSP + 0x88]
LEA RDX,[RSP + 0x68]
CALL 0x00157b16
LAB_0016fdef:
LEA RDX,[0x1b3717]
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x88]
CALL 0x00137958
LAB_0016fe08:
LEA RDI,[RSP + 0x48]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x001624ec
LAB_0016fe1a:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x28]
LEA RDX,[RSP + 0x48]
CALL 0x001389bb
MOV BPL,0x1
LAB_0016fe31:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00123dc0
XOR EBP,EBP
MOV RSI,qword ptr [0x001fbff0]
MOV RDX,qword ptr [0x001fbf58]
MOV RDI,RBX
CALL 0x00123e90
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall minja::Value::operator<(Value *this,Value *param_1)
{
char cVar1;
bool bVar2;
int7 extraout_var;
runtime_error *prVar3;
int8 unaff_RBX;
ulong uVar4;
double dVar5;
double dVar6;
string local_c0 [32];
string local_a0 [32];
int1 local_80 [32];
int1 local_60 [32];
char local_40 [32];
cVar1 = is_null(this);
if (cVar1 != '\0') {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016fd94 to 0016fda2 has its CatchHandler @ 0016fec6 */
std::runtime_error::runtime_error(prVar3,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001fbff0,PTR__runtime_error_001fbf58);
}
if ((byte)((char)this[0x40] - 5U) < 3) {
if (2 < (byte)((char)param_1[0x40] - 5U)) {
LAB_0016fdb9:
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016fdc4 to 0016fdd5 has its CatchHandler @ 0016fec4 */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 0016fdd6 to 0016fdee has its CatchHandler @ 0016fe9e */
std::operator+(local_40,(string *)"Cannot compare values: ");
/* try { // try from 0016fdef to 0016fe07 has its CatchHandler @ 0016fe89 */
std::operator+(local_a0,local_40);
/* try { // try from 0016fe08 to 0016fe19 has its CatchHandler @ 0016fe77 */
dump_abi_cxx11_((int)local_80,SUB81(param_1,0));
/* try { // try from 0016fe1a to 0016fe2d has its CatchHandler @ 0016fe65 */
std::operator+(local_c0,local_a0);
/* try { // try from 0016fe31 to 0016fe55 has its CatchHandler @ 0016fe56 */
std::runtime_error::runtime_error(prVar3,local_c0);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001fbff0,PTR__runtime_error_001fbf58);
}
dVar5 = get<double>(this);
dVar6 = get<double>(param_1);
uVar4 = CONCAT71((int7)((ulong)unaff_RBX >> 8),dVar5 < dVar6);
}
else {
if ((this[0x40] != (Value)0x3) || (param_1[0x40] != (Value)0x3)) goto LAB_0016fdb9;
get<std::__cxx11::string>();
/* try { // try from 0016fd45 to 0016fd51 has its CatchHandler @ 0016feb5 */
get<std::__cxx11::string>();
bVar2 = std::operator<(local_c0,local_a0);
uVar4 = CONCAT71(extraout_var,bVar2) & 0xffffffff;
std::__cxx11::string::~string(local_a0);
std::__cxx11::string::~string(local_c0);
}
return uVar4 & 0xffffffff;
}
|
|
11,395 |
bool nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>::operator==<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>, nullptr>(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>> const&) const
|
msxemulator/build_O3/_deps/picotool-src/lib/nlohmann_json/single_include/nlohmann/json.hpp
|
bool operator==(const IterImpl& other) const
{
// if objects are not the same, the comparison is undefined
if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
{
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
}
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
return (m_it.object_iterator == other.m_it.object_iterator);
case value_t::array:
return (m_it.array_iterator == other.m_it.array_iterator);
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
return (m_it.primitive_iterator == other.m_it.primitive_iterator);
}
}
|
O3
|
cpp
|
bool nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>::operator==<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>, nullptr>(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x70816
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x707f6
cmpl $0x1, %eax
jne 0x70800
movq 0x8(%r14), %rax
cmpq 0x8(%rsi), %rax
jmp 0x70808
movq 0x10(%r14), %rax
cmpq 0x10(%rsi), %rax
jmp 0x70808
movq 0x18(%r14), %rax
cmpq 0x18(%rsi), %rax
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf260
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x379b4(%rip), %rsi # 0xa81e7
leaq 0x379dd(%rip), %rdx # 0xa8217
leaq 0x8(%rsp), %rdi
callq 0x5c00c
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xd4, %esi
callq 0x6956c
xorl %ebp, %ebp
leaq 0x71063(%rip), %rsi # 0xe18c8
leaq -0x98b0(%rip), %rdx # 0x66fbc
movq %rbx, %rdi
callq 0xf790
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7088e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf470
testb %bpl, %bpl
jne 0x70898
jmp 0x708a0
movq %rax, %r14
movq %rbx, %rdi
callq 0xf360
movq %r14, %rdi
callq 0xf7d0
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_:
push rbp; char
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov r14, rdi
mov rax, [rdi]
cmp rax, [rsi]
jnz short loc_70816
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_707F6
cmp eax, 1
jnz short loc_70800
mov rax, [r14+8]
cmp rax, [rsi+8]
jmp short loc_70808
loc_707F6:
mov rax, [r14+10h]
cmp rax, [rsi+10h]
jmp short loc_70808
loc_70800:
mov rax, [r14+18h]
cmp rax, [rsi+18h]
loc_70808:
setz al
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_70816:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotCompareI; "cannot compare iterators of different c"...
lea rdx, aCannotCompareI+30h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0D4h; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_7088E
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7088E:
test bpl, bpl
jnz short loc_70898
jmp short loc_708A0
mov r14, rax
loc_70898:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_708A0:
mov rdi, r14
call __Unwind_Resume
|
bool ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_(
unsigned __int8 **a1,
unsigned __int8 **a2)
{
int v2; // eax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
void *v6[2]; // [rsp+8h] [rbp-40h] BYREF
long long v7; // [rsp+18h] [rbp-30h] BYREF
if ( *a1 != *a2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v6[0] = &v7;
std::string::_M_construct<char const*>((long long)v6, "cannot compare iterators of different containers", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
212,
v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v2 = **a1;
if ( v2 == 2 )
return a1[2] == a2[2];
if ( v2 == 1 )
return a1[1] == a2[1];
return a1[3] == a2[3];
}
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RDI
MOV RAX,qword ptr [RDI]
CMP RAX,qword ptr [RSI]
JNZ 0x00170816
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x001707f6
CMP EAX,0x1
JNZ 0x00170800
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RSI + 0x8]
JMP 0x00170808
LAB_001707f6:
MOV RAX,qword ptr [R14 + 0x10]
CMP RAX,qword ptr [RSI + 0x10]
JMP 0x00170808
LAB_00170800:
MOV RAX,qword ptr [R14 + 0x18]
CMP RAX,qword ptr [RSI + 0x18]
LAB_00170808:
SETZ AL
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00170816:
MOV EDI,0x20
CALL 0x0010f260
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0017082c:
LEA RSI,[0x1a81e7]
LEA RDX,[0x1a8217]
LEA RDI,[RSP + 0x8]
CALL 0x0015c00c
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_0017084a:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xd4
CALL 0x0016956c
XOR EBP,EBP
LEA RSI,[0x1e18c8]
LEA RDX,[0x166fbc]
MOV RDI,RBX
CALL 0x0010f790
|
int8
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
(int8 *param_1,int8 *param_2)
{
char cVar1;
long lVar2;
int8 uVar3;
bool bVar4;
int1 *local_40 [2];
int1 local_30 [16];
if ((char *)*param_1 == (char *)*param_2) {
cVar1 = *(char *)*param_1;
if (cVar1 == '\x02') {
lVar2 = param_1[2];
bVar4 = lVar2 == param_2[2];
}
else if (cVar1 == '\x01') {
lVar2 = param_1[1];
bVar4 = lVar2 == param_2[1];
}
else {
lVar2 = param_1[3];
bVar4 = lVar2 == param_2[3];
}
return CONCAT71((int7)((ulong)lVar2 >> 8),bVar4);
}
uVar3 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 0017082c to 00170843 has its CatchHandler @ 00170895 */
std::__cxx11::string::_M_construct<char_const*>
((string *)local_40,"cannot compare iterators of different containers","");
/* try { // try from 0017084a to 00170873 has its CatchHandler @ 00170874 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xd4,local_40,*param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
|
|
11,396 |
my_interval_timer
|
eloqsql/mysys/my_getsystime.c
|
ulonglong my_interval_timer()
{
#ifdef HAVE_CLOCK_GETTIME
struct timespec tp;
clock_gettime(CLOCK_MONOTONIC, &tp);
return tp.tv_sec*1000000000ULL+tp.tv_nsec;
#elif defined(HAVE_GETHRTIME)
return gethrtime();
#elif defined(_WIN32)
DBUG_ASSERT(query_performance_frequency);
LARGE_INTEGER t_cnt;
QueryPerformanceCounter(&t_cnt);
return (t_cnt.QuadPart / query_performance_frequency * 1000000000ULL) +
((t_cnt.QuadPart % query_performance_frequency) * 1000000000ULL /
query_performance_frequency);
#else
/* TODO: check for other possibilities for hi-res timestamping */
struct timeval tv;
gettimeofday(&tv,NULL);
return tv.tv_sec*1000000000ULL+tv.tv_usec*1000ULL;
#endif
}
|
O3
|
c
|
my_interval_timer:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x292f0
imulq $0x3b9aca00, (%rbx), %rax # imm = 0x3B9ACA00
addq 0x8(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
|
my_interval_timer:
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
lea rbx, [rbp+var_18]
mov edi, 1
mov rsi, rbx
call _clock_gettime
imul rax, [rbx], 3B9ACA00h
add rax, [rbx+8]
add rsp, 18h
pop rbx
pop rbp
retn
|
long long my_interval_timer()
{
_QWORD v1[3]; // [rsp+8h] [rbp-18h] BYREF
clock_gettime(1LL, v1);
return v1[1] + 1000000000LL * v1[0];
}
|
my_interval_timer:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
LEA RBX,[RBP + -0x18]
MOV EDI,0x1
MOV RSI,RBX
CALL 0x001292f0
IMUL RAX,qword ptr [RBX],0x3b9aca00
ADD RAX,qword ptr [RBX + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
RET
|
long my_interval_timer(void)
{
timespec local_20;
clock_gettime(1,&local_20);
return local_20.tv_sec * 1000000000 + local_20.tv_nsec;
}
|
|
11,397 |
ma_test_if_reopen
|
eloqsql/storage/maria/ma_open.c
|
MARIA_HA *_ma_test_if_reopen(const char *filename)
{
LIST *pos;
for (pos=maria_open_list ; pos ; pos=pos->next)
{
MARIA_HA *info=(MARIA_HA*) pos->data;
MARIA_SHARE *share= info->s;
if (!strcmp(share->unique_file_name.str,filename) && share->last_version)
return info;
}
return 0;
}
|
O3
|
c
|
ma_test_if_reopen:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x3ab4ae(%rip), %rax # 0x3fca90
movq (%rax), %r15
testq %r15, %r15
je 0x5161c
movq %rdi, %rbx
movq 0x10(%r15), %r14
movq (%r14), %r12
movq 0x5b0(%r12), %rdi
movq %rbx, %rsi
callq 0x296a0
testl %eax, %eax
jne 0x51613
cmpq $0x0, 0x718(%r12)
jne 0x5161f
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x515ed
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_ma_test_if_reopen:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
lea rax, maria_open_list
mov r15, [rax]
test r15, r15
jz short loc_5161C
mov rbx, rdi
loc_515ED:
mov r14, [r15+10h]
mov r12, [r14]
mov rdi, [r12+5B0h]
mov rsi, rbx
call _strcmp
test eax, eax
jnz short loc_51613
cmp qword ptr [r12+718h], 0
jnz short loc_5161F
loc_51613:
mov r15, [r15+8]
test r15, r15
jnz short loc_515ED
loc_5161C:
xor r14d, r14d
loc_5161F:
mov rax, r14
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long * ma_test_if_reopen(long long a1)
{
long long v1; // r15
long long *v2; // r14
long long v3; // r12
v1 = maria_open_list;
if ( !maria_open_list )
return 0LL;
while ( 1 )
{
v2 = *(long long **)(v1 + 16);
v3 = *v2;
if ( !(unsigned int)strcmp(*(_QWORD *)(*v2 + 1456), a1) )
{
if ( *(_QWORD *)(v3 + 1816) )
break;
}
v1 = *(_QWORD *)(v1 + 8);
if ( !v1 )
return 0LL;
}
return v2;
}
|
_ma_test_if_reopen:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
LEA RAX,[0x4fca90]
MOV R15,qword ptr [RAX]
TEST R15,R15
JZ 0x0015161c
MOV RBX,RDI
LAB_001515ed:
MOV R14,qword ptr [R15 + 0x10]
MOV R12,qword ptr [R14]
MOV RDI,qword ptr [R12 + 0x5b0]
MOV RSI,RBX
CALL 0x001296a0
TEST EAX,EAX
JNZ 0x00151613
CMP qword ptr [R12 + 0x718],0x0
JNZ 0x0015161f
LAB_00151613:
MOV R15,qword ptr [R15 + 0x8]
TEST R15,R15
JNZ 0x001515ed
LAB_0015161c:
XOR R14D,R14D
LAB_0015161f:
MOV RAX,R14
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long * _ma_test_if_reopen(char *param_1)
{
long *plVar1;
long lVar2;
int iVar3;
long lVar4;
lVar4 = maria_open_list;
if (maria_open_list != 0) {
do {
plVar1 = *(long **)(lVar4 + 0x10);
lVar2 = *plVar1;
iVar3 = strcmp(*(char **)(lVar2 + 0x5b0),param_1);
if ((iVar3 == 0) && (*(long *)(lVar2 + 0x718) != 0)) {
return plVar1;
}
plVar1 = (long *)(lVar4 + 8);
lVar4 = *plVar1;
} while (*plVar1 != 0);
}
return (long *)0x0;
}
|
|
11,398 |
json_as_bytes
|
corpus-core[P]colibri-stateless/src/util/json.c
|
bytes_t json_as_bytes(json_t val, buffer_t* buffer) {
if (val.type == JSON_TYPE_NUMBER) {
buffer->data.len = 8;
buffer_grow(buffer, 8);
uint64_to_be(buffer->data.data, json_as_uint64(val));
return buffer->data;
}
if (val.type != JSON_TYPE_STRING) return NULL_BYTES;
buffer_grow(buffer, val.len / 2);
buffer->data.len = val.len;
int len = hex_to_bytes(val.start + 1, val.len - 2, buffer->data);
if (len == -1) return NULL_BYTES;
buffer->data.len = (uint32_t) len;
return buffer->data;
}
|
O0
|
c
|
json_as_bytes:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x18(%rbp)
cmpl $0x2, 0x10(%rax)
jne 0xa4944
movq -0x18(%rbp), %rax
movl $0x8, (%rax)
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x9c950
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa4780
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x9c750
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xa49d9
movq -0x28(%rbp), %rax
cmpl $0x1, 0x10(%rax)
je 0xa495f
movl $0x0, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0xa49d9
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rsi
shrq %rsi
callq 0x9c950
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movl %ecx, %edx
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movq (%rax), %rdi
addq $0x1, %rdi
movq 0x8(%rax), %rax
subq $0x2, %rax
movl %eax, %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movq 0x8(%rax), %rcx
callq 0x9cd40
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0xa49bd
movl $0x0, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0xa49d9
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
json_as_bytes:
push rbp
mov rbp, rsp
sub rsp, 50h
lea rax, [rbp+arg_0]
mov [rbp+var_28], rax
mov [rbp+var_18], rdi
cmp dword ptr [rax+10h], 2
jnz short loc_A4944
mov rax, [rbp+var_18]
mov dword ptr [rax], 8
mov rdi, [rbp+var_18]
mov esi, 8
call buffer_grow
mov rax, [rbp+var_28]
mov rcx, [rbp+var_18]
mov rcx, [rcx+8]
mov [rbp+var_30], rcx
mov rcx, [rax]
mov [rsp+50h+var_50], rcx
mov rcx, [rax+8]
mov [rsp+50h+var_48], rcx
mov rax, [rax+10h]
mov [rsp+50h+var_40], rax
call json_as_uint64
mov rdi, [rbp+var_30]
mov rsi, rax
call uint64_to_be
mov rax, [rbp+var_18]
mov rcx, [rax]
mov [rbp+var_10], rcx
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp loc_A49D9
loc_A4944:
mov rax, [rbp+var_28]
cmp dword ptr [rax+10h], 1
jz short loc_A495F
mov dword ptr [rbp+var_10], 0
mov [rbp+var_8], 0
jmp short loc_A49D9
loc_A495F:
mov rax, [rbp+var_28]
mov rdi, [rbp+var_18]
mov rsi, [rax+8]
shr rsi, 1
call buffer_grow
mov rax, [rbp+var_28]
mov rcx, [rax+8]
mov edx, ecx
mov rcx, [rbp+var_18]
mov [rcx], edx
mov rdi, [rax]
add rdi, 1
mov rax, [rax+8]
sub rax, 2
mov esi, eax
mov rax, [rbp+var_18]
mov edx, [rax]
mov rcx, [rax+8]
call hex_to_bytes
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0FFFFFFFFh
jnz short loc_A49BD
mov dword ptr [rbp+var_10], 0
mov [rbp+var_8], 0
jmp short loc_A49D9
loc_A49BD:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov [rax], ecx
mov rax, [rbp+var_18]
mov rcx, [rax]
mov [rbp+var_10], rcx
mov rax, [rax+8]
mov [rbp+var_8], rax
loc_A49D9:
mov eax, dword ptr [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 50h
pop rbp
retn
|
long long json_as_bytes(
unsigned long long a1,
_DWORD a2,
_DWORD a3,
_DWORD a4,
_DWORD a5,
_DWORD a6,
long long a7,
unsigned long long a8,
int a9)
{
int v9; // edx
int v10; // r8d
int v11; // r9d
unsigned long long v12; // rax
_BYTE *v14; // [rsp+20h] [rbp-30h]
int v15; // [rsp+34h] [rbp-1Ch]
long long v16; // [rsp+40h] [rbp-10h]
if ( a9 == 2 )
{
*(_DWORD *)a1 = 8;
buffer_grow(a1, 8uLL);
v14 = *(_BYTE **)(a1 + 8);
v12 = json_as_uint64(a1, 8, v9, a8, v10, v11, a7, a8, 2);
uint64_to_be(v14, v12);
return (unsigned int)*(_QWORD *)a1;
}
else if ( a9 == 1 )
{
buffer_grow(a1, a8 >> 1);
*(_DWORD *)a1 = a8;
v15 = hex_to_bytes((_BYTE *)(a7 + 1), (int)a8 - 2, *(_DWORD *)a1, *(_BYTE **)(a1 + 8));
if ( v15 == -1 )
{
LODWORD(v16) = 0;
}
else
{
*(_DWORD *)a1 = v15;
return (unsigned int)*(_QWORD *)a1;
}
}
else
{
LODWORD(v16) = 0;
}
return (unsigned int)v16;
}
|
json_as_bytes:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x18],RDI
CMP dword ptr [RAX + 0x10],0x2
JNZ 0x001a4944
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x8
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,0x8
CALL 0x0019c950
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RBP + -0x30],RCX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001a4780
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,RAX
CALL 0x0019c750
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a49d9
LAB_001a4944:
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0x10],0x1
JZ 0x001a495f
MOV dword ptr [RBP + -0x10],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a49d9
LAB_001a495f:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x8]
SHR RSI,0x1
CALL 0x0019c950
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x8]
MOV EDX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV dword ptr [RCX],EDX
MOV RDI,qword ptr [RAX]
ADD RDI,0x1
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,0x2
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
CALL 0x0019cd40
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],-0x1
JNZ 0x001a49bd
MOV dword ptr [RBP + -0x10],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a49d9
LAB_001a49bd:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
LAB_001a49d9:
MOV EAX,dword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
int1 [16] json_as_bytes(ulong *param_1)
{
ulong uVar1;
int iVar2;
int8 uVar3;
int1 auVar4 [16];
long in_stack_00000008;
ulong in_stack_00000010;
int in_stack_00000018;
ulong local_18;
ulong local_10;
if (in_stack_00000018 == 2) {
*(int *)param_1 = 8;
buffer_grow(param_1,8);
uVar1 = param_1[1];
uVar3 = json_as_uint64();
uint64_to_be(uVar1,uVar3);
local_18 = *param_1;
local_10 = param_1[1];
}
else if (in_stack_00000018 == 1) {
buffer_grow(param_1,in_stack_00000010 >> 1);
*(int *)param_1 = (int)in_stack_00000010;
iVar2 = hex_to_bytes(in_stack_00000008 + 1,(int)in_stack_00000010 + -2,(int)*param_1,param_1[1])
;
if (iVar2 == -1) {
local_18 = 0;
local_10 = 0;
}
else {
*(int *)param_1 = iVar2;
local_18 = *param_1;
local_10 = param_1[1];
}
}
else {
local_18 = 0;
local_10 = 0;
}
auVar4._0_8_ = local_18 & 0xffffffff;
auVar4._8_8_ = local_10;
return auVar4;
}
|
|
11,399 |
json_as_bytes
|
corpus-core[P]colibri-stateless/src/util/json.c
|
bytes_t json_as_bytes(json_t val, buffer_t* buffer) {
if (val.type == JSON_TYPE_NUMBER) {
buffer->data.len = 8;
buffer_grow(buffer, 8);
uint64_to_be(buffer->data.data, json_as_uint64(val));
return buffer->data;
}
if (val.type != JSON_TYPE_STRING) return NULL_BYTES;
buffer_grow(buffer, val.len / 2);
buffer->data.len = val.len;
int len = hex_to_bytes(val.start + 1, val.len - 2, buffer->data);
if (len == -1) return NULL_BYTES;
buffer->data.len = (uint32_t) len;
return buffer->data;
}
|
O3
|
c
|
json_as_bytes:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movl 0x10(%r15), %eax
cmpl $0x1, %eax
je 0x55ae5
cmpl $0x2, %eax
jne 0x55b24
movl $0x8, (%rbx)
movl $0x8, %esi
movq %rbx, %rdi
callq 0x50f71
leaq 0x8(%rbx), %r12
movq 0x8(%rbx), %r14
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x559b9
movq %r14, %rdi
movq %rax, %rsi
callq 0x50f63
movl (%rbx), %eax
jmp 0x55b1e
movq 0x8(%r15), %r14
movq %r14, %rsi
shrq %rsi
movq %rbx, %rdi
callq 0x50f71
movl %r14d, (%rbx)
movq (%r15), %rdi
incq %rdi
leal -0x2(%r14), %esi
movq 0x8(%rbx), %rcx
movl %r14d, %edx
callq 0x51192
cmpl $-0x1, %eax
je 0x55b24
movl %eax, (%rbx)
addq $0x8, %rbx
movq %rbx, %r12
movq (%r12), %rdx
jmp 0x55b28
xorl %eax, %eax
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
json_as_bytes:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
lea r15, [rsp+38h+arg_0]
mov eax, [r15+10h]
cmp eax, 1
jz short loc_55AE5
cmp eax, 2
jnz short loc_55B24
mov dword ptr [rbx], 8
mov esi, 8
mov rdi, rbx
call buffer_grow
lea r12, [rbx+8]
mov r14, [rbx+8]
mov rax, [r15+10h]
mov [rsp+38h+var_28], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+38h+var_38], xmm0
call json_as_uint64
mov rdi, r14
mov rsi, rax
call uint64_to_be
mov eax, [rbx]
jmp short loc_55B1E
loc_55AE5:
mov r14, [r15+8]
mov rsi, r14
shr rsi, 1
mov rdi, rbx
call buffer_grow
mov [rbx], r14d
mov rdi, [r15]
inc rdi
lea esi, [r14-2]
mov rcx, [rbx+8]
mov edx, r14d
call hex_to_bytes
cmp eax, 0FFFFFFFFh
jz short loc_55B24
mov [rbx], eax
add rbx, 8
mov r12, rbx
loc_55B1E:
mov rdx, [r12]
jmp short loc_55B28
loc_55B24:
xor eax, eax
xor edx, edx
loc_55B28:
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
|
long long json_as_bytes(
char **a1,
_DWORD a2,
_DWORD a3,
_DWORD a4,
_DWORD a5,
_DWORD a6,
long long a7,
unsigned long long a8,
long long a9)
{
char *v9; // r14
int v10; // edx
int v11; // ecx
long long v12; // r8
long long v13; // r9
unsigned long long v14; // rax
long long result; // rax
if ( (_DWORD)a9 != 1 )
{
if ( (_DWORD)a9 == 2 )
{
*(_DWORD *)a1 = 8;
buffer_grow((long long)a1, 8uLL);
v9 = a1[1];
v14 = json_as_uint64((_DWORD)a1, 8, v10, v11, v12, v13, a7, a8, a9);
uint64_to_be(v9, v14);
return *(unsigned int *)a1;
}
return 0LL;
}
buffer_grow((long long)a1, a8 >> 1);
*(_DWORD *)a1 = a8;
result = hex_to_bytes((_BYTE *)(a7 + 1), (unsigned int)(a8 - 2), a8, a1[1]);
if ( (_DWORD)result == -1 )
return 0LL;
*(_DWORD *)a1 = result;
return result;
}
|
json_as_bytes:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R15,[RSP + 0x40]
MOV EAX,dword ptr [R15 + 0x10]
CMP EAX,0x1
JZ 0x00155ae5
CMP EAX,0x2
JNZ 0x00155b24
MOV dword ptr [RBX],0x8
MOV ESI,0x8
MOV RDI,RBX
CALL 0x00150f71
LEA R12,[RBX + 0x8]
MOV R14,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x001559b9
MOV RDI,R14
MOV RSI,RAX
CALL 0x00150f63
MOV EAX,dword ptr [RBX]
JMP 0x00155b1e
LAB_00155ae5:
MOV R14,qword ptr [R15 + 0x8]
MOV RSI,R14
SHR RSI,0x1
MOV RDI,RBX
CALL 0x00150f71
MOV dword ptr [RBX],R14D
MOV RDI,qword ptr [R15]
INC RDI
LEA ESI,[R14 + -0x2]
MOV RCX,qword ptr [RBX + 0x8]
MOV EDX,R14D
CALL 0x00151192
CMP EAX,-0x1
JZ 0x00155b24
MOV dword ptr [RBX],EAX
ADD RBX,0x8
MOV R12,RBX
LAB_00155b1e:
MOV RDX,qword ptr [R12]
JMP 0x00155b28
LAB_00155b24:
XOR EAX,EAX
XOR EDX,EDX
LAB_00155b28:
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] json_as_bytes(uint *param_1)
{
int8 uVar1;
ulong uVar2;
int8 uVar3;
int1 auVar4 [16];
long in_stack_00000008;
uint uStack0000000000000010;
int in_stack_00000018;
if (in_stack_00000018 == 1) {
buffer_grow(param_1,_uStack0000000000000010 >> 1);
*param_1 = uStack0000000000000010;
uVar2 = hex_to_bytes(in_stack_00000008 + 1,uStack0000000000000010 - 2,uStack0000000000000010,
*(int8 *)(param_1 + 2));
if ((uint)uVar2 == 0xffffffff) goto LAB_00155b24;
*param_1 = (uint)uVar2;
}
else {
if (in_stack_00000018 != 2) {
LAB_00155b24:
uVar2 = 0;
uVar3 = 0;
goto LAB_00155b28;
}
*param_1 = 8;
buffer_grow(param_1,8);
uVar3 = *(int8 *)(param_1 + 2);
uVar1 = json_as_uint64();
uint64_to_be(uVar3,uVar1);
uVar2 = (ulong)*param_1;
}
uVar3 = *(int8 *)(param_1 + 2);
LAB_00155b28:
auVar4._8_8_ = uVar3;
auVar4._0_8_ = uVar2;
return auVar4;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.