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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
25,900 | LefDefParser::defwEndPropDef() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp | int
defwEndPropDef()
{
defwFunc = DEFW_PROP_END; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if (defwState != DEFW_PROP_START &&
defwState != DEFW_PROP)
return DEFW_BAD_ORDER;
fprintf(defwFile, "END PROPERTYDEFINITIONS\n\n");
defwLines++;
defwState = DEFW_PROP_END;
return DEFW_OK;
} | O3 | cpp | LefDefParser::defwEndPropDef():
pushq %rbx
leaq 0x161c7(%rip), %rax # 0x1e178
movl $0xe, (%rax)
leaq 0x161aa(%rip), %rax # 0x1e168
movq (%rax), %rcx
testq %rcx, %rcx
je 0x8005
leaq 0x161a7(%rip), %rbx # 0x1e174
movl (%rbx), %edx
addl $-0xe, %edx
movl $0x2, %eax
cmpl $-0x2, %edx
jb 0x800a
leaq 0xd174(%rip), %rdi # 0x15157
movl $0x19, %esi
movl $0x1, %edx
callq 0x1110
leaq 0x16177(%rip), %rax # 0x1e170
incl (%rax)
movl $0xe, (%rbx)
xorl %eax, %eax
jmp 0x800a
movl $0x1, %eax
popq %rbx
retq
| _ZN12LefDefParser14defwEndPropDefEv:
push rbx
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 0Eh
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rcx, [rax]
test rcx, rcx
jz short loc_8005
lea rbx, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov edx, [rbx]
add edx, 0FFFFFFF2h
mov eax, 2
cmp edx, 0FFFFFFFEh
jb short loc_800A
lea rdi, aEndPropertydef; "END PROPERTYDEFINITIONS\n\n"
mov esi, 19h
mov edx, 1
call _fwrite
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
inc dword ptr [rax]
mov dword ptr [rbx], 0Eh
xor eax, eax
jmp short loc_800A
loc_8005:
mov eax, 1
loc_800A:
pop rbx
retn
| long long LefDefParser::defwEndPropDef(LefDefParser *this)
{
long long result; // rax
LefDefParser::defwFunc = 14;
if ( !LefDefParser::defwFile )
return 1LL;
result = 2LL;
if ( (unsigned int)(LefDefParser::defwState - 14) >= 0xFFFFFFFE )
{
fwrite("END PROPERTYDEFINITIONS\n\n", 25LL, 1LL, LefDefParser::defwFile);
++LefDefParser::defwLines;
LefDefParser::defwState = 14;
return 0LL;
}
return result;
}
| defwEndPropDef:
PUSH RBX
LEA RAX,[0x11e178]
MOV dword ptr [RAX],0xe
LEA RAX,[0x11e168]
MOV RCX,qword ptr [RAX]
TEST RCX,RCX
JZ 0x00108005
LEA RBX,[0x11e174]
MOV EDX,dword ptr [RBX]
ADD EDX,-0xe
MOV EAX,0x2
CMP EDX,-0x2
JC 0x0010800a
LEA RDI,[0x115157]
MOV ESI,0x19
MOV EDX,0x1
CALL 0x00101110
LEA RAX,[0x11e170]
INC dword ptr [RAX]
MOV dword ptr [RBX],0xe
XOR EAX,EAX
JMP 0x0010800a
LAB_00108005:
MOV EAX,0x1
LAB_0010800a:
POP RBX
RET
|
/* LefDefParser::defwEndPropDef() */
int8 LefDefParser::defwEndPropDef(void)
{
int8 uVar1;
defwFunc = 0xe;
if (defwFile == (FILE *)0x0) {
uVar1 = 1;
}
else {
uVar1 = 2;
if (0xfffffffd < defwState - 0xeU) {
fwrite("END PROPERTYDEFINITIONS\n\n",0x19,1,defwFile);
defwLines = defwLines + 1;
defwState = 0xe;
uVar1 = 0;
}
}
return uVar1;
}
| |
25,901 | JS_DetectModule | bluesky950520[P]quickjs/quickjs.c | BOOL JS_DetectModule(const char *input, size_t input_len)
{
JSRuntime *rt;
JSContext *ctx;
JSValue val;
BOOL is_module;
is_module = TRUE;
rt = JS_NewRuntime();
if (!rt)
return FALSE;
ctx = JS_NewContextRaw(rt);
if (!ctx) {
JS_FreeRuntime(rt);
return FALSE;
}
JS_AddIntrinsicRegExp(ctx); // otherwise regexp literals don't parse
val = __JS_EvalInternal(ctx, JS_UNDEFINED, input, input_len, "<unnamed>",
JS_EVAL_TYPE_MODULE|JS_EVAL_FLAG_COMPILE_ONLY, -1);
if (JS_IsException(val)) {
const char *msg = JS_ToCString(ctx, rt->current_exception);
// gruesome hack to recognize exceptions from import statements;
// necessary because we don't pass in a module loader
is_module = !!strstr(msg, "ReferenceError: could not load module");
JS_FreeCString(ctx, msg);
}
JS_FreeValue(ctx, val);
JS_FreeContext(ctx);
JS_FreeRuntime(rt);
return is_module;
} | O2 | c | JS_DetectModule:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
callq 0x1b9f6
testq %rax, %rax
je 0x372aa
movq %rax, %rbx
movq %rax, %rdi
callq 0x1be8d
testq %rax, %rax
je 0x372ae
movq %rax, %r14
movq %rax, %rdi
callq 0x1cd6b
orl $-0x1, 0x8(%rsp)
movl $0x21, (%rsp)
leaq 0x51e2c(%rip), %r9 # 0x89079
pushq $0x3
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rcx
movq %r15, %r8
callq 0x344b0
movq %rax, %r15
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x372b2
movq 0xf0(%rbx), %rsi
movq 0xf8(%rbx), %rdx
movq %r14, %rdi
callq 0x1e5bd
movq %rax, %r13
leaq 0x51df7(%rip), %rsi # 0x89083
movq %rax, %rdi
callq 0xea30
xorl %ebp, %ebp
testq %rax, %rax
setne %bpl
movq %r14, %rdi
movq %r13, %rsi
callq 0x1ec07
jmp 0x372b5
xorl %ebp, %ebp
jmp 0x372d3
xorl %ebp, %ebp
jmp 0x372cb
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1bbce
movq %r14, %rdi
callq 0x1dae6
movq %rbx, %rdi
callq 0x1b842
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_DetectModule:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rsi
mov r12, rdi
call JS_NewRuntime
test rax, rax
jz loc_372AA
mov rbx, rax
mov rdi, rax
call JS_NewContextRaw
test rax, rax
jz short loc_372AE
mov r14, rax
mov rdi, rax
call JS_AddIntrinsicRegExp
or [rsp+48h+var_40], 0FFFFFFFFh
mov [rsp+48h+var_48], 21h ; '!'
lea r9, aUnnamed; "<unnamed>"
push 3
pop rdx
mov rdi, r14
xor esi, esi
mov rcx, r12
mov r8, r15
call __JS_EvalInternal
mov r15, rax
mov r12, rdx
cmp r12d, 6
jnz short loc_372B2
mov rsi, [rbx+0F0h]
mov rdx, [rbx+0F8h]
mov rdi, r14
call JS_ToCString_1
mov r13, rax
lea rsi, aReferenceerror; "ReferenceError: could not load module"
mov rdi, rax
call _strstr
xor ebp, ebp
test rax, rax
setnz bpl
mov rdi, r14
mov rsi, r13
call JS_FreeCString
jmp short loc_372B5
loc_372AA:
xor ebp, ebp
jmp short loc_372D3
loc_372AE:
xor ebp, ebp
jmp short loc_372CB
loc_372B2:
push 1
pop rbp
loc_372B5:
mov rdi, r14
mov rsi, r15
mov rdx, r12
call JS_FreeValue
mov rdi, r14
call JS_FreeContext
loc_372CB:
mov rdi, rbx
call JS_FreeRuntime
loc_372D3:
mov eax, ebp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BOOL8 JS_DetectModule(
char *a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // rax
long long v11; // rbx
unsigned int *v12; // rax
unsigned int *v13; // r14
double v14; // xmm4_8
double v15; // xmm5_8
unsigned long long v16; // r15
long long v17; // rdx
long long v18; // r12
long long v19; // r13
BOOL v20; // ebp
v10 = JS_NewRuntime();
if ( v10 )
{
v11 = v10;
v12 = (unsigned int *)JS_NewContextRaw(v10);
if ( v12 )
{
v13 = v12;
JS_AddIntrinsicRegExp(v12);
v16 = _JS_EvalInternal(
(long long)v13,
0LL,
3LL,
a1,
a2,
"<unnamed>",
a3,
a4,
a5,
a6,
v14,
v15,
a9,
a10,
0x21u,
0xFFFFFFFF);
v18 = v17;
if ( (_DWORD)v17 == 6 )
{
v19 = JS_ToCString_1((long long)v13, *(_QWORD *)(v11 + 240), *(_QWORD *)(v11 + 248));
v20 = strstr(v19, "ReferenceError: could not load module") != 0;
JS_FreeCString((long long)v13, v19);
}
else
{
v20 = 1;
}
JS_FreeValue((long long)v13, v16, v18);
JS_FreeContext(v13);
}
else
{
v20 = 0;
}
JS_FreeRuntime(v11);
}
else
{
return 0;
}
return v20;
}
| JS_DetectModule:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RSI
MOV R12,RDI
CALL 0x0011b9f6
TEST RAX,RAX
JZ 0x001372aa
MOV RBX,RAX
MOV RDI,RAX
CALL 0x0011be8d
TEST RAX,RAX
JZ 0x001372ae
MOV R14,RAX
MOV RDI,RAX
CALL 0x0011cd6b
OR dword ptr [RSP + 0x8],0xffffffff
MOV dword ptr [RSP],0x21
LEA R9,[0x189079]
PUSH 0x3
POP RDX
MOV RDI,R14
XOR ESI,ESI
MOV RCX,R12
MOV R8,R15
CALL 0x001344b0
MOV R15,RAX
MOV R12,RDX
CMP R12D,0x6
JNZ 0x001372b2
MOV RSI,qword ptr [RBX + 0xf0]
MOV RDX,qword ptr [RBX + 0xf8]
MOV RDI,R14
CALL 0x0011e5bd
MOV R13,RAX
LEA RSI,[0x189083]
MOV RDI,RAX
CALL 0x0010ea30
XOR EBP,EBP
TEST RAX,RAX
SETNZ BPL
MOV RDI,R14
MOV RSI,R13
CALL 0x0011ec07
JMP 0x001372b5
LAB_001372aa:
XOR EBP,EBP
JMP 0x001372d3
LAB_001372ae:
XOR EBP,EBP
JMP 0x001372cb
LAB_001372b2:
PUSH 0x1
POP RBP
LAB_001372b5:
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x0011bbce
MOV RDI,R14
CALL 0x0011dae6
LAB_001372cb:
MOV RDI,RBX
CALL 0x0011b842
LAB_001372d3:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
bool JS_DetectModule(int8 param_1,int8 param_2)
{
long lVar1;
long lVar2;
char *__haystack;
char *pcVar3;
bool bVar4;
int1 auVar5 [16];
lVar1 = JS_NewRuntime();
if (lVar1 == 0) {
bVar4 = false;
}
else {
lVar2 = JS_NewContextRaw(lVar1);
if (lVar2 == 0) {
bVar4 = false;
}
else {
JS_AddIntrinsicRegExp(lVar2);
auVar5 = __JS_EvalInternal(lVar2,0,3,param_1,param_2,"<unnamed>",0x21,0xffffffff);
if (auVar5._8_4_ == 6) {
__haystack = (char *)JS_ToCString(lVar2,*(int8 *)(lVar1 + 0xf0),
*(int8 *)(lVar1 + 0xf8));
pcVar3 = strstr(__haystack,"ReferenceError: could not load module");
bVar4 = pcVar3 != (char *)0x0;
JS_FreeCString(lVar2,__haystack);
}
else {
bVar4 = true;
}
JS_FreeValue(lVar2,auVar5._0_8_,auVar5._8_8_);
JS_FreeContext(lVar2);
}
JS_FreeRuntime(lVar1);
}
return bVar4;
}
| |
25,902 | code_has_label | bluesky950520[P]quickjs/quickjs.c | static BOOL code_has_label(CodeContext *s, int pos, int label)
{
while (pos < s->bc_len) {
int op = s->bc_buf[pos];
if (op == OP_source_loc) {
pos += 9;
continue;
}
if (op == OP_label) {
int lab = get_u32(s->bc_buf + pos + 1);
if (lab == label)
return TRUE;
pos += 5;
continue;
}
if (op == OP_goto) {
int lab = get_u32(s->bc_buf + pos + 1);
if (lab == label)
return TRUE;
}
break;
}
return FALSE;
} | O0 | c | code_has_label:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xc3046
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
cmpl $0xc4, 0xc(%rsp)
jne 0xc2fbf
movl 0x14(%rsp), %eax
addl $0x9, %eax
movl %eax, 0x14(%rsp)
jmp 0xc2f81
cmpl $0xb5, 0xc(%rsp)
jne 0xc300a
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movslq 0x14(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
callq 0x654a0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x10(%rsp), %eax
jne 0xc2ffa
movl $0x1, 0x24(%rsp)
jmp 0xc304e
movl 0x14(%rsp), %eax
addl $0x5, %eax
movl %eax, 0x14(%rsp)
jmp 0xc2f81
cmpl $0x6b, 0xc(%rsp)
jne 0xc3044
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movslq 0x14(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
callq 0x654a0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x10(%rsp), %eax
jne 0xc3042
movl $0x1, 0x24(%rsp)
jmp 0xc304e
jmp 0xc3044
jmp 0xc3046
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| code_has_label:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], esi
mov [rsp+28h+var_18], edx
loc_C2F81:
mov eax, [rsp+28h+var_14]
mov rcx, [rsp+28h+var_10]
cmp eax, [rcx+8]
jge loc_C3046
mov rax, [rsp+28h+var_10]
mov rax, [rax]
movsxd rcx, [rsp+28h+var_14]
movzx eax, byte ptr [rax+rcx]
mov [rsp+28h+var_1C], eax
cmp [rsp+28h+var_1C], 0C4h
jnz short loc_C2FBF
mov eax, [rsp+28h+var_14]
add eax, 9
mov [rsp+28h+var_14], eax
jmp short loc_C2F81
loc_C2FBF:
cmp [rsp+28h+var_1C], 0B5h
jnz short loc_C300A
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
movsxd rax, [rsp+28h+var_14]
add rdi, rax
add rdi, 1
call get_u32
mov [rsp+28h+var_20], eax
mov eax, [rsp+28h+var_20]
cmp eax, [rsp+28h+var_18]
jnz short loc_C2FFA
mov [rsp+28h+var_4], 1
jmp short loc_C304E
loc_C2FFA:
mov eax, [rsp+28h+var_14]
add eax, 5
mov [rsp+28h+var_14], eax
jmp loc_C2F81
loc_C300A:
cmp [rsp+28h+var_1C], 6Bh ; 'k'
jnz short loc_C3044
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
movsxd rax, [rsp+28h+var_14]
add rdi, rax
add rdi, 1
call get_u32
mov [rsp+28h+var_24], eax
mov eax, [rsp+28h+var_24]
cmp eax, [rsp+28h+var_18]
jnz short loc_C3042
mov [rsp+28h+var_4], 1
jmp short loc_C304E
loc_C3042:
jmp short $+2
loc_C3044:
jmp short $+2
loc_C3046:
mov [rsp+28h+var_4], 0
loc_C304E:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long code_has_label(long long a1, int a2, int a3)
{
int v4; // [rsp+Ch] [rbp-1Ch]
while ( a2 < *(_DWORD *)(a1 + 8) )
{
v4 = *(unsigned __int8 *)(*(_QWORD *)a1 + a2);
if ( v4 == 196 )
{
a2 += 9;
}
else
{
if ( v4 != 181 )
{
if ( v4 == 107 && (unsigned int)get_u32((unsigned int *)(a2 + *(_QWORD *)a1 + 1LL)) == a3 )
return 1;
break;
}
if ( (unsigned int)get_u32((unsigned int *)(a2 + *(_QWORD *)a1 + 1LL)) == a3 )
return 1;
a2 += 5;
}
}
return 0;
}
| code_has_label:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],ESI
MOV dword ptr [RSP + 0x10],EDX
LAB_001c2f81:
MOV EAX,dword ptr [RSP + 0x14]
MOV RCX,qword ptr [RSP + 0x18]
CMP EAX,dword ptr [RCX + 0x8]
JGE 0x001c3046
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RSP + 0x14]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RSP + 0xc],0xc4
JNZ 0x001c2fbf
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x9
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001c2f81
LAB_001c2fbf:
CMP dword ptr [RSP + 0xc],0xb5
JNZ 0x001c300a
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX]
MOVSXD RAX,dword ptr [RSP + 0x14]
ADD RDI,RAX
ADD RDI,0x1
CALL 0x001654a0
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RSP + 0x8]
CMP EAX,dword ptr [RSP + 0x10]
JNZ 0x001c2ffa
MOV dword ptr [RSP + 0x24],0x1
JMP 0x001c304e
LAB_001c2ffa:
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x5
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001c2f81
LAB_001c300a:
CMP dword ptr [RSP + 0xc],0x6b
JNZ 0x001c3044
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX]
MOVSXD RAX,dword ptr [RSP + 0x14]
ADD RDI,RAX
ADD RDI,0x1
CALL 0x001654a0
MOV dword ptr [RSP + 0x4],EAX
MOV EAX,dword ptr [RSP + 0x4]
CMP EAX,dword ptr [RSP + 0x10]
JNZ 0x001c3042
MOV dword ptr [RSP + 0x24],0x1
JMP 0x001c304e
LAB_001c3042:
JMP 0x001c3044
LAB_001c3044:
JMP 0x001c3046
LAB_001c3046:
MOV dword ptr [RSP + 0x24],0x0
LAB_001c304e:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 code_has_label(long *param_1,int param_2,int param_3)
{
char cVar1;
int iVar2;
int local_14;
local_14 = param_2;
while( true ) {
while( true ) {
if ((int)param_1[1] <= local_14) {
return 0;
}
cVar1 = *(char *)(*param_1 + (long)local_14);
if (cVar1 != -0x3c) break;
local_14 = local_14 + 9;
}
if (cVar1 != -0x4b) break;
iVar2 = get_u32(*param_1 + (long)local_14 + 1);
if (iVar2 == param_3) {
return 1;
}
local_14 = local_14 + 5;
}
if (cVar1 != 'k') {
return 0;
}
iVar2 = get_u32(*param_1 + (long)local_14 + 1);
if (iVar2 != param_3) {
return 0;
}
return 1;
}
| |
25,903 | unsigned int rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseHex4<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, unsigned long) | mnn-tts/MNN/3rd_party/rapidjson/reader.h | unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
unsigned codepoint = 0;
for (int i = 0; i < 4; i++) {
Ch c = is.Peek();
codepoint <<= 4;
codepoint += static_cast<unsigned>(c);
if (c >= '0' && c <= '9')
codepoint -= '0';
else if (c >= 'A' && c <= 'F')
codepoint -= 'A' - 10;
else if (c >= 'a' && c <= 'f')
codepoint -= 'a' - 10;
else {
RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset);
RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
}
is.Take();
}
return codepoint;
} | O0 | c | unsigned int rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseHex4<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, unsigned long):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x4, 0x10(%rsp)
jge 0x1c8ce
movq 0x20(%rsp), %rdi
callq 0x196d0
movb %al, 0xf(%rsp)
movl 0x14(%rsp), %eax
shll $0x4, %eax
movl %eax, 0x14(%rsp)
movsbl 0xf(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x30, %eax
jl 0x1c801
movsbl 0xf(%rsp), %eax
cmpl $0x39, %eax
jg 0x1c801
movl 0x14(%rsp), %eax
subl $0x30, %eax
movl %eax, 0x14(%rsp)
jmp 0x1c8b4
movsbl 0xf(%rsp), %eax
cmpl $0x41, %eax
jl 0x1c825
movsbl 0xf(%rsp), %eax
cmpl $0x46, %eax
jg 0x1c825
movl 0x14(%rsp), %eax
subl $0x37, %eax
movl %eax, 0x14(%rsp)
jmp 0x1c8b2
movsbl 0xf(%rsp), %eax
cmpl $0x61, %eax
jl 0x1c846
movsbl 0xf(%rsp), %eax
cmpl $0x66, %eax
jg 0x1c846
movl 0x14(%rsp), %eax
subl $0x57, %eax
movl %eax, 0x14(%rsp)
jmp 0x1c8b0
jmp 0x1c848
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c859
jmp 0x1c85b
jmp 0x1c87a
leaq 0x70b4(%rip), %rdi # 0x23916
leaq 0x70be(%rip), %rsi # 0x23927
movl $0x395, %edx # imm = 0x395
leaq 0x7b9c(%rip), %rcx # 0x24411
callq 0x4100
movq (%rsp), %rdi
movq 0x18(%rsp), %rdx
movl $0x8, %esi
callq 0x196e0
jmp 0x1c88f
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c8a2
jmp 0x1c8ac
movl $0x0, 0x34(%rsp)
jmp 0x1c8d6
jmp 0x1c8ae
jmp 0x1c8b0
jmp 0x1c8b2
jmp 0x1c8b4
movq 0x20(%rsp), %rdi
callq 0x19960
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1c7ac
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
| _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE9ParseHex4INS_19GenericStringStreamIS2_EEEEjRT_m:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_20], rdx
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_38], rax
mov [rsp+38h+var_24], 0
mov [rsp+38h+var_28], 0
loc_1C7AC:
cmp [rsp+38h+var_28], 4
jge loc_1C8CE
mov rdi, [rsp+38h+var_18]
call _ZNK9rapidjson19GenericStringStreamINS_4UTF8IcEEE4PeekEv; rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Peek(void)
mov [rsp+38h+var_29], al
mov eax, [rsp+38h+var_24]
shl eax, 4
mov [rsp+38h+var_24], eax
movsx eax, [rsp+38h+var_29]
add eax, [rsp+38h+var_24]
mov [rsp+38h+var_24], eax
movsx eax, [rsp+38h+var_29]
cmp eax, 30h ; '0'
jl short loc_1C801
movsx eax, [rsp+38h+var_29]
cmp eax, 39h ; '9'
jg short loc_1C801
mov eax, [rsp+38h+var_24]
sub eax, 30h ; '0'
mov [rsp+38h+var_24], eax
jmp loc_1C8B4
loc_1C801:
movsx eax, [rsp+38h+var_29]
cmp eax, 41h ; 'A'
jl short loc_1C825
movsx eax, [rsp+38h+var_29]
cmp eax, 46h ; 'F'
jg short loc_1C825
mov eax, [rsp+38h+var_24]
sub eax, 37h ; '7'
mov [rsp+38h+var_24], eax
jmp loc_1C8B2
loc_1C825:
movsx eax, [rsp+38h+var_29]
cmp eax, 61h ; 'a'
jl short loc_1C846
movsx eax, [rsp+38h+var_29]
cmp eax, 66h ; 'f'
jg short loc_1C846
mov eax, [rsp+38h+var_24]
sub eax, 57h ; 'W'
mov [rsp+38h+var_24], eax
jmp short loc_1C8B0
loc_1C846:
jmp short $+2
loc_1C848:
mov rdi, [rsp+38h+var_38]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
test al, 1
jnz short loc_1C859
jmp short loc_1C85B
loc_1C859:
jmp short loc_1C87A
loc_1C85B:
lea rdi, aHasparseerror; "!HasParseError()"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/mnn-tt"...
mov edx, 395h
lea rcx, aUnsignedIntRap; "unsigned int rapidjson::GenericReader<r"...
call ___assert_fail
loc_1C87A:
mov rdi, [rsp+38h+var_38]
mov rdx, [rsp+38h+var_20]
mov esi, 8
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13SetParseErrorENS_14ParseErrorCodeEm; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SetParseError(rapidjson::ParseErrorCode,ulong)
jmp short $+2
loc_1C88F:
mov rdi, [rsp+38h+var_38]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1C8A2
jmp short loc_1C8AC
loc_1C8A2:
mov [rsp+38h+var_4], 0
jmp short loc_1C8D6
loc_1C8AC:
jmp short $+2
loc_1C8AE:
jmp short $+2
loc_1C8B0:
jmp short $+2
loc_1C8B2:
jmp short $+2
loc_1C8B4:
mov rdi, [rsp+38h+var_18]
call _ZN9rapidjson19GenericStringStreamINS_4UTF8IcEEE4TakeEv; rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Take(void)
mov eax, [rsp+38h+var_28]
add eax, 1
mov [rsp+38h+var_28], eax
jmp loc_1C7AC
loc_1C8CE:
mov eax, [rsp+38h+var_24]
mov [rsp+38h+var_4], eax
loc_1C8D6:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::ParseHex4<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(
long long a1,
_QWORD *a2,
long long a3)
{
char v4; // [rsp+Fh] [rbp-29h]
int i; // [rsp+10h] [rbp-28h]
unsigned int v6; // [rsp+14h] [rbp-24h]
v6 = 0;
for ( i = 0; i < 4; ++i )
{
v4 = rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Peek((long long)a2);
v6 = 16 * v6 + v4;
if ( v4 < 48 || v4 > 57 )
{
if ( v4 < 65 || v4 > 70 )
{
if ( v4 < 97 || v4 > 102 )
{
if ( (rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1) & 1) != 0 )
__assert_fail(
"!HasParseError()",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h",
917LL,
"unsigned int rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseHex4(InputStream &, size"
"_t) [SourceEncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::C"
"rtAllocator, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>]");
rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SetParseError(
a1,
8u,
a3);
if ( (rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1) & 1) != 0 )
return 0;
}
else
{
v6 -= 87;
}
}
else
{
v6 -= 55;
}
}
else
{
v6 -= 48;
}
rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Take(a2);
}
return v6;
}
| ParseHex4<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP],RAX
MOV dword ptr [RSP + 0x14],0x0
MOV dword ptr [RSP + 0x10],0x0
LAB_0011c7ac:
CMP dword ptr [RSP + 0x10],0x4
JGE 0x0011c8ce
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001196d0
MOV byte ptr [RSP + 0xf],AL
MOV EAX,dword ptr [RSP + 0x14]
SHL EAX,0x4
MOV dword ptr [RSP + 0x14],EAX
MOVSX EAX,byte ptr [RSP + 0xf]
ADD EAX,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x14],EAX
MOVSX EAX,byte ptr [RSP + 0xf]
CMP EAX,0x30
JL 0x0011c801
MOVSX EAX,byte ptr [RSP + 0xf]
CMP EAX,0x39
JG 0x0011c801
MOV EAX,dword ptr [RSP + 0x14]
SUB EAX,0x30
MOV dword ptr [RSP + 0x14],EAX
JMP 0x0011c8b4
LAB_0011c801:
MOVSX EAX,byte ptr [RSP + 0xf]
CMP EAX,0x41
JL 0x0011c825
MOVSX EAX,byte ptr [RSP + 0xf]
CMP EAX,0x46
JG 0x0011c825
MOV EAX,dword ptr [RSP + 0x14]
SUB EAX,0x37
MOV dword ptr [RSP + 0x14],EAX
JMP 0x0011c8b2
LAB_0011c825:
MOVSX EAX,byte ptr [RSP + 0xf]
CMP EAX,0x61
JL 0x0011c846
MOVSX EAX,byte ptr [RSP + 0xf]
CMP EAX,0x66
JG 0x0011c846
MOV EAX,dword ptr [RSP + 0x14]
SUB EAX,0x57
MOV dword ptr [RSP + 0x14],EAX
JMP 0x0011c8b0
LAB_0011c846:
JMP 0x0011c848
LAB_0011c848:
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011c859
JMP 0x0011c85b
LAB_0011c859:
JMP 0x0011c87a
LAB_0011c85b:
LEA RDI,[0x123916]
LEA RSI,[0x123927]
MOV EDX,0x395
LEA RCX,[0x124411]
CALL 0x00104100
LAB_0011c87a:
MOV RDI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x18]
MOV ESI,0x8
CALL 0x001196e0
JMP 0x0011c88f
LAB_0011c88f:
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011c8a2
JMP 0x0011c8ac
LAB_0011c8a2:
MOV dword ptr [RSP + 0x34],0x0
JMP 0x0011c8d6
LAB_0011c8ac:
JMP 0x0011c8ae
LAB_0011c8ae:
JMP 0x0011c8b0
LAB_0011c8b0:
JMP 0x0011c8b2
LAB_0011c8b2:
JMP 0x0011c8b4
LAB_0011c8b4:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00119960
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
MOV dword ptr [RSP + 0x10],EAX
JMP 0x0011c7ac
LAB_0011c8ce:
MOV EAX,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x34],EAX
LAB_0011c8d6:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
/* unsigned int rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>,
rapidjson::CrtAllocator>::ParseHex4<rapidjson::GenericStringStream<rapidjson::UTF8<char> >
>(rapidjson::GenericStringStream<rapidjson::UTF8<char> >&, unsigned long) */
uint __thiscall
rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::
ParseHex4<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>
(GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator> *this,
GenericStringStream *param_1,ulong param_2)
{
char cVar1;
byte bVar2;
int local_28;
uint local_24;
local_24 = 0;
local_28 = 0;
do {
if (3 < local_28) {
return local_24;
}
cVar1 = GenericStringStream<rapidjson::UTF8<char>>::Peek
((GenericStringStream<rapidjson::UTF8<char>> *)param_1);
local_24 = (int)cVar1 + local_24 * 0x10;
if ((cVar1 < '0') || ('9' < cVar1)) {
if ((cVar1 < 'A') || ('F' < cVar1)) {
if ((cVar1 < 'a') || ('f' < cVar1)) {
bVar2 = HasParseError(this);
if (((bVar2 ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!HasParseError()",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h"
,0x395,
"unsigned int rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseHex4(InputStream &, size_t) [SourceEncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::CrtAllocator, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>]"
);
}
SetParseError(this,8,param_2);
bVar2 = HasParseError(this);
if ((bVar2 & 1) != 0) {
return 0;
}
}
else {
local_24 = local_24 - 0x57;
}
}
else {
local_24 = local_24 - 0x37;
}
}
else {
local_24 = local_24 - 0x30;
}
GenericStringStream<rapidjson::UTF8<char>>::Take
((GenericStringStream<rapidjson::UTF8<char>> *)param_1);
local_28 = local_28 + 1;
} while( true );
}
| |
25,904 | ok | eloqsql/unittest/mytap/tap.c | void
ok(int pass, char const *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
if (!pass && *g_test.todo == '\0')
++g_test.failed;
vemit_tap(pass, fmt, ap);
va_end(ap);
if (*g_test.todo != '\0')
emit_dir("todo", g_test.todo);
emit_endl();
} | O0 | c | ok:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x26bd8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpl $0x0, -0x4(%rbp)
jne 0x26c40
movsbl 0x36a740(%rip), %eax # 0x39136c
cmpl $0x0, %eax
jne 0x26c40
movl 0x36a731(%rip), %eax # 0x391368
addl $0x1, %eax
movl %eax, 0x36a728(%rip) # 0x391368
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x26c90
leaq -0x30(%rbp), %rax
movsbl 0x36a711(%rip), %eax # 0x39136c
cmpl $0x0, %eax
je 0x26c77
leaq 0x5b9b5(%rip), %rdi # 0x8261c
leaq 0x36a6f2(%rip), %rsi # 0x391360
addq $0xc, %rsi
callq 0x26d70
callq 0x271d0
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ok:
push rbp
mov rbp, rsp
sub rsp, 0E0h
test al, al
jz short loc_26BD8
movaps [rbp+var_B0], xmm0
movaps [rbp+var_A0], xmm1
movaps [rbp+var_90], xmm2
movaps [rbp+var_80], xmm3
movaps [rbp+var_70], xmm4
movaps [rbp+var_60], xmm5
movaps [rbp+var_50], xmm6
movaps [rbp+var_40], xmm7
loc_26BD8:
mov [rbp+var_B8], r9
mov [rbp+var_C0], r8
mov [rbp+var_C8], rcx
mov [rbp+var_D0], rdx
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_E0]
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
cmp [rbp+var_4], 0
jnz short loc_26C40
movsx eax, cs:byte_39136C
cmp eax, 0
jnz short loc_26C40
mov eax, cs:dword_391368
add eax, 1
mov cs:dword_391368, eax
loc_26C40:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_30]
call vemit_tap
lea rax, [rbp+var_30]
movsx eax, cs:byte_39136C
cmp eax, 0
jz short loc_26C77
lea rdi, aTodo; "todo"
lea rsi, g_test
add rsi, 0Ch
call emit_dir
loc_26C77:
call emit_endl
add rsp, 0E0h
pop rbp
retn
| long long ok(unsigned int a1, long long a2, ...)
{
va_list va; // [rsp+B0h] [rbp-30h] BYREF
long long v4; // [rsp+D0h] [rbp-10h]
unsigned int v5; // [rsp+DCh] [rbp-4h]
va_start(va, a2);
v5 = a1;
v4 = a2;
if ( !a1 && !byte_39136C )
++dword_391368;
vemit_tap(v5, v4, va);
if ( byte_39136C )
emit_dir("todo", &g_test + 3);
return emit_endl();
}
| ok:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
TEST AL,AL
JZ 0x00126bd8
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM1
MOVAPS xmmword ptr [RBP + -0x90],XMM2
MOVAPS xmmword ptr [RBP + -0x80],XMM3
MOVAPS xmmword ptr [RBP + -0x70],XMM4
MOVAPS xmmword ptr [RBP + -0x60],XMM5
MOVAPS xmmword ptr [RBP + -0x50],XMM6
MOVAPS xmmword ptr [RBP + -0x40],XMM7
LAB_00126bd8:
MOV qword ptr [RBP + -0xb8],R9
MOV qword ptr [RBP + -0xc0],R8
MOV qword ptr [RBP + -0xc8],RCX
MOV qword ptr [RBP + -0xd0],RDX
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0xe0]
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
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x00126c40
MOVSX EAX,byte ptr [0x0049136c]
CMP EAX,0x0
JNZ 0x00126c40
MOV EAX,dword ptr [0x00491368]
ADD EAX,0x1
MOV dword ptr [0x00491368],EAX
LAB_00126c40:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x30]
CALL 0x00126c90
LEA RAX,[RBP + -0x30]
MOVSX EAX,byte ptr [0x0049136c]
CMP EAX,0x0
JZ 0x00126c77
LEA RDI,[0x18261c]
LEA RSI,[0x491360]
ADD RSI,0xc
CALL 0x00126d70
LAB_00126c77:
CALL 0x001271d0
ADD RSP,0xe0
POP RBP
RET
|
void ok(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,int param_9,
int8 param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
char in_AL;
int1 local_e8 [16];
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int4 local_38;
int4 local_34;
int1 *local_30;
int1 *local_28;
int8 local_18;
int local_c;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
local_28 = local_e8;
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
if ((param_9 == 0) && (DAT_0049136c == '\0')) {
DAT_00491368 = DAT_00491368 + 1;
}
local_d8 = param_11;
local_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
local_18 = param_10;
local_c = param_9;
vemit_tap(param_9,param_10,&local_38);
if (DAT_0049136c != '\0') {
emit_dir(&DAT_0018261c,&DAT_0049136c);
}
emit_endl();
return;
}
| |
25,905 | ok | eloqsql/unittest/mytap/tap.c | void
ok(int pass, char const *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
if (!pass && *g_test.todo == '\0')
++g_test.failed;
vemit_tap(pass, fmt, ap);
va_end(ap);
if (*g_test.todo != '\0')
emit_dir("todo", g_test.todo);
emit_endl();
} | O3 | c | ok:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
leaq -0xd0(%rbp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x26784
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r10, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, -0x20(%rbp)
testl %edi, %edi
jne 0x267b1
cmpb $0x0, 0x346f63(%rip) # 0x36d70c
jne 0x267b1
incl 0x346f57(%rip) # 0x36d708
leaq -0x20(%rbp), %rdx
callq 0x26825
cmpb $0x0, 0x346f4b(%rip) # 0x36d70c
je 0x267f6
movq 0x2cf7de(%rip), %rbx # 0x2f5fa8
movq (%rbx), %rdi
leaq 0x3aeb9(%rip), %rdx # 0x6168d
leaq 0x3ae41(%rip), %rcx # 0x6161c
leaq 0x346f2a(%rip), %r8 # 0x36d70c
movl $0x1, %esi
xorl %eax, %eax
callq 0x245f0
movq (%rbx), %rdi
callq 0x243d0
movq 0x2cf7ab(%rip), %rbx # 0x2f5fa8
movq (%rbx), %rdi
leaq 0x3f54c(%rip), %rdx # 0x65d53
movl $0x1, %esi
xorl %eax, %eax
callq 0x245f0
movq (%rbx), %rdi
callq 0x243d0
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
| ok:
push rbp
mov rbp, rsp
push rbx
sub rsp, 0C8h
lea r10, [rbp+var_D0]
mov [r10+10h], rdx
mov [r10+18h], rcx
mov [r10+20h], r8
mov [r10+28h], r9
test al, al
jz short loc_26784
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_26784:
mov [rbp+var_10], r10
lea rax, [rbp+arg_0]
mov [rbp+var_18], rax
mov rax, 3000000010h
mov [rbp+var_20], rax
test edi, edi
jnz short loc_267B1
cmp cs:byte_36D70C, 0
jnz short loc_267B1
inc cs:dword_36D708
loc_267B1:
lea rdx, [rbp+var_20]
call vemit_tap
cmp cs:byte_36D70C, 0
jz short loc_267F6
mov rbx, cs:stdout_ptr
mov rdi, [rbx]
lea rdx, aSS; " # %s %s"
lea rcx, aTodo; "todo"
lea r8, byte_36D70C
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
call _fflush
loc_267F6:
mov rbx, cs:stdout_ptr
mov rdi, [rbx]
lea rdx, asc_65D50+3; "\n"
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
call _fflush
add rsp, 0C8h
pop rbx
pop rbp
retn
| long long ok(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v16; // [rsp+0h] [rbp-D0h] BYREF
long long v17; // [rsp+10h] [rbp-C0h]
long long v18; // [rsp+18h] [rbp-B8h]
long long v19; // [rsp+20h] [rbp-B0h]
long long v20; // [rsp+28h] [rbp-A8h]
__m128 v21; // [rsp+30h] [rbp-A0h]
__m128 v22; // [rsp+40h] [rbp-90h]
__m128 v23; // [rsp+50h] [rbp-80h]
__m128 v24; // [rsp+60h] [rbp-70h]
__m128 v25; // [rsp+70h] [rbp-60h]
__m128 v26; // [rsp+80h] [rbp-50h]
__m128 v27; // [rsp+90h] [rbp-40h]
__m128 v28; // [rsp+A0h] [rbp-30h]
_QWORD v29[4]; // [rsp+B0h] [rbp-20h] BYREF
v21 = a7;
v22 = a8;
v23 = a9;
v24 = a10;
v25 = a11;
v26 = a12;
v27 = a13;
v28 = a14;
v17 = a3;
v18 = a4;
v19 = a5;
v20 = a6;
v29[2] = &v16;
v29[1] = &a15;
v29[0] = 0x3000000010LL;
if ( !(_DWORD)a1 && !byte_36D70C )
++dword_36D708;
vemit_tap(a1, a2, v29);
if ( byte_36D70C )
{
__fprintf_chk(stdout, 1LL, " # %s %s", "todo", &byte_36D70C);
fflush(stdout);
}
__fprintf_chk(stdout, 1LL, "\n");
return fflush(stdout);
}
| ok:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xc8
LEA R10,[RBP + -0xd0]
MOV qword ptr [R10 + 0x10],RDX
MOV qword ptr [R10 + 0x18],RCX
MOV qword ptr [R10 + 0x20],R8
MOV qword ptr [R10 + 0x28],R9
TEST AL,AL
JZ 0x00126784
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_00126784:
MOV qword ptr [RBP + -0x10],R10
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,0x3000000010
MOV qword ptr [RBP + -0x20],RAX
TEST EDI,EDI
JNZ 0x001267b1
CMP byte ptr [0x0046d70c],0x0
JNZ 0x001267b1
INC dword ptr [0x0046d708]
LAB_001267b1:
LEA RDX,[RBP + -0x20]
CALL 0x00126825
CMP byte ptr [0x0046d70c],0x0
JZ 0x001267f6
MOV RBX,qword ptr [0x003f5fa8]
MOV RDI,qword ptr [RBX]
LEA RDX,[0x16168d]
LEA RCX,[0x16161c]
LEA R8,[0x46d70c]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001245f0
MOV RDI,qword ptr [RBX]
CALL 0x001243d0
LAB_001267f6:
MOV RBX,qword ptr [0x003f5fa8]
MOV RDI,qword ptr [RBX]
LEA RDX,[0x165d53]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001245f0
MOV RDI,qword ptr [RBX]
CALL 0x001243d0
ADD RSP,0xc8
POP RBX
POP RBP
RET
|
void ok(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
int *puVar1;
char in_AL;
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
int1 *local_20;
int1 *local_18;
local_18 = local_d8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_20 = &stack0x00000008;
local_28 = 0x3000000010;
if (((int)param_9 == 0) && (DAT_0046d70c == '\0')) {
DAT_0046d708 = DAT_0046d708 + 1;
}
local_c8 = param_11;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
vemit_tap(param_9,param_10,&local_28);
puVar1 = PTR_stdout_003f5fa8;
if (DAT_0046d70c != '\0') {
__fprintf_chk(*(int8 *)PTR_stdout_003f5fa8,1," # %s %s",&DAT_0016161c,&DAT_0046d70c);
fflush(*(FILE **)puVar1);
}
puVar1 = PTR_stdout_003f5fa8;
__fprintf_chk(*(int8 *)PTR_stdout_003f5fa8,1,&DAT_00165d53);
fflush(*(FILE **)puVar1);
return;
}
| |
25,906 | my_getwd | eloqsql/mysys/my_getwd.c | int my_getwd(char * buf, size_t size, myf MyFlags)
{
char * pos;
DBUG_ENTER("my_getwd");
DBUG_PRINT("my",("buf:%p size: %u MyFlags %lu",
buf, (uint) size, MyFlags));
if (size < 1)
DBUG_RETURN(-1);
if (curr_dir[0]) /* Current pos is saved here */
(void) strmake(buf,&curr_dir[0],size-1);
else
{
#if defined(HAVE_GETCWD)
if (size < 2)
DBUG_RETURN(-1);
if (!getcwd(buf,(uint) (size-2)) && MyFlags & MY_WME)
{
my_errno=errno;
my_error(EE_GETWD,MYF(ME_BELL),errno);
DBUG_RETURN(-1);
}
#elif defined(HAVE_GETWD)
{
char pathname[MAXPATHLEN];
getwd(pathname);
strmake(buf,pathname,size-1);
}
#else
#error "No way to get current directory"
#endif
if (*((pos=strend(buf))-1) != FN_LIBCHAR) /* End with FN_LIBCHAR */
{
pos[0]= FN_LIBCHAR;
pos[1]=0;
}
(void) strmake(&curr_dir[0],buf, (size_t) (FN_REFLEN-1));
}
DBUG_RETURN(0);
} | O3 | c | my_getwd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x61555
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x35d2fc(%rip), %rax # 0x3be7f0
cmpb $0x0, (%rax)
je 0x6150f
decq %rdx
leaq 0x35d2ed(%rip), %rsi # 0x3be7f0
movq %r14, %rdi
callq 0x9292c
xorl %ebx, %ebx
jmp 0x61555
cmpq $0x1, %rdx
je 0x61555
addl $-0x2, %edx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x363c0
testb $0x10, %r15b
je 0x61562
testq %rax, %rax
jne 0x61562
callq 0x36a30
movq %rax, %r14
movl (%rax), %r15d
callq 0x6337a
movl %r15d, (%rax)
movl (%r14), %edx
movl $0x4, %esi
movl $0x10, %edi
xorl %eax, %eax
callq 0x5e6bb
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x928e4
cmpb $0x2f, -0x1(%rax)
je 0x61575
movw $0x2f, (%rax)
leaq 0x35d274(%rip), %rdi # 0x3be7f0
movl $0x1ff, %edx # imm = 0x1FF
movq %r14, %rsi
jmp 0x61506
| my_getwd:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, 0FFFFFFFFh
test rsi, rsi
jz short loc_61555
mov r15, rdx
mov rdx, rsi
mov r14, rdi
lea rax, curr_dir
cmp byte ptr [rax], 0
jz short loc_6150F
dec rdx
lea rsi, curr_dir
mov rdi, r14
loc_61506:
call strmake
xor ebx, ebx
jmp short loc_61555
loc_6150F:
cmp rdx, 1
jz short loc_61555
add edx, 0FFFFFFFEh
mov rdi, r14
mov rsi, rdx
call _getcwd
test r15b, 10h
jz short loc_61562
test rax, rax
jnz short loc_61562
call ___errno_location
mov r14, rax
mov r15d, [rax]
call _my_thread_var
mov [rax], r15d
mov edx, [r14]
mov esi, 4
mov edi, 10h
xor eax, eax
call my_error
loc_61555:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_61562:
mov rdi, r14
call strend
cmp byte ptr [rax-1], 2Fh ; '/'
jz short loc_61575
mov word ptr [rax], 2Fh ; '/'
loc_61575:
lea rdi, curr_dir
mov edx, 1FFh
mov rsi, r14
jmp short loc_61506
| long long my_getwd(_BYTE *a1, long long a2, char a3)
{
unsigned int v3; // ebx
_BYTE *v5; // r14
long long v6; // rdx
_BYTE *v7; // rsi
long long v8; // rax
unsigned int *v9; // r14
unsigned int v10; // r15d
_WORD *v12; // rax
v3 = -1;
if ( a2 )
{
v5 = a1;
if ( curr_dir[0] )
{
v6 = a2 - 1;
v7 = curr_dir;
}
else
{
if ( a2 == 1 )
return v3;
v8 = getcwd(a1, (unsigned int)(a2 - 2));
if ( (a3 & 0x10) != 0 && !v8 )
{
v9 = (unsigned int *)__errno_location(a1);
v10 = *v9;
*(_DWORD *)my_thread_var(a1) = v10;
my_error(0x10u, 4LL, *v9);
return v3;
}
v12 = (_WORD *)strend(a1);
if ( *((_BYTE *)v12 - 1) != 47 )
*v12 = 47;
a1 = curr_dir;
v6 = 511LL;
v7 = v5;
}
strmake(a1, v7, v6);
return 0;
}
return v3;
}
| my_getwd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,0xffffffff
TEST RSI,RSI
JZ 0x00161555
MOV R15,RDX
MOV RDX,RSI
MOV R14,RDI
LEA RAX,[0x4be7f0]
CMP byte ptr [RAX],0x0
JZ 0x0016150f
DEC RDX
LEA RSI,[0x4be7f0]
MOV RDI,R14
LAB_00161506:
CALL 0x0019292c
XOR EBX,EBX
JMP 0x00161555
LAB_0016150f:
CMP RDX,0x1
JZ 0x00161555
ADD EDX,-0x2
MOV RDI,R14
MOV RSI,RDX
CALL 0x001363c0
TEST R15B,0x10
JZ 0x00161562
TEST RAX,RAX
JNZ 0x00161562
CALL 0x00136a30
MOV R14,RAX
MOV R15D,dword ptr [RAX]
CALL 0x0016337a
MOV dword ptr [RAX],R15D
MOV EDX,dword ptr [R14]
MOV ESI,0x4
MOV EDI,0x10
XOR EAX,EAX
CALL 0x0015e6bb
LAB_00161555:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00161562:
MOV RDI,R14
CALL 0x001928e4
CMP byte ptr [RAX + -0x1],0x2f
JZ 0x00161575
MOV word ptr [RAX],0x2f
LAB_00161575:
LEA RDI,[0x4be7f0]
MOV EDX,0x1ff
MOV RSI,R14
JMP 0x00161506
|
int8 my_getwd(char *param_1,long param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int *piVar4;
int2 *puVar5;
char *pcVar6;
if (param_2 == 0) {
return 0xffffffff;
}
if (curr_dir == '\0') {
if (param_2 == 1) {
return 0xffffffff;
}
pcVar2 = getcwd(param_1,(ulong)((int)param_2 - 2));
if (((param_3 & 0x10) != 0) && (pcVar2 == (char *)0x0)) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
my_error(0x10,4,*piVar3);
return 0xffffffff;
}
puVar5 = (int2 *)strend(param_1);
if (*(char *)((long)puVar5 + -1) != '/') {
*puVar5 = 0x2f;
}
pcVar6 = &curr_dir;
param_2 = 0x1ff;
pcVar2 = param_1;
}
else {
param_2 = param_2 + -1;
pcVar2 = &curr_dir;
pcVar6 = param_1;
}
strmake(pcVar6,pcVar2,param_2);
return 0;
}
| |
25,907 | stmt_cursor_fetch | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | static int stmt_cursor_fetch(MYSQL_STMT *stmt, uchar **row)
{
uchar buf[STMT_ID_LENGTH + 4];
MYSQL_DATA *result= &stmt->result;
if (stmt->state < MYSQL_STMT_USE_OR_STORE_CALLED)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
/* do we have some prefetched rows available ? */
if (stmt->result_cursor)
return(stmt_buffered_fetch(stmt, row));
if (stmt->upsert_status.server_status & SERVER_STATUS_LAST_ROW_SENT)
stmt->upsert_status.server_status&= ~SERVER_STATUS_LAST_ROW_SENT;
else
{
int4store(buf, stmt->stmt_id);
int4store(buf + STMT_ID_LENGTH, stmt->prefetch_rows);
if (stmt->mysql->methods->db_command(stmt->mysql, COM_STMT_FETCH, (char *)buf, sizeof(buf), 1, stmt))
{
UPDATE_STMT_ERROR(stmt);
return(1);
}
/* free previously allocated buffer */
ma_free_root(&result->alloc, MYF(MY_KEEP_PREALLOC));
result->data= 0;
result->rows= 0;
if (!stmt->mysql->options.extension->skip_read_response)
{
if (stmt->mysql->methods->db_stmt_read_all_rows(stmt))
return(1);
return(stmt_buffered_fetch(stmt, row));
}
}
/* no more cursor data available */
*row= NULL;
return(MYSQL_NO_DATA);
} | O0 | c | stmt_cursor_fetch:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, 0x50(%rax)
jae 0x26476
jmp 0x26407
movq -0x20(%rbp), %rax
movl $0x7de, 0x108(%rax) # imm = 0x7DE
movq -0x20(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x39a59(%rip), %rax # 0x5fe80
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x20(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x20(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x39a3f(%rip), %rax # 0x5fe90
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13210
movq -0x20(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x14(%rbp)
jmp 0x266e2
movq -0x20(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x26499
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2b290
movl %eax, -0x14(%rbp)
jmp 0x266e2
movq -0x20(%rbp), %rax
movl 0xf4(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x264c8
movq -0x20(%rbp), %rax
movl 0xf4(%rax), %ecx
andl $0xffffff7f, %ecx # imm = 0xFFFFFF7F
movl %ecx, 0xf4(%rax)
jmp 0x266d0
jmp 0x264ca
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movb %al, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x8, %rax
movb %al, -0xf(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x10, %rax
movb %al, -0xe(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x18, %rax
movb %al, -0xd(%rbp)
jmp 0x26504
movq -0x20(%rbp), %rax
movq 0x318(%rax), %rax
movb %al, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq 0x318(%rax), %rax
shrq $0x8, %rax
movb %al, -0xb(%rbp)
movq -0x20(%rbp), %rax
movq 0x318(%rax), %rax
shrq $0x10, %rax
movb %al, -0xa(%rbp)
movq -0x20(%rbp), %rax
movq 0x318(%rax), %rax
shrq $0x18, %rax
movb %al, -0x9(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rdi
leaq -0x10(%rbp), %rdx
movq -0x20(%rbp), %r9
movl $0x1c, %esi
movl $0x8, %ecx
movl $0x1, %r8d
callq *%rax
cmpl $0x0, %eax
je 0x26654
jmp 0x26588
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x90(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x108(%rax)
movq -0x20(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rsi
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x13210
movq -0x20(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x20(%rbp), %rax
addq $0x10c, %rax # imm = 0x10C
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x97, %rax
cmpq $0x0, %rax
je 0x26605
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x97, %rax
movq %rax, -0x40(%rbp)
jmp 0x2662b
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x90(%rax), %eax
subl $0x7d0, %eax # imm = 0x7D0
movl %eax, %eax
movl %eax, %ecx
leaq 0x3986d(%rip), %rax # 0x5fe90
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13210
movq -0x20(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x14(%rbp)
jmp 0x266e2
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0x24c20
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
cmpb $0x0, 0x148(%rax)
jne 0x266ce
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x60(%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x266bc
movl $0x1, -0x14(%rbp)
jmp 0x266e2
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2b290
movl %eax, -0x14(%rbp)
jmp 0x266e2
jmp 0x266d0
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0x64, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x26703
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
callq 0x134b0
nopl (%rax,%rax)
| stmt_cursor_fetch:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov rax, [rbp+var_20]
add rax, 80h
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
cmp dword ptr [rax+50h], 4
jnb short loc_26476
jmp short $+2
loc_26407:
mov rax, [rbp+var_20]
mov dword ptr [rax+108h], 7DEh
mov rdi, [rbp+var_20]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_20]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_20]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_20]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_14], 1
jmp loc_266E2
loc_26476:
mov rax, [rbp+var_20]
cmp qword ptr [rax+0E0h], 0
jz short loc_26499
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
call stmt_buffered_fetch
mov [rbp+var_14], eax
jmp loc_266E2
loc_26499:
mov rax, [rbp+var_20]
mov eax, [rax+0F4h]
and eax, 80h
cmp eax, 0
jz short loc_264C8
mov rax, [rbp+var_20]
mov ecx, [rax+0F4h]
and ecx, 0FFFFFF7Fh
mov [rax+0F4h], ecx
jmp loc_266D0
loc_264C8:
jmp short $+2
loc_264CA:
mov rax, [rbp+var_20]
mov rax, [rax+40h]
mov [rbp+var_10], al
mov rax, [rbp+var_20]
mov rax, [rax+40h]
shr rax, 8
mov [rbp+var_F], al
mov rax, [rbp+var_20]
mov rax, [rax+40h]
shr rax, 10h
mov [rbp+var_E], al
mov rax, [rbp+var_20]
mov rax, [rax+40h]
shr rax, 18h
mov [rbp+var_D], al
jmp short $+2
loc_26504:
mov rax, [rbp+var_20]
mov rax, [rax+318h]
mov [rbp+var_C], al
mov rax, [rbp+var_20]
mov rax, [rax+318h]
shr rax, 8
mov [rbp+var_B], al
mov rax, [rbp+var_20]
mov rax, [rax+318h]
shr rax, 10h
mov [rbp+var_A], al
mov rax, [rbp+var_20]
mov rax, [rax+318h]
shr rax, 18h
mov [rbp+var_9], al
mov rax, [rbp+var_20]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+10h]
mov rcx, [rbp+var_20]
mov rdi, [rcx+38h]
lea rdx, [rbp+var_10]
mov r9, [rbp+var_20]
mov esi, 1Ch
mov ecx, 8
mov r8d, 1
call rax
cmp eax, 0
jz loc_26654
jmp short $+2
loc_26588:
mov rax, [rbp+var_20]
mov rax, [rax+38h]
mov ecx, [rax+90h]
mov rax, [rbp+var_20]
mov [rax+108h], ecx
mov rdi, [rbp+var_20]
add rdi, 30Dh
mov rax, [rbp+var_20]
mov rsi, [rax+38h]
add rsi, 297h
mov edx, 5
call _strncpy
mov rax, [rbp+var_20]
mov byte ptr [rax+312h], 0
mov rax, [rbp+var_20]
add rax, 10Ch
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov rax, [rax+38h]
add rax, 97h
cmp rax, 0
jz short loc_26605
mov rax, [rbp+var_20]
mov rax, [rax+38h]
add rax, 97h
mov [rbp+var_40], rax
jmp short loc_2662B
loc_26605:
mov rax, [rbp+var_20]
mov rax, [rax+38h]
mov eax, [rax+90h]
sub eax, 7D0h
mov eax, eax
mov ecx, eax
lea rax, client_errors
mov rax, [rax+rcx*8]
mov [rbp+var_40], rax
loc_2662B:
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_40]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_20]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_14], 1
jmp loc_266E2
loc_26654:
mov rdi, [rbp+var_30]
add rdi, 10h
mov esi, 1
call ma_free_root
mov rax, [rbp+var_30]
mov qword ptr [rax], 0
mov rax, [rbp+var_30]
mov qword ptr [rax+48h], 0
mov rax, [rbp+var_20]
mov rax, [rax+38h]
mov rax, [rax+480h]
cmp byte ptr [rax+148h], 0
jnz short loc_266CE
mov rax, [rbp+var_20]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+60h]
mov rdi, [rbp+var_20]
call rax
cmp eax, 0
jz short loc_266BC
mov [rbp+var_14], 1
jmp short loc_266E2
loc_266BC:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
call stmt_buffered_fetch
mov [rbp+var_14], eax
jmp short loc_266E2
loc_266CE:
jmp short $+2
loc_266D0:
mov rax, [rbp+var_28]
mov qword ptr [rax], 0
mov [rbp+var_14], 64h ; 'd'
loc_266E2:
mov eax, [rbp+var_14]
mov [rbp+var_44], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_26703
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
loc_26703:
call ___stack_chk_fail
| long long stmt_cursor_fetch(long long a1, _QWORD *a2)
{
char *v2; // rax
_BYTE v5[8]; // [rsp+40h] [rbp-10h] BYREF
unsigned long long v6; // [rsp+48h] [rbp-8h]
v6 = __readfsqword(0x28u);
if ( *(_DWORD *)(a1 + 80) < 4u )
{
*(_DWORD *)(a1 + 264) = 2014;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[14], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
if ( *(_QWORD *)(a1 + 224) )
return (unsigned int)stmt_buffered_fetch(a1, a2);
if ( (*(_DWORD *)(a1 + 244) & 0x80) != 0 )
{
*(_DWORD *)(a1 + 244) &= ~0x80u;
LABEL_16:
*a2 = 0LL;
return 100;
}
v5[0] = *(_QWORD *)(a1 + 64);
v5[1] = BYTE1(*(_QWORD *)(a1 + 64));
v5[2] = BYTE2(*(_QWORD *)(a1 + 64));
v5[3] = BYTE3(*(_QWORD *)(a1 + 64));
v5[4] = *(_QWORD *)(a1 + 792);
v5[5] = BYTE1(*(_QWORD *)(a1 + 792));
v5[6] = BYTE2(*(_QWORD *)(a1 + 792));
v5[7] = BYTE3(*(_QWORD *)(a1 + 792));
if ( (*(unsigned int ( **)(_QWORD, long long, _BYTE *, long long, long long, long long))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL)
+ 16LL))(
*(_QWORD *)(a1 + 56),
28LL,
v5,
8LL,
1LL,
a1) )
{
*(_DWORD *)(a1 + 264) = *(_DWORD *)(*(_QWORD *)(a1 + 56) + 144LL);
strncpy(a1 + 781, *(_QWORD *)(a1 + 56) + 663LL, 5LL);
*(_BYTE *)(a1 + 786) = 0;
if ( *(_QWORD *)(a1 + 56) == -151LL )
v2 = client_errors[*(_DWORD *)(*(_QWORD *)(a1 + 56) + 144LL) - 2000];
else
v2 = (char *)(*(_QWORD *)(a1 + 56) + 151LL);
strncpy(a1 + 268, v2, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
else
{
ma_free_root((_QWORD *)(a1 + 144), 1);
*(_QWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 200) = 0LL;
if ( *(_BYTE *)(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1152LL) + 328LL) )
goto LABEL_16;
if ( (*(unsigned int ( **)(long long))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 96LL))(a1) )
return 1;
else
return (unsigned int)stmt_buffered_fetch(a1, a2);
}
}
| stmt_cursor_fetch:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x80
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x50],0x4
JNC 0x00126476
JMP 0x00126407
LAB_00126407:
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x108],0x7de
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x30d
LEA RAX,[0x15fe80]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x10c
LEA RAX,[0x15fe90]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001266e2
LAB_00126476:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0xe0],0x0
JZ 0x00126499
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x0012b290
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001266e2
LAB_00126499:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0xf4]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001264c8
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0xf4]
AND ECX,0xffffff7f
MOV dword ptr [RAX + 0xf4],ECX
JMP 0x001266d0
LAB_001264c8:
JMP 0x001264ca
LAB_001264ca:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x40]
MOV byte ptr [RBP + -0x10],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x40]
SHR RAX,0x8
MOV byte ptr [RBP + -0xf],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x40]
SHR RAX,0x10
MOV byte ptr [RBP + -0xe],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x40]
SHR RAX,0x18
MOV byte ptr [RBP + -0xd],AL
JMP 0x00126504
LAB_00126504:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x318]
MOV byte ptr [RBP + -0xc],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x318]
SHR RAX,0x8
MOV byte ptr [RBP + -0xb],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x318]
SHR RAX,0x10
MOV byte ptr [RBP + -0xa],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x318]
SHR RAX,0x18
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RCX + 0x38]
LEA RDX,[RBP + -0x10]
MOV R9,qword ptr [RBP + -0x20]
MOV ESI,0x1c
MOV ECX,0x8
MOV R8D,0x1
CALL RAX
CMP EAX,0x0
JZ 0x00126654
JMP 0x00126588
LAB_00126588:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x38]
MOV ECX,dword ptr [RAX + 0x90]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x108],ECX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x30d
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + 0x38]
ADD RSI,0x297
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x312],0x0
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x10c
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x38]
ADD RAX,0x97
CMP RAX,0x0
JZ 0x00126605
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x38]
ADD RAX,0x97
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0012662b
LAB_00126605:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x38]
MOV EAX,dword ptr [RAX + 0x90]
SUB EAX,0x7d0
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x15fe90]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x40],RAX
LAB_0012662b:
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,0x200
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001266e2
LAB_00126654:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x10
MOV ESI,0x1
CALL 0x00124c20
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x48],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
CMP byte ptr [RAX + 0x148],0x0
JNZ 0x001266ce
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x60]
MOV RDI,qword ptr [RBP + -0x20]
CALL RAX
CMP EAX,0x0
JZ 0x001266bc
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001266e2
LAB_001266bc:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x0012b290
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001266e2
LAB_001266ce:
JMP 0x001266d0
LAB_001266d0:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x14],0x64
LAB_001266e2:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00126703
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
LAB_00126703:
CALL 0x001134b0
|
int4 stmt_cursor_fetch(long param_1,int8 *param_2)
{
int iVar1;
long in_FS_OFFSET;
char *local_48;
int4 local_1c;
int1 local_18;
int1 local_17;
int1 local_16;
int1 local_15;
int1 local_14;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (*(uint *)(param_1 + 0x50) < 4) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_0015ff00,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
local_1c = 1;
}
else if (*(long *)(param_1 + 0xe0) == 0) {
if ((*(uint *)(param_1 + 0xf4) & 0x80) == 0) {
local_18 = (int1)*(int8 *)(param_1 + 0x40);
local_17 = (int1)((ulong)*(int8 *)(param_1 + 0x40) >> 8);
local_16 = (int1)((ulong)*(int8 *)(param_1 + 0x40) >> 0x10);
local_15 = (int1)((ulong)*(int8 *)(param_1 + 0x40) >> 0x18);
local_14 = (int1)*(int8 *)(param_1 + 0x318);
local_13 = (int1)((ulong)*(int8 *)(param_1 + 0x318) >> 8);
local_12 = (int1)((ulong)*(int8 *)(param_1 + 0x318) >> 0x10);
local_11 = (int1)((ulong)*(int8 *)(param_1 + 0x318) >> 0x18);
iVar1 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x10))
(*(int8 *)(param_1 + 0x38),0x1c,&local_18,8,1,param_1);
if (iVar1 != 0) {
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
if (*(long *)(param_1 + 0x38) == -0x97) {
local_48 = (&client_errors)[*(int *)(*(long *)(param_1 + 0x38) + 0x90) - 2000];
}
else {
local_48 = (char *)(*(long *)(param_1 + 0x38) + 0x97);
}
strncpy((char *)(param_1 + 0x10c),local_48,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
local_1c = 1;
goto LAB_001266e2;
}
ma_free_root(param_1 + 0x90,1);
*(int8 *)(param_1 + 0x80) = 0;
*(int8 *)(param_1 + 200) = 0;
if (*(char *)(*(long *)(*(long *)(param_1 + 0x38) + 0x480) + 0x148) == '\0') {
iVar1 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x60))(param_1);
if (iVar1 == 0) {
local_1c = stmt_buffered_fetch(param_1,param_2);
}
else {
local_1c = 1;
}
goto LAB_001266e2;
}
}
else {
*(uint *)(param_1 + 0xf4) = *(uint *)(param_1 + 0xf4) & 0xffffff7f;
}
*param_2 = 0;
local_1c = 100;
}
else {
local_1c = stmt_buffered_fetch(param_1,param_2);
}
LAB_001266e2:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_1c;
}
| |
25,908 | reset_events_transactions_history_long() | eloqsql/storage/perfschema/pfs_events_transactions.cc | void reset_events_transactions_history_long(void)
{
PFS_atomic::store_u32(&events_transactions_history_long_index.m_u32, 0);
events_transactions_history_long_full= false;
PFS_events_transactions *pfs= events_transactions_history_long_array;
PFS_events_transactions *pfs_last= pfs + events_transactions_history_long_size;
for ( ; pfs < pfs_last; pfs++)
pfs->m_class= NULL;
} | O3 | cpp | reset_events_transactions_history_long():
xorl %eax, %eax
xchgl %eax, 0x38d902(%rip) # 0x3d0a80
movb $0x0, 0x38d8bb(%rip) # 0x3d0a40
movq 0x38d7b4(%rip), %rax # 0x3d0940
testq %rax, %rax
jle 0x43288
pushq %rbp
movq %rsp, %rbp
movq 0x38d920(%rip), %rcx # 0x3d0ac0
leaq (%rax,%rax,4), %rax
shlq $0x6, %rax
addq %rcx, %rax
leaq 0x140(%rcx), %rdx
cmpq %rdx, %rax
cmovbeq %rdx, %rax
addq $-0x140, %rax # imm = 0xFEC0
xorl %esi, %esi
cmpq %rcx, %rax
setne %sil
subq %rcx, %rax
subq %rsi, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
mulq %rdx
shrq $0x8, %rdx
leaq (%rdx,%rsi), %rax
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x170, %rcx # imm = 0x170
leaq (%rdx,%rsi), %rax
addq $0x2, %rax
andq $-0x2, %rax
xorl %edx, %edx
movdqa 0x3da16(%rip), %xmm1 # 0x80c20
movdqa 0x3da3e(%rip), %xmm2 # 0x80c50
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x43261
movq $0x0, -0x140(%rcx)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x43277
movq $0x0, (%rcx)
addq $0x2, %rdx
addq $0x280, %rcx # imm = 0x280
cmpq %rdx, %rax
jne 0x4321a
popq %rbp
retq
| _Z38reset_events_transactions_history_longv:
xor eax, eax
xchg eax, cs:events_transactions_history_long_index
mov cs:events_transactions_history_long_full, 0
mov rax, cs:events_transactions_history_long_size
test rax, rax
jle locret_43288
push rbp
mov rbp, rsp
mov rcx, cs:events_transactions_history_long_array
lea rax, [rax+rax*4]
shl rax, 6
add rax, rcx
lea rdx, [rcx+140h]
cmp rax, rdx
cmovbe rax, rdx
add rax, 0FFFFFFFFFFFFFEC0h
xor esi, esi
cmp rax, rcx
setnz sil
sub rax, rcx
sub rax, rsi
mov rdx, 0CCCCCCCCCCCCCCCDh
mul rdx
shr rdx, 8
lea rax, [rdx+rsi]
movq xmm0, rax
pshufd xmm0, xmm0, 44h ; 'D'
add rcx, 170h
lea rax, [rdx+rsi]
add rax, 2
and rax, 0FFFFFFFFFFFFFFFEh
xor edx, edx
movdqa xmm1, cs:xmmword_80C20
movdqa xmm2, cs:xmmword_80C50
pxor xmm0, xmm2
pcmpeqd xmm3, xmm3
loc_4321A:
movq xmm4, rdx
pshufd xmm4, xmm4, 44h ; 'D'
por xmm4, xmm1
pxor xmm4, xmm2
movdqa xmm5, xmm4
pcmpgtd xmm5, xmm0
pcmpeqd xmm4, xmm0
pshufd xmm6, xmm4, 0F5h
pand xmm6, xmm5
pshufd xmm4, xmm5, 0F5h
por xmm4, xmm6
movd esi, xmm4
not esi
test sil, 1
jz short loc_43261
mov qword ptr [rcx-140h], 0
loc_43261:
pxor xmm4, xmm3
pextrw esi, xmm4, 4
test sil, 1
jz short loc_43277
mov qword ptr [rcx], 0
loc_43277:
add rdx, 2
add rcx, 280h
cmp rax, rdx
jnz short loc_4321A
pop rbp
locret_43288:
retn
| unsigned long long reset_events_transactions_history_long(void)
{
unsigned long long result; // rax
unsigned long long v1; // rax
unsigned long long v2; // rax
__m128i v3; // xmm0
_QWORD *v4; // rcx
unsigned long long v5; // rdx
__m128i si128; // xmm1
__m128i v7; // xmm2
__m128i v8; // xmm0
__m128i v9; // xmm4
__m128i v10; // xmm5
__m128i v11; // xmm4
_InterlockedExchange(&events_transactions_history_long_index, 0);
events_transactions_history_long_full = 0;
result = events_transactions_history_long_size;
if ( events_transactions_history_long_size > 0 )
{
v1 = events_transactions_history_long_array + 320 * events_transactions_history_long_size;
if ( v1 <= events_transactions_history_long_array + 320 )
v1 = events_transactions_history_long_array + 320;
v2 = (v1 - 320 - events_transactions_history_long_array - (v1 - 320 != events_transactions_history_long_array))
/ 0x140
+ (v1 - 320 != events_transactions_history_long_array);
v3 = _mm_shuffle_epi32((__m128i)v2, 68);
v4 = (_QWORD *)(events_transactions_history_long_array + 368);
result = (v2 + 2) & 0xFFFFFFFFFFFFFFFELL;
v5 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_80C20);
v7 = _mm_load_si128((const __m128i *)&xmmword_80C50);
v8 = _mm_xor_si128(v3, v7);
do
{
v9 = _mm_xor_si128(_mm_or_si128(_mm_shuffle_epi32((__m128i)v5, 68), si128), v7);
v10 = _mm_cmpgt_epi32(v9, v8);
v11 = _mm_or_si128(
_mm_shuffle_epi32(v10, 245),
_mm_and_si128(_mm_shuffle_epi32(_mm_cmpeq_epi32(v9, v8), 245), v10));
if ( (~_mm_cvtsi128_si32(v11) & 1) != 0 )
*(v4 - 40) = 0LL;
if ( (_mm_extract_epi16(_mm_xor_si128(v11, (__m128i)-1LL), 4) & 1) != 0 )
*v4 = 0LL;
v5 += 2LL;
v4 += 80;
}
while ( result != v5 );
}
return result;
}
| reset_events_transactions_history_long:
XOR EAX,EAX
XCHG dword ptr [0x004d0a80],EAX
MOV byte ptr [0x004d0a40],0x0
MOV RAX,qword ptr [0x004d0940]
TEST RAX,RAX
JLE 0x00143288
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [0x004d0ac0]
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x6
ADD RAX,RCX
LEA RDX,[RCX + 0x140]
CMP RAX,RDX
CMOVBE RAX,RDX
ADD RAX,-0x140
XOR ESI,ESI
CMP RAX,RCX
SETNZ SIL
SUB RAX,RCX
SUB RAX,RSI
MOV RDX,-0x3333333333333333
MUL RDX
SHR RDX,0x8
LEA RAX,[RDX + RSI*0x1]
MOVQ XMM0,RAX
PSHUFD XMM0,XMM0,0x44
ADD RCX,0x170
LEA RAX,[RDX + RSI*0x1]
ADD RAX,0x2
AND RAX,-0x2
XOR EDX,EDX
MOVDQA XMM1,xmmword ptr [0x00180c20]
MOVDQA XMM2,xmmword ptr [0x00180c50]
PXOR XMM0,XMM2
PCMPEQD XMM3,XMM3
LAB_0014321a:
MOVQ XMM4,RDX
PSHUFD XMM4,XMM4,0x44
POR XMM4,XMM1
PXOR XMM4,XMM2
MOVDQA XMM5,XMM4
PCMPGTD XMM5,XMM0
PCMPEQD XMM4,XMM0
PSHUFD XMM6,XMM4,0xf5
PAND XMM6,XMM5
PSHUFD XMM4,XMM5,0xf5
POR XMM4,XMM6
MOVD ESI,XMM4
NOT ESI
TEST SIL,0x1
JZ 0x00143261
MOV qword ptr [RCX + -0x140],0x0
LAB_00143261:
PXOR XMM4,XMM3
PEXTRW ESI,XMM4,0x4
TEST SIL,0x1
JZ 0x00143277
MOV qword ptr [RCX],0x0
LAB_00143277:
ADD RDX,0x2
ADD RCX,0x280
CMP RAX,RDX
JNZ 0x0014321a
POP RBP
LAB_00143288:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* reset_events_transactions_history_long() */
void reset_events_transactions_history_long(void)
{
long lVar1;
int1 auVar2 [16];
int1 auVar3 [16];
ulong uVar4;
int8 *puVar5;
ulong uVar6;
ulong uVar7;
int1 auVar8 [16];
int1 auVar9 [16];
auVar3 = _DAT_00180c50;
auVar2 = _DAT_00180c20;
LOCK();
events_transactions_history_long_index = 0;
UNLOCK();
events_transactions_history_long_full = 0;
if (0 < events_transactions_history_long_size) {
uVar4 = events_transactions_history_long_size * 0x140 + events_transactions_history_long_array;
if (uVar4 <= events_transactions_history_long_array + 0x140U) {
uVar4 = events_transactions_history_long_array + 0x140U;
}
uVar7 = (ulong)(uVar4 - 0x140 != events_transactions_history_long_array);
uVar4 = (((uVar4 - 0x140) - events_transactions_history_long_array) - uVar7) / 0x140;
lVar1 = uVar4 + uVar7;
auVar8._8_4_ = (int)lVar1;
auVar8._0_8_ = lVar1;
auVar8._12_4_ = (int)((ulong)lVar1 >> 0x20);
puVar5 = (int8 *)(events_transactions_history_long_array + 0x170);
uVar6 = 0;
auVar8 = auVar8 ^ _DAT_00180c50;
do {
auVar9._8_4_ = (int)uVar6;
auVar9._0_8_ = uVar6;
auVar9._12_4_ = (int)(uVar6 >> 0x20);
auVar9 = (auVar9 | auVar2) ^ auVar3;
if ((bool)(~(auVar9._4_4_ == auVar8._4_4_ && auVar8._0_4_ < auVar9._0_4_ ||
auVar8._4_4_ < auVar9._4_4_) & 1)) {
puVar5[-0x28] = 0;
}
if ((auVar9._12_4_ != auVar8._12_4_ || auVar9._8_4_ <= auVar8._8_4_) &&
auVar9._12_4_ <= auVar8._12_4_) {
*puVar5 = 0;
}
uVar6 = uVar6 + 2;
puVar5 = puVar5 + 0x50;
} while ((uVar4 + uVar7 + 2 & 0xfffffffffffffffe) != uVar6);
}
return;
}
| |
25,909 | google::protobuf::io::ArrayInputStream::BackUp(int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc | void ArrayInputStream::BackUp(int count) {
GOOGLE_CHECK_GT(last_returned_size_, 0)
<< "BackUp() can only be called after a successful Next().";
GOOGLE_CHECK_LE(count, last_returned_size_);
GOOGLE_CHECK_GE(count, 0);
position_ -= count;
last_returned_size_ = 0; // Don't let caller back up further.
} | O0 | cpp | google::protobuf::io::ArrayInputStream::BackUp(int):
subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movl %esi, 0x11c(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x1c(%rax), %eax
movb $0x0, 0xdf(%rsp)
cmpl $0x0, %eax
jle 0x1f0265
jmp 0x1f02d6
leaq 0x20bc64(%rip), %rdx # 0x3fbed0
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x3, %esi
movl $0x50, %ecx
callq 0x219560
movq 0x30(%rsp), %rdi
movb $0x1, 0xdf(%rsp)
leaq 0x20bcae(%rip), %rsi # 0x3fbf4a
callq 0x218e20
movq %rax, 0x38(%rsp)
jmp 0x1f02a8
movq 0x38(%rsp), %rdi
leaq 0x20bcc2(%rip), %rsi # 0x3fbf76
callq 0x218e20
movq %rax, 0x28(%rsp)
jmp 0x1f02c0
movq 0x28(%rsp), %rsi
leaq 0xcb(%rsp), %rdi
callq 0x218fd0
jmp 0x1f02d4
jmp 0x1f02d6
testb $0x1, 0xdf(%rsp)
jne 0x1f02e2
jmp 0x1f02ef
leaq 0xe0(%rsp), %rdi
callq 0x2195a0
movq 0x40(%rsp), %rcx
movl 0x11c(%rsp), %eax
movl 0x1c(%rcx), %ecx
movb $0x0, 0x8f(%rsp)
cmpl %ecx, %eax
jg 0x1f030c
jmp 0x1f0365
leaq 0x20bbbd(%rip), %rdx # 0x3fbed0
leaq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x3, %esi
movl $0x52, %ecx
callq 0x219560
movq 0x18(%rsp), %rdi
movb $0x1, 0x8f(%rsp)
leaq 0x20bc6a(%rip), %rsi # 0x3fbfad
callq 0x218e20
movq %rax, 0x20(%rsp)
jmp 0x1f034f
movq 0x20(%rsp), %rsi
leaq 0x8e(%rsp), %rdi
callq 0x218fd0
jmp 0x1f0363
jmp 0x1f0365
testb $0x1, 0x8f(%rsp)
jne 0x1f0371
jmp 0x1f037e
leaq 0x90(%rsp), %rdi
callq 0x2195a0
movl 0x11c(%rsp), %eax
movb $0x0, 0x4f(%rsp)
cmpl $0x0, %eax
jl 0x1f0391
jmp 0x1f03e1
leaq 0x20bb38(%rip), %rdx # 0x3fbed0
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x3, %esi
movl $0x53, %ecx
callq 0x219560
movq 0x8(%rsp), %rdi
movb $0x1, 0x4f(%rsp)
leaq 0x20bc1c(%rip), %rsi # 0x3fbfde
callq 0x218e20
movq %rax, 0x10(%rsp)
jmp 0x1f03ce
movq 0x10(%rsp), %rsi
leaq 0x4e(%rsp), %rdi
callq 0x218fd0
jmp 0x1f03df
jmp 0x1f03e1
testb $0x1, 0x4f(%rsp)
jne 0x1f03ea
jmp 0x1f03f4
leaq 0x50(%rsp), %rdi
callq 0x2195a0
movq 0x40(%rsp), %rax
movl 0x11c(%rsp), %edx
movl 0x18(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x18(%rax)
movl $0x0, 0x1c(%rax)
addq $0x128, %rsp # imm = 0x128
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
testb $0x1, 0xdf(%rsp)
jne 0x1f0437
jmp 0x1f0444
leaq 0xe0(%rsp), %rdi
callq 0x2195a0
jmp 0x1f049e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
testb $0x1, 0x8f(%rsp)
jne 0x1f0466
jmp 0x1f0473
leaq 0x90(%rsp), %rdi
callq 0x2195a0
jmp 0x1f049e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x1f0492
jmp 0x1f049c
leaq 0x50(%rsp), %rdi
callq 0x2195a0
jmp 0x1f049e
movq 0xd0(%rsp), %rdi
callq 0x21700
nopl (%rax,%rax)
| _ZN6google8protobuf2io16ArrayInputStream6BackUpEi:
sub rsp, 128h
mov [rsp+128h+var_8], rdi
mov [rsp+128h+var_C], esi
mov rax, [rsp+128h+var_8]
mov [rsp+128h+var_E8], rax
mov eax, [rax+1Ch]
mov [rsp+128h+var_49], 0
cmp eax, 0
jle short loc_1F0265
jmp short loc_1F02D6
loc_1F0265:
lea rdx, aWorkspaceLlm4b_66; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+128h+var_48]
mov [rsp+128h+var_F8], rdi
mov esi, 3
mov ecx, 50h ; 'P'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+128h+var_F8]
mov [rsp+128h+var_49], 1
lea rsi, aCheckFailedLas; "CHECK failed: (last_returned_size_) > ("...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+128h+var_F0], rax
jmp short $+2
loc_1F02A8:
mov rdi, [rsp+128h+var_F0]
lea rsi, aBackupCanOnlyB; "BackUp() can only be called after a suc"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+128h+var_100], rax
jmp short $+2
loc_1F02C0:
mov rsi, [rsp+128h+var_100]
lea rdi, [rsp+128h+var_5D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1F02D4:
jmp short $+2
loc_1F02D6:
test [rsp+128h+var_49], 1
jnz short loc_1F02E2
jmp short loc_1F02EF
loc_1F02E2:
lea rdi, [rsp+128h+var_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1F02EF:
mov rcx, [rsp+128h+var_E8]
mov eax, [rsp+128h+var_C]
mov ecx, [rcx+1Ch]
mov [rsp+128h+var_99], 0
cmp eax, ecx
jg short loc_1F030C
jmp short loc_1F0365
loc_1F030C:
lea rdx, aWorkspaceLlm4b_66; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+128h+var_98]
mov [rsp+128h+var_110], rdi
mov esi, 3
mov ecx, 52h ; 'R'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+128h+var_110]
mov [rsp+128h+var_99], 1
lea rsi, aCheckFailedCou_0; "CHECK failed: (count) <= (last_returned"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+128h+var_108], rax
jmp short $+2
loc_1F034F:
mov rsi, [rsp+128h+var_108]
lea rdi, [rsp+128h+var_9A]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1F0363:
jmp short $+2
loc_1F0365:
test [rsp+128h+var_99], 1
jnz short loc_1F0371
jmp short loc_1F037E
loc_1F0371:
lea rdi, [rsp+128h+var_98]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1F037E:
mov eax, [rsp+128h+var_C]
mov [rsp+128h+var_D9], 0
cmp eax, 0
jl short loc_1F0391
jmp short loc_1F03E1
loc_1F0391:
lea rdx, aWorkspaceLlm4b_66; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+128h+var_D8]
mov [rsp+128h+var_120], rdi
mov esi, 3
mov ecx, 53h ; 'S'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+128h+var_120]
mov [rsp+128h+var_D9], 1
lea rsi, aCheckFailedCou_1; "CHECK failed: (count) >= (0): "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+128h+var_118], rax
jmp short $+2
loc_1F03CE:
mov rsi, [rsp+128h+var_118]
lea rdi, [rsp+128h+var_DA]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1F03DF:
jmp short $+2
loc_1F03E1:
test [rsp+128h+var_D9], 1
jnz short loc_1F03EA
jmp short loc_1F03F4
loc_1F03EA:
lea rdi, [rsp+128h+var_D8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1F03F4:
mov rax, [rsp+128h+var_E8]
mov edx, [rsp+128h+var_C]
mov ecx, [rax+18h]
sub ecx, edx
mov [rax+18h], ecx
mov dword ptr [rax+1Ch], 0
add rsp, 128h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_C8], rcx
mov [rsp+arg_C4], eax
test [rsp+arg_D7], 1
jnz short loc_1F0437
jmp short loc_1F0444
loc_1F0437:
lea rdi, [rsp+arg_D8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1F0444:
jmp short loc_1F049E
mov rcx, rax
mov eax, edx
mov [rsp+arg_C8], rcx
mov [rsp+arg_C4], eax
test [rsp+arg_87], 1
jnz short loc_1F0466
jmp short loc_1F0473
loc_1F0466:
lea rdi, [rsp+arg_88]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1F0473:
jmp short loc_1F049E
mov rcx, rax
mov eax, edx
mov [rsp+arg_C8], rcx
mov [rsp+arg_C4], eax
test [rsp+arg_47], 1
jnz short loc_1F0492
jmp short loc_1F049C
loc_1F0492:
lea rdi, [rsp+arg_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1F049C:
jmp short $+2
loc_1F049E:
mov rdi, [rsp+arg_C8]
call __Unwind_Resume
| google::protobuf::io::ArrayInputStream * google::protobuf::io::ArrayInputStream::BackUp(
google::protobuf::io::ArrayInputStream *this,
int a2)
{
int v2; // eax
int v3; // ecx
google::protobuf::io::ArrayInputStream *result; // rax
long long v5; // [rsp+10h] [rbp-118h]
long long v6; // [rsp+20h] [rbp-108h]
long long v7; // [rsp+28h] [rbp-100h]
long long v8; // [rsp+38h] [rbp-F0h]
char v9; // [rsp+4Eh] [rbp-DAh] BYREF
char v10; // [rsp+4Fh] [rbp-D9h]
_BYTE v11[62]; // [rsp+50h] [rbp-D8h] BYREF
char v12; // [rsp+8Eh] [rbp-9Ah] BYREF
char v13; // [rsp+8Fh] [rbp-99h]
_BYTE v14[59]; // [rsp+90h] [rbp-98h] BYREF
_BYTE v15[20]; // [rsp+CBh] [rbp-5Dh] BYREF
char v16; // [rsp+DFh] [rbp-49h]
_BYTE v17[60]; // [rsp+E0h] [rbp-48h] BYREF
int v18; // [rsp+11Ch] [rbp-Ch]
google::protobuf::io::ArrayInputStream *v19; // [rsp+120h] [rbp-8h]
v19 = this;
v18 = a2;
v2 = *((_DWORD *)this + 7);
v16 = 0;
if ( v2 <= 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
v17,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc",
80LL);
v16 = 1;
v8 = google::protobuf::internal::LogMessage::operator<<(v17, "CHECK failed: (last_returned_size_) > (0): ");
v7 = google::protobuf::internal::LogMessage::operator<<(
v8,
"BackUp() can only be called after a successful Next().");
google::protobuf::internal::LogFinisher::operator=(v15, v7);
}
if ( (v16 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v17);
v3 = *((_DWORD *)this + 7);
v13 = 0;
if ( v18 > v3 )
{
google::protobuf::internal::LogMessage::LogMessage(
v14,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc",
82LL);
v13 = 1;
v6 = google::protobuf::internal::LogMessage::operator<<(v14, "CHECK failed: (count) <= (last_returned_size_): ");
google::protobuf::internal::LogFinisher::operator=(&v12, v6);
}
if ( (v13 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v14);
v10 = 0;
if ( v18 < 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
v11,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc",
83LL);
v10 = 1;
v5 = google::protobuf::internal::LogMessage::operator<<(v11, "CHECK failed: (count) >= (0): ");
google::protobuf::internal::LogFinisher::operator=(&v9, v5);
}
if ( (v10 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v11);
result = this;
*((_QWORD *)this + 3) = (unsigned int)(*((_DWORD *)this + 6) - v18);
return result;
}
| |||
25,910 | google::protobuf::io::ArrayInputStream::BackUp(int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc | void ArrayInputStream::BackUp(int count) {
GOOGLE_CHECK_GT(last_returned_size_, 0)
<< "BackUp() can only be called after a successful Next().";
GOOGLE_CHECK_LE(count, last_returned_size_);
GOOGLE_CHECK_GE(count, 0);
position_ -= count;
last_returned_size_ = 0; // Don't let caller back up further.
} | O3 | cpp | google::protobuf::io::ArrayInputStream::BackUp(int):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl 0x1c(%rdi), %eax
testl %eax, %eax
jg 0xfc2c2
leaq 0xf01dc(%rip), %rdx # 0x1ec44f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x50, %ecx
callq 0x1072ba
leaq 0xf0238(%rip), %rsi # 0x1ec4c9
movq %r14, %rdi
callq 0x106db8
leaq 0xf0255(%rip), %rsi # 0x1ec4f5
movq %rax, %rdi
callq 0x106db8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x106e92
leaq 0x8(%rsp), %rdi
callq 0x1072d8
movl 0x1c(%rbx), %eax
cmpl %ebp, %eax
jge 0xfc30a
leaq 0xf0182(%rip), %rdx # 0x1ec44f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x52, %ecx
callq 0x1072ba
leaq 0xf0241(%rip), %rsi # 0x1ec52c
movq %r14, %rdi
callq 0x106db8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x106e92
leaq 0x8(%rsp), %rdi
callq 0x1072d8
testl %ebp, %ebp
jns 0xfc352
leaq 0xf013a(%rip), %rdx # 0x1ec44f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x53, %ecx
callq 0x1072ba
leaq 0xf022a(%rip), %rsi # 0x1ec55d
movq %r14, %rdi
callq 0x106db8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x106e92
leaq 0x8(%rsp), %rdi
callq 0x1072d8
subl %ebp, 0x18(%rbx)
movl $0x0, 0x1c(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xfc36f
jmp 0xfc36f
jmp 0xfc36f
jmp 0xfc36f
jmp 0xfc36f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1072d8
movq %rbx, %rdi
callq 0x1f860
| _ZN6google8protobuf2io16ArrayInputStream6BackUpEi:
push rbp
push r14
push rbx
sub rsp, 40h
mov ebp, esi
mov rbx, rdi
mov eax, [rdi+1Ch]
test eax, eax
jg short loc_FC2C2
lea rdx, aWorkspaceLlm4b_51; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 50h ; 'P'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedLas; "CHECK failed: (last_returned_size_) > ("...
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rsi, aBackupCanOnlyB; "BackUp() can only be called after a suc"...
mov rdi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov eax, [rbx+1Ch]
loc_FC2C2:
cmp eax, ebp
jge short loc_FC30A
lea rdx, aWorkspaceLlm4b_51; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 52h ; 'R'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedCou_0; "CHECK failed: (count) <= (last_returned"...
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_FC30A:
test ebp, ebp
jns short loc_FC352
lea rdx, aWorkspaceLlm4b_51; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 53h ; 'S'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedCou_1; "CHECK failed: (count) >= (0): "
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_FC352:
sub [rbx+18h], ebp
mov dword ptr [rbx+1Ch], 0
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
jmp short loc_FC36F
jmp short loc_FC36F
jmp short loc_FC36F
jmp short loc_FC36F
jmp short $+2
loc_FC36F:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
| void google::protobuf::io::ArrayInputStream::BackUp(google::protobuf::io::ArrayInputStream *this, int a2)
{
int v2; // eax
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v6; // rax
char v7; // [rsp+7h] [rbp-51h] BYREF
_BYTE v8[80]; // [rsp+8h] [rbp-50h] BYREF
v2 = *((_DWORD *)this + 7);
if ( v2 <= 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
v8,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc",
80LL);
v3 = google::protobuf::internal::LogMessage::operator<<(v8, "CHECK failed: (last_returned_size_) > (0): ");
v4 = google::protobuf::internal::LogMessage::operator<<(
v3,
"BackUp() can only be called after a successful Next().");
google::protobuf::internal::LogFinisher::operator=(&v7, v4);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v8);
v2 = *((_DWORD *)this + 7);
}
if ( v2 < a2 )
{
google::protobuf::internal::LogMessage::LogMessage(
v8,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc",
82LL);
v5 = google::protobuf::internal::LogMessage::operator<<(v8, "CHECK failed: (count) <= (last_returned_size_): ");
google::protobuf::internal::LogFinisher::operator=(&v7, v5);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v8);
}
if ( a2 < 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
v8,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc",
83LL);
v6 = google::protobuf::internal::LogMessage::operator<<(v8, "CHECK failed: (count) >= (0): ");
google::protobuf::internal::LogFinisher::operator=(&v7, v6);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v8);
}
*((_DWORD *)this + 6) -= a2;
*((_DWORD *)this + 7) = 0;
}
| BackUp:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV EBP,ESI
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x1c]
TEST EAX,EAX
JG 0x001fc2c2
LEA RDX,[0x2ec44f]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x50
CALL 0x002072ba
LAB_001fc28a:
LEA RSI,[0x2ec4c9]
MOV RDI,R14
CALL 0x00206db8
LEA RSI,[0x2ec4f5]
MOV RDI,RAX
CALL 0x00206db8
LAB_001fc2a8:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x00206e92
LAB_001fc2b5:
LEA RDI,[RSP + 0x8]
CALL 0x002072d8
MOV EAX,dword ptr [RBX + 0x1c]
LAB_001fc2c2:
CMP EAX,EBP
JGE 0x001fc30a
LEA RDX,[0x2ec44f]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x52
CALL 0x002072ba
LAB_001fc2e4:
LEA RSI,[0x2ec52c]
MOV RDI,R14
CALL 0x00206db8
LAB_001fc2f3:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x00206e92
LAB_001fc300:
LEA RDI,[RSP + 0x8]
CALL 0x002072d8
LAB_001fc30a:
TEST EBP,EBP
JNS 0x001fc352
LEA RDX,[0x2ec44f]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x53
CALL 0x002072ba
LAB_001fc32c:
LEA RSI,[0x2ec55d]
MOV RDI,R14
CALL 0x00206db8
LAB_001fc33b:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x00206e92
LAB_001fc348:
LEA RDI,[RSP + 0x8]
CALL 0x002072d8
LAB_001fc352:
SUB dword ptr [RBX + 0x18],EBP
MOV dword ptr [RBX + 0x1c],0x0
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
/* google::protobuf::io::ArrayInputStream::BackUp(int) */
void __thiscall google::protobuf::io::ArrayInputStream::BackUp(ArrayInputStream *this,int param_1)
{
int iVar1;
LogMessage *pLVar2;
LogFinisher local_51;
LogMessage local_50 [56];
iVar1 = *(int *)(this + 0x1c);
if (iVar1 < 1) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc"
,0x50);
/* try { // try from 001fc28a to 001fc2a7 has its CatchHandler @ 001fc36f */
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<
(local_50,"CHECK failed: (last_returned_size_) > (0): ");
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<
(pLVar2,"BackUp() can only be called after a successful Next().");
/* try { // try from 001fc2a8 to 001fc2b4 has its CatchHandler @ 001fc369 */
internal::LogFinisher::operator=(&local_51,pLVar2);
internal::LogMessage::~LogMessage(local_50);
iVar1 = *(int *)(this + 0x1c);
}
if (iVar1 < param_1) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc"
,0x52);
/* try { // try from 001fc2e4 to 001fc2f2 has its CatchHandler @ 001fc36d */
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<
(local_50,"CHECK failed: (count) <= (last_returned_size_): ");
/* try { // try from 001fc2f3 to 001fc2ff has its CatchHandler @ 001fc36b */
internal::LogFinisher::operator=(&local_51,pLVar2);
internal::LogMessage::~LogMessage(local_50);
}
if (param_1 < 0) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc"
,0x53);
/* try { // try from 001fc32c to 001fc33a has its CatchHandler @ 001fc367 */
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<(local_50,"CHECK failed: (count) >= (0): ");
/* try { // try from 001fc33b to 001fc347 has its CatchHandler @ 001fc365 */
internal::LogFinisher::operator=(&local_51,pLVar2);
internal::LogMessage::~LogMessage(local_50);
}
*(int *)(this + 0x18) = *(int *)(this + 0x18) - param_1;
*(int4 *)(this + 0x1c) = 0;
return;
}
| |
25,911 | mz_zip_reader_extract_file_to_heap | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip,
const char *pFilename, size_t *pSize,
mz_uint flags) {
mz_uint32 file_index;
if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags,
&file_index)) {
if (pSize)
*pSize = 0;
return MZ_FALSE;
}
return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
} | O0 | c | mz_zip_reader_extract_file_to_heap:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %ecx
xorl %eax, %eax
movl %eax, %edx
movq %rsp, %r8
callq 0x100310
cmpl $0x0, %eax
jne 0x101d15
cmpq $0x0, 0x8(%rsp)
je 0x101d0a
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x20(%rsp)
jmp 0x101d30
movq 0x18(%rsp), %rdi
movl (%rsp), %esi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
callq 0x101a40
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| mz_zip_reader_extract_file_to_heap:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_20], rdx
mov [rsp+28h+var_24], ecx
mov rdi, [rsp+28h+var_10]
mov rsi, [rsp+28h+var_18]
mov ecx, [rsp+28h+var_24]
xor eax, eax
mov edx, eax
mov r8, rsp
call mz_zip_reader_locate_file_v2
cmp eax, 0
jnz short loc_101D15
cmp [rsp+28h+var_20], 0
jz short loc_101D0A
mov rax, [rsp+28h+var_20]
mov qword ptr [rax], 0
loc_101D0A:
mov [rsp+28h+var_8], 0
jmp short loc_101D30
loc_101D15:
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_28]
mov rdx, [rsp+28h+var_20]
mov ecx, [rsp+28h+var_24]
call mz_zip_reader_extract_to_heap
mov [rsp+28h+var_8], rax
loc_101D30:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
| _BYTE * mz_zip_reader_extract_file_to_heap(long long a1, long long a2, unsigned long long *a3, int a4)
{
unsigned int v5; // [rsp+0h] [rbp-28h] BYREF
int v6; // [rsp+4h] [rbp-24h]
unsigned long long *v7; // [rsp+8h] [rbp-20h]
long long v8; // [rsp+10h] [rbp-18h]
long long v9; // [rsp+18h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
v6 = a4;
if ( (unsigned int)mz_zip_reader_locate_file_v2(a1, a2, 0LL, a4, &v5) )
return mz_zip_reader_extract_to_heap(v9, v5, v7, v6);
if ( v7 )
*v7 = 0LL;
return 0LL;
}
| |||
25,912 | mz_zip_reader_extract_file_to_heap | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip,
const char *pFilename, size_t *pSize,
mz_uint flags) {
mz_uint32 file_index;
if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags,
&file_index)) {
if (pSize)
*pSize = 0;
return MZ_FALSE;
}
return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
} | O1 | c | mz_zip_reader_extract_file_to_heap:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r8
xorl %edx, %edx
callq 0x84330
testl %eax, %eax
je 0x84df0
movl 0xc(%rsp), %esi
movq %r14, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x84ccf
jmp 0x84dfe
testq %rbx, %rbx
je 0x84dfc
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| mz_zip_reader_extract_file_to_heap:
push rbp
push r14
push rbx
sub rsp, 10h
mov ebp, ecx
mov rbx, rdx
mov r14, rdi
lea r8, [rsp+28h+var_1C]
xor edx, edx
call mz_zip_reader_locate_file_v2
test eax, eax
jz short loc_84DF0
mov esi, [rsp+28h+var_1C]
mov rdi, r14
mov rdx, rbx
mov ecx, ebp
call mz_zip_reader_extract_to_heap
jmp short loc_84DFE
loc_84DF0:
test rbx, rbx
jz short loc_84DFC
mov qword ptr [rbx], 0
loc_84DFC:
xor eax, eax
loc_84DFE:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| _BYTE * mz_zip_reader_extract_file_to_heap(long long a1, unsigned __int8 *a2, unsigned long long *a3, __int16 a4)
{
unsigned int v7[7]; // [rsp+Ch] [rbp-1Ch] BYREF
if ( (unsigned int)mz_zip_reader_locate_file_v2(a1, a2, 0LL, a4, v7) )
return mz_zip_reader_extract_to_heap(a1, v7[0], a3, a4);
if ( a3 )
*a3 = 0LL;
return 0LL;
}
| |||
25,913 | mz_zip_reader_extract_file_to_heap | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip,
const char *pFilename, size_t *pSize,
mz_uint flags) {
mz_uint32 file_index;
if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags,
&file_index)) {
if (pSize)
*pSize = 0;
return MZ_FALSE;
}
return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
} | O2 | c | mz_zip_reader_extract_file_to_heap:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r8
xorl %edx, %edx
callq 0x5ea94
testl %eax, %eax
je 0x5f4ba
movl 0xc(%rsp), %esi
movq %r14, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x5f39c
jmp 0x5f4c5
testq %rbx, %rbx
je 0x5f4c3
andq $0x0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| mz_zip_reader_extract_file_to_heap:
push rbp
push r14
push rbx
sub rsp, 10h
mov ebp, ecx
mov rbx, rdx
mov r14, rdi
lea r8, [rsp+28h+var_1C]
xor edx, edx
call mz_zip_reader_locate_file_v2
test eax, eax
jz short loc_5F4BA
mov esi, [rsp+28h+var_1C]
mov rdi, r14
mov rdx, rbx
mov ecx, ebp
call mz_zip_reader_extract_to_heap
jmp short loc_5F4C5
loc_5F4BA:
test rbx, rbx
jz short loc_5F4C3
and qword ptr [rbx], 0
loc_5F4C3:
xor eax, eax
loc_5F4C5:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| _BYTE * mz_zip_reader_extract_file_to_heap(long long a1, long long a2, unsigned long long *a3, __int16 a4)
{
unsigned int v7[7]; // [rsp+Ch] [rbp-1Ch] BYREF
if ( (unsigned int)mz_zip_reader_locate_file_v2(a1, a2, 0LL, a4, v7) )
return mz_zip_reader_extract_to_heap(a1, v7[0], a3, a4);
if ( a3 )
*a3 = 0LL;
return 0LL;
}
| mz_zip_reader_extract_file_to_heap:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EBP,ECX
MOV RBX,RDX
MOV R14,RDI
LEA R8,[RSP + 0xc]
XOR EDX,EDX
CALL 0x0015ea94
TEST EAX,EAX
JZ 0x0015f4ba
MOV ESI,dword ptr [RSP + 0xc]
MOV RDI,R14
MOV RDX,RBX
MOV ECX,EBP
CALL 0x0015f39c
JMP 0x0015f4c5
LAB_0015f4ba:
TEST RBX,RBX
JZ 0x0015f4c3
AND qword ptr [RBX],0x0
LAB_0015f4c3:
XOR EAX,EAX
LAB_0015f4c5:
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
int8
mz_zip_reader_extract_file_to_heap
(int8 param_1,int8 param_2,int8 *param_3,ulong param_4)
{
int iVar1;
int8 uVar2;
int4 local_1c;
iVar1 = mz_zip_reader_locate_file_v2(param_1,param_2,0,param_4,&local_1c);
if (iVar1 == 0) {
if (param_3 != (int8 *)0x0) {
*param_3 = 0;
}
uVar2 = 0;
}
else {
uVar2 = mz_zip_reader_extract_to_heap(param_1,local_1c,param_3,param_4 & 0xffffffff);
}
return uVar2;
}
| |
25,914 | mz_zip_reader_extract_file_to_heap | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip,
const char *pFilename, size_t *pSize,
mz_uint flags) {
mz_uint32 file_index;
if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags,
&file_index)) {
if (pSize)
*pSize = 0;
return MZ_FALSE;
}
return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
} | O3 | c | mz_zip_reader_extract_file_to_heap:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r8
xorl %edx, %edx
callq 0x833b0
testl %eax, %eax
je 0x83e0c
movl 0xc(%rsp), %esi
movq %r14, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x83cf0
jmp 0x83e1a
testq %rbx, %rbx
je 0x83e18
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| mz_zip_reader_extract_file_to_heap:
push rbp
push r14
push rbx
sub rsp, 10h
mov ebp, ecx
mov rbx, rdx
mov r14, rdi
lea r8, [rsp+28h+var_1C]
xor edx, edx
call mz_zip_reader_locate_file_v2
test eax, eax
jz short loc_83E0C
mov esi, [rsp+28h+var_1C]
mov rdi, r14
mov rdx, rbx
mov ecx, ebp
call mz_zip_reader_extract_to_heap
jmp short loc_83E1A
loc_83E0C:
test rbx, rbx
jz short loc_83E18
mov qword ptr [rbx], 0
loc_83E18:
xor eax, eax
loc_83E1A:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| _BYTE * mz_zip_reader_extract_file_to_heap(long long a1, _BYTE *a2, unsigned long long *a3, __int16 a4)
{
unsigned int v7[7]; // [rsp+Ch] [rbp-1Ch] BYREF
if ( (unsigned int)mz_zip_reader_locate_file_v2(a1, a2, 0LL, a4, v7) )
return mz_zip_reader_extract_to_heap(a1, v7[0], a3, a4);
if ( a3 )
*a3 = 0LL;
return 0LL;
}
| |||
25,915 | my_strxfrm_desc_and_reverse | eloqsql/strings/ctype-simple.c | void
my_strxfrm_desc_and_reverse(uchar *str, uchar *strend,
uint flags, uint level)
{
if (flags & (MY_STRXFRM_DESC_LEVEL1 << level))
{
if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str <= strend;)
{
uchar tmp= *str;
*str++= ~*strend;
*strend--= ~tmp;
}
}
else
{
for (; str < strend; str++)
*str= ~*str;
}
}
else if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str < strend;)
{
uchar tmp= *str;
*str++= *strend;
*strend--= tmp;
}
}
} | O0 | c | my_strxfrm_desc_and_reverse:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x100, %edx # imm = 0x100
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x7ac5c
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x10000, %edx # imm = 0x10000
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x7ac2c
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x7ac2a
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
xorl $-0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movzbl -0x19(%rbp), %eax
xorl $-0x1, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x7abde
jmp 0x7ac5a
jmp 0x7ac2e
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x7ac58
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
xorl $-0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7ac2e
jmp 0x7ac5a
jmp 0x7acc2
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x10000, %edx # imm = 0x10000
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x7acc0
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x7acbe
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movb -0x1a(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x7ac7e
jmp 0x7acc0
jmp 0x7acc2
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strxfrm_desc_and_reverse:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov eax, [rbp+var_14]
mov ecx, [rbp+var_18]
mov edx, 100h
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz loc_7AC5C
mov eax, [rbp+var_14]
mov ecx, [rbp+var_18]
mov edx, 10000h
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz short loc_7AC2C
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rax
loc_7ABDE:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
ja short loc_7AC2A
mov rax, [rbp+var_8]
mov al, [rax]
mov [rbp+var_19], al
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
xor eax, 0FFFFFFFFh
mov cl, al
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
movzx eax, [rbp+var_19]
xor eax, 0FFFFFFFFh
mov cl, al
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_7ABDE
loc_7AC2A:
jmp short loc_7AC5A
loc_7AC2C:
jmp short $+2
loc_7AC2E:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_7AC58
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax]
xor eax, 0FFFFFFFFh
mov cl, al
mov rax, [rbp+var_8]
mov [rax], cl
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_7AC2E
loc_7AC58:
jmp short $+2
loc_7AC5A:
jmp short loc_7ACC2
loc_7AC5C:
mov eax, [rbp+var_14]
mov ecx, [rbp+var_18]
mov edx, 10000h
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz short loc_7ACC0
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rax
loc_7AC7E:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_7ACBE
mov rax, [rbp+var_8]
mov al, [rax]
mov [rbp+var_1A], al
mov rax, [rbp+var_10]
mov cl, [rax]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov cl, [rbp+var_1A]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_7AC7E
loc_7ACBE:
jmp short $+2
loc_7ACC0:
jmp short $+2
loc_7ACC2:
pop rbp
retn
| _BYTE * my_strxfrm_desc_and_reverse(_BYTE *a1, unsigned long long a2, unsigned int a3, char a4)
{
_BYTE *result; // rax
_BYTE *v5; // rax
_BYTE *v6; // rax
_BYTE *v7; // rax
_BYTE *v8; // rax
char v9; // [rsp+0h] [rbp-1Ah]
char v10; // [rsp+1h] [rbp-19h]
_BYTE *i; // [rsp+Ah] [rbp-10h]
_BYTE *j; // [rsp+Ah] [rbp-10h]
if ( ((256 << a4) & a3) != 0 )
{
if ( ((0x10000 << a4) & a3) != 0 )
{
for ( i = (_BYTE *)(a2 - 1); ; --i )
{
result = a1;
if ( a1 > i )
break;
v10 = *a1;
v5 = a1++;
*v5 = ~*i;
v6 = i;
*v6 = ~v10;
}
}
else
{
while ( 1 )
{
result = a1;
if ( (unsigned long long)a1 >= a2 )
break;
*a1 = ~*a1;
++a1;
}
}
}
else
{
result = (_BYTE *)((0x10000 << a4) & a3);
if ( (_DWORD)result )
{
for ( j = (_BYTE *)(a2 - 1); ; --j )
{
result = a1;
if ( a1 >= j )
break;
v9 = *a1;
v7 = a1++;
*v7 = *j;
v8 = j;
*v8 = v9;
}
}
}
return result;
}
| my_strxfrm_desc_and_reverse:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOV EDX,0x100
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x0017ac5c
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOV EDX,0x10000
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x0017ac2c
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_0017abde:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JA 0x0017ac2a
MOV RAX,qword ptr [RBP + -0x8]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
XOR EAX,0xffffffff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOVZX EAX,byte ptr [RBP + -0x19]
XOR EAX,0xffffffff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x0017abde
LAB_0017ac2a:
JMP 0x0017ac5a
LAB_0017ac2c:
JMP 0x0017ac2e
LAB_0017ac2e:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x0017ac58
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX]
XOR EAX,0xffffffff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017ac2e
LAB_0017ac58:
JMP 0x0017ac5a
LAB_0017ac5a:
JMP 0x0017acc2
LAB_0017ac5c:
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOV EDX,0x10000
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x0017acc0
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_0017ac7e:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x0017acbe
MOV RAX,qword ptr [RBP + -0x8]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x1a],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV CL,byte ptr [RBP + -0x1a]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x0017ac7e
LAB_0017acbe:
JMP 0x0017acc0
LAB_0017acc0:
JMP 0x0017acc2
LAB_0017acc2:
POP RBP
RET
|
void my_strxfrm_desc_and_reverse(byte *param_1,byte *param_2,uint param_3,byte param_4)
{
byte bVar1;
byte *local_18;
byte *local_10;
if ((param_3 & 0x100 << (param_4 & 0x1f)) == 0) {
if ((param_3 & 0x10000 << (param_4 & 0x1f)) != 0) {
local_18 = param_2 + -1;
local_10 = param_1;
while (local_10 < local_18) {
bVar1 = *local_10;
*local_10 = *local_18;
*local_18 = bVar1;
local_18 = local_18 + -1;
local_10 = local_10 + 1;
}
}
}
else {
local_10 = param_1;
if ((param_3 & 0x10000 << (param_4 & 0x1f)) == 0) {
for (; local_10 < param_2; local_10 = local_10 + 1) {
*local_10 = *local_10 ^ 0xff;
}
}
else {
local_18 = param_2 + -1;
local_10 = param_1;
while (local_10 <= local_18) {
bVar1 = *local_10;
*local_10 = *local_18 ^ 0xff;
*local_18 = bVar1 ^ 0xff;
local_18 = local_18 + -1;
local_10 = local_10 + 1;
}
}
}
return;
}
| |
25,916 | Catch::BinaryExpr<AST::ASTTree::DSFIterator&, AST::ASTTree::DSFIterator const&>::streamReconstructedExpression(std::ostream&) const | 11AgReS1SoR11[P]Graph/build_O3/_deps/catch2-src/src/catch2/../catch2/internal/catch_decomposer.hpp | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | O3 | cpp | Catch::BinaryExpr<AST::ASTTree::DSFIterator&, AST::ASTTree::DSFIterator const&>::streamReconstructedExpression(std::ostream&) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rax
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movl $0x7d3f7b, %esi # imm = 0x7D3F7B
movl %esi, (%r14)
movl $0x3, %r8d
movq %r8, -0x8(%r14)
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movl %esi, (%r15)
movq %r8, -0x8(%r15)
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %rax, %rdi
callq 0x2d750
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x199b5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x104f0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x199cc
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x104f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x199ef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x104f0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x19a06
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x104f0
movq %rbx, %rdi
callq 0x10930
| _ZNK5Catch10BinaryExprIRKN3AST7ASTTree11DSFIteratorES5_E29streamReconstructedExpressionERSo:
push r15
push r14
push rbx
sub rsp, 40h
mov rax, rsi
lea r14, [rsp+58h+var_28]
mov [r14-10h], r14
mov esi, 7D3F7Bh
mov [r14], esi
mov r8d, 3
mov [r14-8], r8
mov rdx, [rdi+18h]
mov rcx, [rdi+20h]
lea r15, [rsp+58h+var_48]
mov [r15-10h], r15
mov [r15], esi
mov [r15-8], r8
lea rsi, [rsp+58h+var_38]
mov r8, rsp
mov rdi, rax
call _ZN5Catch29formatReconstructedExpressionERSoRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_9StringRefES8_; Catch::formatReconstructedExpression(std::ostream &,std::string const&,Catch::StringRef,std::string const&)
mov rdi, [rsp+58h+var_58]; void *
cmp rdi, r15
jz short loc_199B5
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_199B5:
mov rdi, [rsp+58h+var_38]; void *
cmp rdi, r14
jz short loc_199CC
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_199CC:
add rsp, 40h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r15
jz short loc_199EF
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_199EF:
mov rdi, [rsp+arg_18]; void *
cmp rdi, r14
jz short loc_19A06
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_19A06:
mov rdi, rbx
call __Unwind_Resume
| void Catch::BinaryExpr<AST::ASTTree::DSFIterator const&,AST::ASTTree::DSFIterator const&>::streamReconstructedExpression(
long long a1,
long long a2)
{
long long v2; // rdx
long long v3; // rcx
void *v4[2]; // [rsp+0h] [rbp-58h] BYREF
_QWORD v5[2]; // [rsp+10h] [rbp-48h] BYREF
void *v6[2]; // [rsp+20h] [rbp-38h] BYREF
_QWORD v7[5]; // [rsp+30h] [rbp-28h] BYREF
v6[0] = v7;
LODWORD(v7[0]) = 8208251;
v6[1] = &dword_0 + 3;
v2 = *(_QWORD *)(a1 + 24);
v3 = *(_QWORD *)(a1 + 32);
v4[0] = v5;
LODWORD(v5[0]) = 8208251;
v4[1] = &dword_0 + 3;
Catch::formatReconstructedExpression(a2, v6, v2, v3, v4);
if ( v4[0] != v5 )
operator delete(v4[0], v5[0] + 1LL);
if ( v6[0] != v7 )
operator delete(v6[0], v7[0] + 1LL);
}
| streamReconstructedExpression:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RAX,RSI
LEA R14,[RSP + 0x30]
MOV qword ptr [R14 + -0x10],R14
MOV ESI,0x7d3f7b
MOV dword ptr [R14],ESI
MOV R8D,0x3
MOV qword ptr [R14 + -0x8],R8
MOV RDX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RDI + 0x20]
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV dword ptr [R15],ESI
MOV qword ptr [R15 + -0x8],R8
LAB_0011998f:
LEA RSI,[RSP + 0x20]
MOV R8,RSP
MOV RDI,RAX
CALL 0x0012d750
LAB_0011999f:
MOV RDI,qword ptr [RSP]
CMP RDI,R15
JZ 0x001199b5
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001104f0
LAB_001199b5:
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R14
JZ 0x001199cc
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001104f0
LAB_001199cc:
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
|
/* Catch::BinaryExpr<AST::ASTTree::DSFIterator const&, AST::ASTTree::DSFIterator
const&>::streamReconstructedExpression(std::ostream&) const */
void __thiscall
Catch::BinaryExpr<AST::ASTTree::DSFIterator_const&,AST::ASTTree::DSFIterator_const&>::
streamReconstructedExpression
(BinaryExpr<AST::ASTTree::DSFIterator_const&,AST::ASTTree::DSFIterator_const&> *this,
ostream *param_1)
{
int4 *local_58;
int8 local_50;
int4 local_48;
int4 uStack_44;
int4 *local_38;
int8 local_30;
int4 local_28;
int4 uStack_24;
local_28 = 0x7d3f7b;
local_30 = 3;
local_48 = 0x7d3f7b;
local_50 = 3;
/* try { // try from 0011998f to 0011999e has its CatchHandler @ 001199d6 */
local_58 = &local_48;
local_38 = &local_28;
formatReconstructedExpression
((Catch *)param_1,&local_38,*(int8 *)(this + 0x18),*(int8 *)(this + 0x20),
&local_58);
if (local_58 != &local_48) {
operator_delete(local_58,CONCAT44(uStack_44,local_48) + 1);
}
if (local_38 != &local_28) {
operator_delete(local_38,CONCAT44(uStack_24,local_28) + 1);
}
return;
}
| |
25,917 | auth_old_password | eloqsql/libmariadb/plugins/auth/old_password.c | static int auth_old_password(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
{
uchar *pkt;
int pkt_len;
if (((MCPVIO_EXT *)vio)->mysql_change_user)
{
/*
in mysql_change_user() the client sends the first packet.
we use the old scramble.
*/
pkt= (uchar*)mysql->scramble_buff;
}
else
{
/* read the scramble */
if ((pkt_len= vio->read_packet(vio, &pkt)) < 0)
return CR_ERROR;
if (pkt_len != SCRAMBLE_LENGTH_323 + 1 &&
pkt_len != SCRAMBLE_LENGTH + 1)
return CR_SERVER_HANDSHAKE_ERR;
/* save it in MYSQL */
memmove(mysql->scramble_buff, pkt, pkt_len - 1);
mysql->scramble_buff[pkt_len - 1] = 0;
}
if (mysql && mysql->passwd[0])
{
char scrambled[SCRAMBLE_LENGTH_323 + 1];
ma_scramble_323(scrambled, (char*)pkt, mysql->passwd);
if (vio->write_packet(vio, (uchar*)scrambled, SCRAMBLE_LENGTH_323 + 1))
return CR_ERROR;
}
else
if (vio->write_packet(vio, 0, 0)) /* no password */
return CR_ERROR;
return CR_OK;
} | O0 | c | auth_old_password:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0x3df07
movq -0x28(%rbp), %rax
addq $0x48e, %rax # imm = 0x48E
movq %rax, -0x30(%rbp)
jmp 0x3df76
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x3df2c
movl $0x0, -0x18(%rbp)
jmp 0x3dffa
cmpl $0x9, -0x34(%rbp)
je 0x3df44
cmpl $0x15, -0x34(%rbp)
je 0x3df44
movl $0x7dc, -0x18(%rbp) # imm = 0x7DC
jmp 0x3dffa
movq -0x28(%rbp), %rdi
addq $0x48e, %rdi # imm = 0x48E
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x126c0
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, 0x48e(%rax,%rcx)
cmpq $0x0, -0x28(%rbp)
je 0x3dfcf
movq -0x28(%rbp), %rax
movq 0x2c0(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3dfcf
leaq -0x11(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x2c0(%rax), %rdx
callq 0x454c0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
leaq -0x11(%rbp), %rsi
movl $0x9, %edx
callq *%rax
cmpl $0x0, %eax
je 0x3dfcd
movl $0x0, -0x18(%rbp)
jmp 0x3dffa
jmp 0x3dff3
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
callq *%rax
cmpl $0x0, %eax
je 0x3dff1
movl $0x0, -0x18(%rbp)
jmp 0x3dffa
jmp 0x3dff3
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3e01b
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x12490
| auth_old_password:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov rax, [rbp+var_20]
cmp byte ptr [rax+48h], 0
jz short loc_3DF07
mov rax, [rbp+var_28]
add rax, 48Eh
mov [rbp+var_30], rax
jmp short loc_3DF76
loc_3DF07:
mov rax, [rbp+var_20]
mov rax, [rax]
mov rdi, [rbp+var_20]
lea rsi, [rbp+var_30]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jge short loc_3DF2C
mov [rbp+var_18], 0
jmp loc_3DFFA
loc_3DF2C:
cmp [rbp+var_34], 9
jz short loc_3DF44
cmp [rbp+var_34], 15h
jz short loc_3DF44
mov [rbp+var_18], 7DCh
jmp loc_3DFFA
loc_3DF44:
mov rdi, [rbp+var_28]
add rdi, 48Eh
mov rsi, [rbp+var_30]
mov eax, [rbp+var_34]
sub eax, 1
movsxd rdx, eax
call _memmove
mov rax, [rbp+var_28]
mov ecx, [rbp+var_34]
sub ecx, 1
movsxd rcx, ecx
mov byte ptr [rax+rcx+48Eh], 0
loc_3DF76:
cmp [rbp+var_28], 0
jz short loc_3DFCF
mov rax, [rbp+var_28]
mov rax, [rax+2C0h]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_3DFCF
lea rdi, [rbp+var_11]
mov rsi, [rbp+var_30]
mov rax, [rbp+var_28]
mov rdx, [rax+2C0h]
call ma_scramble_323
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rdi, [rbp+var_20]
lea rsi, [rbp+var_11]
mov edx, 9
call rax
cmp eax, 0
jz short loc_3DFCD
mov [rbp+var_18], 0
jmp short loc_3DFFA
loc_3DFCD:
jmp short loc_3DFF3
loc_3DFCF:
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rdi, [rbp+var_20]
xor ecx, ecx
mov esi, ecx
xor edx, edx
call rax
cmp eax, 0
jz short loc_3DFF1
mov [rbp+var_18], 0
jmp short loc_3DFFA
loc_3DFF1:
jmp short $+2
loc_3DFF3:
mov [rbp+var_18], 0FFFFFFFFh
loc_3DFFA:
mov eax, [rbp+var_18]
mov [rbp+var_38], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3E01B
mov eax, [rbp+var_38]
add rsp, 40h
pop rbp
retn
loc_3E01B:
call ___stack_chk_fail
| long long auth_old_password(long long a1, long long a2)
{
int v3; // [rsp+Ch] [rbp-34h]
long long v4; // [rsp+10h] [rbp-30h] BYREF
long long v5; // [rsp+18h] [rbp-28h]
long long v6; // [rsp+20h] [rbp-20h]
_BYTE v8[9]; // [rsp+2Fh] [rbp-11h] BYREF
unsigned long long v9; // [rsp+38h] [rbp-8h]
v9 = __readfsqword(0x28u);
v6 = a1;
v5 = a2;
if ( *(_BYTE *)(a1 + 72) )
{
v4 = v5 + 1166;
LABEL_9:
if ( v5 && **(_BYTE **)(v5 + 704) )
{
ma_scramble_323(v8, v4, *(_QWORD *)(v5 + 704));
if ( (*(unsigned int ( **)(long long, _BYTE *, long long))(v6 + 8))(v6, v8, 9LL) )
return 0;
}
else if ( (*(unsigned int ( **)(long long, _QWORD, _QWORD))(v6 + 8))(v6, 0LL, 0LL) )
{
return 0;
}
return (unsigned int)-1;
}
v3 = (*(long long ( **)(long long, long long *))v6)(v6, &v4);
if ( v3 >= 0 )
{
if ( v3 == 9 || v3 == 21 )
{
memmove(v5 + 1166, v4, v3 - 1);
*(_BYTE *)(v5 + v3 - 1 + 1166) = 0;
goto LABEL_9;
}
return 2012;
}
else
{
return 0;
}
}
| auth_old_password:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV RAX,qword ptr [RBP + -0x20]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x0013df07
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x48e
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0013df76
LAB_0013df07:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x30]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JGE 0x0013df2c
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0013dffa
LAB_0013df2c:
CMP dword ptr [RBP + -0x34],0x9
JZ 0x0013df44
CMP dword ptr [RBP + -0x34],0x15
JZ 0x0013df44
MOV dword ptr [RBP + -0x18],0x7dc
JMP 0x0013dffa
LAB_0013df44:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x48e
MOV RSI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x1
MOVSXD RDX,EAX
CALL 0x001126c0
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x34]
SUB ECX,0x1
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1 + 0x48e],0x0
LAB_0013df76:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0013dfcf
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x2c0]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0013dfcf
LEA RDI,[RBP + -0x11]
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX + 0x2c0]
CALL 0x001454c0
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x11]
MOV EDX,0x9
CALL RAX
CMP EAX,0x0
JZ 0x0013dfcd
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0013dffa
LAB_0013dfcd:
JMP 0x0013dff3
LAB_0013dfcf:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x20]
XOR ECX,ECX
MOV ESI,ECX
XOR EDX,EDX
CALL RAX
CMP EAX,0x0
JZ 0x0013dff1
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0013dffa
LAB_0013dff1:
JMP 0x0013dff3
LAB_0013dff3:
MOV dword ptr [RBP + -0x18],0xffffffff
LAB_0013dffa:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013e01b
MOV EAX,dword ptr [RBP + -0x38]
ADD RSP,0x40
POP RBP
RET
LAB_0013e01b:
CALL 0x00112490
|
int4 auth_old_password(int8 *param_1,long param_2)
{
int iVar1;
long in_FS_OFFSET;
void *local_38;
long local_30;
int8 *local_28;
int4 local_20;
int1 local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = param_2;
local_28 = param_1;
if (*(char *)(param_1 + 9) == '\0') {
iVar1 = (*(code *)*param_1)(param_1,&local_38);
if (iVar1 < 0) {
local_20 = 0;
goto LAB_0013dffa;
}
if ((iVar1 != 9) && (iVar1 != 0x15)) {
local_20 = 0x7dc;
goto LAB_0013dffa;
}
memmove((void *)(local_30 + 0x48e),local_38,(long)(iVar1 + -1));
*(int1 *)(local_30 + 0x48e + (long)(iVar1 + -1)) = 0;
}
else {
local_38 = (void *)(param_2 + 0x48e);
}
if ((local_30 == 0) || (**(char **)(local_30 + 0x2c0) == '\0')) {
iVar1 = (*(code *)local_28[1])(local_28,0,0);
if (iVar1 != 0) {
local_20 = 0;
goto LAB_0013dffa;
}
}
else {
ma_scramble_323(local_19,local_38,*(int8 *)(local_30 + 0x2c0));
iVar1 = (*(code *)local_28[1])(local_28,local_19,9);
if (iVar1 != 0) {
local_20 = 0;
goto LAB_0013dffa;
}
}
local_20 = 0xffffffff;
LAB_0013dffa:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_20;
}
| |
25,918 | net_get_error | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void net_get_error(char *buf, size_t buf_len,
char *error, size_t error_len,
unsigned int *error_no,
char *sqlstate)
{
char *p= buf;
size_t error_msg_len= 0;
if (buf_len > 2)
{
*error_no= uint2korr(p);
p+= 2;
/* since 4.1 sqlstate is following */
if (*p == '#')
{
memcpy(sqlstate, ++p, SQLSTATE_LENGTH);
p+= SQLSTATE_LENGTH;
}
error_msg_len= buf_len - (p - buf);
error_msg_len= MIN(error_msg_len, error_len - 1);
memcpy(error, p, error_msg_len);
}
else
{
*error_no= CR_UNKNOWN_ERROR;
memcpy(sqlstate, SQLSTATE_UNKNOWN, SQLSTATE_LENGTH);
}
} | O0 | c | net_get_error:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x2, -0x10(%rbp)
jbe 0x1a318
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
movzwl %ax, %eax
movq -0x38(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movzwl %ax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x1a2c0
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movl 0x1(%rcx), %edx
movl %edx, (%rax)
movb 0x5(%rcx), %cl
movb %cl, 0x4(%rax)
movq -0x38(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rdx
subq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1a2f1
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1a2fd
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x13370
jmp 0x1a33a
movq -0x28(%rbp), %rax
movl $0x7d0, (%rax) # imm = 0x7D0
movq -0x30(%rbp), %rax
leaq 0x4ae53(%rip), %rcx # 0x65180
movq (%rcx), %rcx
movl (%rcx), %edx
movl %edx, (%rax)
movb 0x4(%rcx), %cl
movb %cl, 0x4(%rax)
addq $0x50, %rsp
popq %rbp
retq
| net_get_error:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov [rbp+var_40], 0
cmp [rbp+var_10], 2
jbe loc_1A318
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax]
movzx eax, ax
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
add eax, ecx
movzx ecx, ax
mov rax, [rbp+var_28]
mov [rax], ecx
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
movsx eax, byte ptr [rax]
cmp eax, 23h ; '#'
jnz short loc_1A2C0
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
mov rdx, rcx
add rdx, 1
mov [rbp+var_38], rdx
mov edx, [rcx+1]
mov [rax], edx
mov cl, [rcx+5]
mov [rax+4], cl
mov rax, [rbp+var_38]
add rax, 5
mov [rbp+var_38], rax
loc_1A2C0:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
mov rdx, [rbp+var_8]
sub rcx, rdx
sub rax, rcx
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov rcx, [rbp+var_20]
sub rcx, 1
cmp rax, rcx
jnb short loc_1A2F1
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
jmp short loc_1A2FD
loc_1A2F1:
mov rax, [rbp+var_20]
sub rax, 1
mov [rbp+var_48], rax
loc_1A2FD:
mov rax, [rbp+var_48]
mov [rbp+var_40], rax
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_40]
call _memcpy
jmp short loc_1A33A
loc_1A318:
mov rax, [rbp+var_28]
mov dword ptr [rax], 7D0h
mov rax, [rbp+var_30]
lea rcx, SQLSTATE_UNKNOWN
mov rcx, [rcx]
mov edx, [rcx]
mov [rax], edx
mov cl, [rcx+4]
mov [rax+4], cl
loc_1A33A:
add rsp, 50h
pop rbp
retn
| long long net_get_error(
unsigned __int8 *a1,
unsigned long long a2,
long long a3,
long long a4,
_DWORD *a5,
long long a6)
{
long long result; // rax
char *v7; // rcx
unsigned long long v8; // [rsp+8h] [rbp-48h]
unsigned __int8 *v9; // [rsp+18h] [rbp-38h]
if ( a2 <= 2 )
{
*a5 = 2000;
result = a6;
v7 = SQLSTATE_UNKNOWN;
*(_DWORD *)a6 = *(_DWORD *)SQLSTATE_UNKNOWN;
*(_BYTE *)(a6 + 4) = v7[4];
}
else
{
*a5 = (unsigned __int16)((a1[1] << 8) + *a1);
v9 = a1 + 2;
if ( a1[2] == 35 )
{
*(_DWORD *)a6 = *(_DWORD *)(a1 + 3);
*(_BYTE *)(a6 + 4) = a1[7];
v9 = a1 + 8;
}
if ( a2 - (v9 - a1) >= a4 - 1 )
v8 = a4 - 1;
else
v8 = a2 - (v9 - a1);
return memcpy(a3, v9, v8);
}
return result;
}
| net_get_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV qword ptr [RBP + -0x40],0x0
CMP qword ptr [RBP + -0x10],0x2
JBE 0x0011a318
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
ADD EAX,ECX
MOVZX ECX,AX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x23
JNZ 0x0011a2c0
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x38],RDX
MOV EDX,dword ptr [RCX + 0x1]
MOV dword ptr [RAX],EDX
MOV CL,byte ptr [RCX + 0x5]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x5
MOV qword ptr [RBP + -0x38],RAX
LAB_0011a2c0:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x8]
SUB RCX,RDX
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x20]
SUB RCX,0x1
CMP RAX,RCX
JNC 0x0011a2f1
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0011a2fd
LAB_0011a2f1:
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
LAB_0011a2fd:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x00113370
JMP 0x0011a33a
LAB_0011a318:
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],0x7d0
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x165180]
MOV RCX,qword ptr [RCX]
MOV EDX,dword ptr [RCX]
MOV dword ptr [RAX],EDX
MOV CL,byte ptr [RCX + 0x4]
MOV byte ptr [RAX + 0x4],CL
LAB_0011a33a:
ADD RSP,0x50
POP RBP
RET
|
void net_get_error(byte *param_1,ulong param_2,void *param_3,long param_4,uint *param_5,
int4 *param_6)
{
int *puVar1;
size_t local_50;
byte *local_40;
if (param_2 < 3) {
*param_5 = 2000;
puVar1 = SQLSTATE_UNKNOWN;
*param_6 = *(int4 *)SQLSTATE_UNKNOWN;
*(int *)(param_6 + 1) = puVar1[4];
}
else {
*param_5 = (uint)*param_1 + (uint)param_1[1] * 0x100 & 0xffff;
local_40 = param_1 + 2;
if (*local_40 == 0x23) {
*param_6 = *(int4 *)(param_1 + 3);
*(byte *)(param_6 + 1) = param_1[7];
local_40 = param_1 + 8;
}
local_50 = param_2 - ((long)local_40 - (long)param_1);
if (param_4 - 1U <= local_50) {
local_50 = param_4 - 1;
}
memcpy(param_3,local_40,local_50);
}
return;
}
| |
25,919 | MyCTX_gcm::finish(unsigned char*, unsigned int*) | eloqsql/mysys_ssl/my_crypt.cc | int finish(uchar *dst, uint *dlen)
{
int fin;
if (!EVP_CipherFinal_ex(ctx, dst, &fin))
return MY_AES_BAD_DATA;
DBUG_ASSERT(fin == 0);
if (EVP_CIPHER_CTX_encrypting(ctx))
{
if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, MY_AES_BLOCK_SIZE, dst))
return MY_AES_OPENSSL_ERROR;
*dlen= MY_AES_BLOCK_SIZE;
}
else
*dlen= 0;
return MY_AES_OK;
} | O3 | cpp | MyCTX_gcm::finish(unsigned char*, unsigned int*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0xc8(%rdi), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x29240
testl %eax, %eax
je 0x92e6a
movq 0xc8(%r12), %rdi
callq 0x297e0
xorl %r15d, %r15d
movl $0x0, %r13d
testl %eax, %eax
je 0x92e65
movq 0xc8(%r12), %rdi
movl $0x10, %r13d
movl $0x10, %esi
movl $0x10, %edx
movq %r14, %rcx
callq 0x29280
testl %eax, %eax
je 0x92e72
movl %r13d, (%rbx)
jmp 0x92e78
movl $0xffffff9c, %r15d # imm = 0xFFFFFF9C
jmp 0x92e78
movl $0xffffff9b, %r15d # imm = 0xFFFFFF9B
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN9MyCTX_gcm6finishEPhPj:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r12, rdi
mov rdi, [rdi+0C8h]
lea rdx, [rbp+var_2C]
call _EVP_CipherFinal_ex
test eax, eax
jz short loc_92E6A
mov rdi, [r12+0C8h]
call _EVP_CIPHER_CTX_is_encrypting
xor r15d, r15d
mov r13d, 0
test eax, eax
jz short loc_92E65
mov rdi, [r12+0C8h]
mov r13d, 10h
mov esi, 10h
mov edx, 10h
mov rcx, r14
call _EVP_CIPHER_CTX_ctrl
test eax, eax
jz short loc_92E72
loc_92E65:
mov [rbx], r13d
jmp short loc_92E78
loc_92E6A:
mov r15d, 0FFFFFF9Ch
jmp short loc_92E78
loc_92E72:
mov r15d, 0FFFFFF9Bh
loc_92E78:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long MyCTX_gcm::finish(MyCTX_gcm *this, unsigned __int8 *a2, unsigned int *a3)
{
long long v3; // rax
unsigned int v5; // r15d
unsigned int v6; // r13d
_DWORD v8[11]; // [rsp+0h] [rbp-2Ch] BYREF
v8[0] = HIDWORD(v3);
if ( (unsigned int)EVP_CipherFinal_ex(*((_QWORD *)this + 25), a2, v8) )
{
v5 = 0;
v6 = 0;
if ( (unsigned int)EVP_CIPHER_CTX_is_encrypting(*((_QWORD *)this + 25))
&& (v6 = 16, !(unsigned int)EVP_CIPHER_CTX_ctrl(*((_QWORD *)this + 25), 16LL, 16LL, a2)) )
{
return (unsigned int)-101;
}
else
{
*a3 = v6;
}
}
else
{
return (unsigned int)-100;
}
return v5;
}
| finish:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R12,RDI
MOV RDI,qword ptr [RDI + 0xc8]
LEA RDX,[RBP + -0x2c]
CALL 0x00129240
TEST EAX,EAX
JZ 0x00192e6a
MOV RDI,qword ptr [R12 + 0xc8]
CALL 0x001297e0
XOR R15D,R15D
MOV R13D,0x0
TEST EAX,EAX
JZ 0x00192e65
MOV RDI,qword ptr [R12 + 0xc8]
MOV R13D,0x10
MOV ESI,0x10
MOV EDX,0x10
MOV RCX,R14
CALL 0x00129280
TEST EAX,EAX
JZ 0x00192e72
LAB_00192e65:
MOV dword ptr [RBX],R13D
JMP 0x00192e78
LAB_00192e6a:
MOV R15D,0xffffff9c
JMP 0x00192e78
LAB_00192e72:
MOV R15D,0xffffff9b
LAB_00192e78:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* MyCTX_gcm::finish(unsigned char*, unsigned int*) */
int8 __thiscall MyCTX_gcm::finish(MyCTX_gcm *this,uchar *param_1,uint *param_2)
{
int iVar1;
uint uVar2;
int8 uVar3;
int local_34;
iVar1 = EVP_CipherFinal_ex(*(EVP_CIPHER_CTX **)(this + 200),param_1,&local_34);
if (iVar1 == 0) {
uVar3 = 0xffffff9c;
}
else {
iVar1 = EVP_CIPHER_CTX_is_encrypting(*(int8 *)(this + 200));
uVar3 = 0;
uVar2 = 0;
if (iVar1 != 0) {
uVar2 = 0x10;
iVar1 = EVP_CIPHER_CTX_ctrl(*(EVP_CIPHER_CTX **)(this + 200),0x10,0x10,param_1);
if (iVar1 == 0) {
return 0xffffff9b;
}
}
*param_2 = uVar2;
}
return uVar3;
}
| |
25,920 | my_rw_rdlock | eloqsql/mysys/thr_rwlock.c | int my_rw_rdlock(my_rw_lock_t *rwp)
{
pthread_mutex_lock(&rwp->lock);
/* active or queued writers */
while (( rwp->state < 0 ) || rwp->waiters)
pthread_cond_wait( &rwp->readers, &rwp->lock);
rwp->state++;
pthread_mutex_unlock(&rwp->lock);
return(0);
} | O0 | c | my_rw_rdlock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25490
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x88(%rcx)
movb %al, -0x9(%rbp)
jl 0x34c28
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8c(%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x34c31
jmp 0x34c44
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
callq 0x25530
jmp 0x34c05
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rdi
callq 0x25210
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_rw_rdlock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
call _pthread_mutex_lock
loc_34C05:
mov rcx, [rbp+var_8]
mov al, 1
cmp dword ptr [rcx+88h], 0
mov [rbp+var_9], al
jl short loc_34C28
mov rax, [rbp+var_8]
cmp dword ptr [rax+8Ch], 0
setnz al
mov [rbp+var_9], al
loc_34C28:
mov al, [rbp+var_9]
test al, 1
jnz short loc_34C31
jmp short loc_34C44
loc_34C31:
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
mov rsi, [rbp+var_8]
call _pthread_cond_wait
jmp short loc_34C05
loc_34C44:
mov rax, [rbp+var_8]
mov ecx, [rax+88h]
add ecx, 1
mov [rax+88h], ecx
mov rdi, [rbp+var_8]
call _pthread_mutex_unlock
xor eax, eax
add rsp, 10h
pop rbp
retn
| long long my_rw_rdlock(long long a1)
{
bool v2; // [rsp+7h] [rbp-9h]
pthread_mutex_lock(a1);
while ( 1 )
{
v2 = 1;
if ( *(int *)(a1 + 136) >= 0 )
v2 = *(_DWORD *)(a1 + 140) != 0;
if ( !v2 )
break;
pthread_cond_wait(a1 + 40, a1);
}
++*(_DWORD *)(a1 + 136);
pthread_mutex_unlock(a1);
return 0LL;
}
| my_rw_rdlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00125490
LAB_00134c05:
MOV RCX,qword ptr [RBP + -0x8]
MOV AL,0x1
CMP dword ptr [RCX + 0x88],0x0
MOV byte ptr [RBP + -0x9],AL
JL 0x00134c28
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x8c],0x0
SETNZ AL
MOV byte ptr [RBP + -0x9],AL
LAB_00134c28:
MOV AL,byte ptr [RBP + -0x9]
TEST AL,0x1
JNZ 0x00134c31
JMP 0x00134c44
LAB_00134c31:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x00125530
JMP 0x00134c05
LAB_00134c44:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x88]
ADD ECX,0x1
MOV dword ptr [RAX + 0x88],ECX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00125210
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 my_rw_rdlock(pthread_mutex_t *param_1)
{
bool bVar1;
pthread_mutex_lock(param_1);
while( true ) {
bVar1 = true;
if (-1 < *(int *)((long)param_1 + 0x88)) {
bVar1 = *(int *)((long)param_1 + 0x8c) != 0;
}
if (!bVar1) break;
pthread_cond_wait((pthread_cond_t *)(param_1 + 1),param_1);
}
*(int *)((long)param_1 + 0x88) = *(int *)((long)param_1 + 0x88) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
| |
25,921 | my_rw_rdlock | eloqsql/mysys/thr_rwlock.c | int my_rw_rdlock(my_rw_lock_t *rwp)
{
pthread_mutex_lock(&rwp->lock);
/* active or queued writers */
while (( rwp->state < 0 ) || rwp->waiters)
pthread_cond_wait( &rwp->readers, &rwp->lock);
rwp->state++;
pthread_mutex_unlock(&rwp->lock);
return(0);
} | O3 | c | my_rw_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x244c0
leaq 0x28(%rbx), %r14
movl 0x88(%rbx), %eax
testl %eax, %eax
js 0x2f272
cmpl $0x0, 0x8c(%rbx)
je 0x2f27f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24560
jmp 0x2f25f
incl %eax
movl %eax, 0x88(%rbx)
movq %rbx, %rdi
callq 0x24220
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| my_rw_rdlock:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call _pthread_mutex_lock
lea r14, [rbx+28h]
loc_2F25F:
mov eax, [rbx+88h]
test eax, eax
js short loc_2F272
cmp dword ptr [rbx+8Ch], 0
jz short loc_2F27F
loc_2F272:
mov rdi, r14
mov rsi, rbx
call _pthread_cond_wait
jmp short loc_2F25F
loc_2F27F:
inc eax
mov [rbx+88h], eax
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
pop rbx
pop r14
pop rbp
retn
| long long my_rw_rdlock(long long a1)
{
int v1; // eax
pthread_mutex_lock(a1);
while ( 1 )
{
v1 = *(_DWORD *)(a1 + 136);
if ( v1 >= 0 && !*(_DWORD *)(a1 + 140) )
break;
pthread_cond_wait(a1 + 40, a1);
}
*(_DWORD *)(a1 + 136) = v1 + 1;
pthread_mutex_unlock(a1);
return 0LL;
}
| my_rw_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x001244c0
LEA R14,[RBX + 0x28]
LAB_0012f25f:
MOV EAX,dword ptr [RBX + 0x88]
TEST EAX,EAX
JS 0x0012f272
CMP dword ptr [RBX + 0x8c],0x0
JZ 0x0012f27f
LAB_0012f272:
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124560
JMP 0x0012f25f
LAB_0012f27f:
INC EAX
MOV dword ptr [RBX + 0x88],EAX
MOV RDI,RBX
CALL 0x00124220
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
int8 my_rw_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
while ((*(int *)((long)param_1 + 0x88) < 0 || (*(int *)((long)param_1 + 0x8c) != 0))) {
pthread_cond_wait((pthread_cond_t *)(param_1 + 1),param_1);
}
*(int *)((long)param_1 + 0x88) = *(int *)((long)param_1 + 0x88) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
| |
25,922 | bf_exp | bluesky950520[P]quickjs/libbf.c | int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
bf_context_t *s = r->ctx;
int ret;
assert(r != a);
if (a->len == 0) {
if (a->expn == BF_EXP_NAN) {
bf_set_nan(r);
} else if (a->expn == BF_EXP_INF) {
if (a->sign)
bf_set_zero(r, 0);
else
bf_set_inf(r, 0);
} else {
bf_set_ui(r, 1);
}
return 0;
}
ret = check_exp_underflow_overflow(s, r, a, a, prec, flags);
if (ret)
return ret;
if (a->expn < 0 && (-a->expn) >= (prec + 2)) {
/* small argument case: result = 1 + epsilon * sign(x) */
bf_set_ui(r, 1);
return bf_add_epsilon(r, r, -(prec + 2), a->sign, prec, flags);
}
return bf_ziv_rounding(r, a, prec, flags, bf_exp_internal, NULL);
} | O2 | c | bf_exp:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x18(%rsi)
je 0x77d5f
movl %ecx, %ebp
movq %rdx, %r15
movq (%rbx), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r14, %rcx
movq %r15, %r8
movl %ebp, %r9d
callq 0x77df8
movl %eax, %r12d
testl %eax, %eax
jne 0x77daf
movq 0x10(%r14), %rax
testq %rax, %rax
jns 0x77d3d
negq %rax
leaq 0x2(%r15), %rcx
cmpq %rax, %rcx
jbe 0x77dca
leaq 0x3ca(%rip), %r8 # 0x7810e
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x78034
movq 0x10(%r14), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, %rax
je 0x77d8b
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jne 0x77da1
movq %rbx, %rdi
callq 0x7317d
jmp 0x77dac
cmpl $0x0, 0x8(%r14)
je 0x77dbb
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x731c2
jmp 0x77daf
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x73106
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x731ec
jmp 0x77daf
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x73106
pushq $-0x2
popq %rdx
subq %r15, %rdx
movl 0x8(%r14), %ecx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %r8
movl %ebp, %r9d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x77fb1
| bf_exp:
push rbp
push r15
push r14
push r12
push rbx
mov r14, rsi
mov rbx, rdi
cmp qword ptr [rsi+18h], 0
jz short loc_77D5F
mov ebp, ecx
mov r15, rdx
mov rdi, [rbx]
mov rsi, rbx
mov rdx, r14
mov rcx, r14
mov r8, r15
mov r9d, ebp
call check_exp_underflow_overflow
mov r12d, eax
test eax, eax
jnz loc_77DAF
mov rax, [r14+10h]
test rax, rax
jns short loc_77D3D
neg rax
lea rcx, [r15+2]
cmp rcx, rax
jbe loc_77DCA
loc_77D3D:
lea r8, bf_exp_internal
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov ecx, ebp
xor r9d, r9d
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp bf_ziv_rounding
loc_77D5F:
mov rax, [r14+10h]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp rax, rcx
jz short loc_77D8B
mov rcx, 7FFFFFFFFFFFFFFFh
cmp rax, rcx
jnz short loc_77DA1
mov rdi, rbx
call bf_set_nan
jmp short loc_77DAC
loc_77D8B:
cmp dword ptr [r14+8], 0
jz short loc_77DBB
xor r12d, r12d
mov rdi, rbx
xor esi, esi
call bf_set_zero
jmp short loc_77DAF
loc_77DA1:
push 1
pop rsi
mov rdi, rbx
call bf_set_ui
loc_77DAC:
xor r12d, r12d
loc_77DAF:
mov eax, r12d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_77DBB:
xor r12d, r12d
mov rdi, rbx
xor esi, esi
call bf_set_inf
jmp short loc_77DAF
loc_77DCA:
push 1
pop rsi
mov rdi, rbx
call bf_set_ui
push 0FFFFFFFFFFFFFFFEh
pop rdx
sub rdx, r15
mov ecx, [r14+8]
mov rdi, rbx
mov rsi, rbx
mov r8, r15
mov r9d, ebp
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp bf_add_epsilon
| long long bf_exp(_QWORD *a1, long long a2, long long a3, unsigned int a4)
{
unsigned int v6; // r12d
long long v7; // rax
long long v9; // rax
if ( !*(_QWORD *)(a2 + 24) )
{
v9 = *(_QWORD *)(a2 + 16);
if ( v9 == 0x7FFFFFFFFFFFFFFELL )
{
v6 = 0;
if ( *(_DWORD *)(a2 + 8) )
bf_set_zero((long long)a1, 0);
else
bf_set_inf((long long)a1, 0);
}
else
{
if ( v9 == 0x7FFFFFFFFFFFFFFFLL )
bf_set_nan((long long)a1);
else
bf_set_ui((long long)a1, 1uLL);
return 0;
}
return v6;
}
v6 = check_exp_underflow_overflow(*a1, a1, a2, a2, a3, a4);
if ( v6 )
return v6;
v7 = *(_QWORD *)(a2 + 16);
if ( v7 >= 0 || a3 + 2 > (unsigned long long)-v7 )
return bf_ziv_rounding(a1, a2, a3, a4, bf_exp_internal, 0LL);
bf_set_ui((long long)a1, 1uLL);
return bf_add_epsilon(a1, a1, -2 - a3, *(unsigned int *)(a2 + 8), a3, a4);
}
| bf_exp:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
CMP qword ptr [RSI + 0x18],0x0
JZ 0x00177d5f
MOV EBP,ECX
MOV R15,RDX
MOV RDI,qword ptr [RBX]
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R14
MOV R8,R15
MOV R9D,EBP
CALL 0x00177df8
MOV R12D,EAX
TEST EAX,EAX
JNZ 0x00177daf
MOV RAX,qword ptr [R14 + 0x10]
TEST RAX,RAX
JNS 0x00177d3d
NEG RAX
LEA RCX,[R15 + 0x2]
CMP RCX,RAX
JBE 0x00177dca
LAB_00177d3d:
LEA R8,[0x17810e]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV ECX,EBP
XOR R9D,R9D
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00178034
LAB_00177d5f:
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,0x7ffffffffffffffe
CMP RAX,RCX
JZ 0x00177d8b
MOV RCX,0x7fffffffffffffff
CMP RAX,RCX
JNZ 0x00177da1
MOV RDI,RBX
CALL 0x0017317d
JMP 0x00177dac
LAB_00177d8b:
CMP dword ptr [R14 + 0x8],0x0
JZ 0x00177dbb
XOR R12D,R12D
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001731c2
JMP 0x00177daf
LAB_00177da1:
PUSH 0x1
POP RSI
MOV RDI,RBX
CALL 0x00173106
LAB_00177dac:
XOR R12D,R12D
LAB_00177daf:
MOV EAX,R12D
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00177dbb:
XOR R12D,R12D
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001731ec
JMP 0x00177daf
LAB_00177dca:
PUSH 0x1
POP RSI
MOV RDI,RBX
CALL 0x00173106
PUSH -0x2
POP RDX
SUB RDX,R15
MOV ECX,dword ptr [R14 + 0x8]
MOV RDI,RBX
MOV RSI,RBX
MOV R8,R15
MOV R9D,EBP
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00177fb1
|
ulong bf_exp(int8 *param_1,long param_2,long param_3,int4 param_4)
{
uint uVar1;
ulong uVar2;
if (*(long *)(param_2 + 0x18) == 0) {
if (*(long *)(param_2 + 0x10) == 0x7ffffffffffffffe) {
if (*(int *)(param_2 + 8) == 0) {
uVar2 = 0;
bf_set_inf(param_1,0);
}
else {
uVar2 = 0;
bf_set_zero(param_1,0);
}
}
else {
if (*(long *)(param_2 + 0x10) == 0x7fffffffffffffff) {
bf_set_nan(param_1);
}
else {
bf_set_ui(param_1,1);
}
uVar2 = 0;
}
}
else {
uVar1 = check_exp_underflow_overflow(*param_1,param_1,param_2,param_2,param_3,param_4);
uVar2 = (ulong)uVar1;
if (uVar1 == 0) {
if ((*(long *)(param_2 + 0x10) < 0) && (param_3 + 2U <= (ulong)-*(long *)(param_2 + 0x10))) {
bf_set_ui(param_1,1);
uVar2 = bf_add_epsilon(param_1,param_1,-2 - param_3,*(int4 *)(param_2 + 8),param_3,
param_4);
return uVar2;
}
uVar2 = bf_ziv_rounding(param_1,param_2,param_3,param_4,bf_exp_internal,0);
return uVar2;
}
}
return uVar2;
}
| |
25,923 | pack_dirname | eloqsql/mysys/mf_pack.c | void pack_dirname(char * to, const char *from)
{
int cwd_err;
size_t d_length,length,UNINIT_VAR(buff_length);
char * start;
char buff[FN_REFLEN + 1];
DBUG_ENTER("pack_dirname");
(void) intern_filename(to,from); /* Change to intern name */
#ifdef FN_DEVCHAR
if ((start=strrchr(to,FN_DEVCHAR)) != 0) /* Skip device part */
start++;
else
#endif
start=to;
if (!(cwd_err= my_getwd(buff,FN_REFLEN,MYF(0))))
{
buff_length= strlen(buff);
d_length= (size_t) (start-to);
if ((start == to ||
(buff_length == d_length && !memcmp(buff,start,d_length))) &&
*start != FN_LIBCHAR && *start)
{ /* Put current dir before */
bchange((uchar*) to, d_length, (uchar*) buff, buff_length, strlen(to)+1);
}
}
if ((d_length= cleanup_dirname(to,to)) != 0)
{
length=0;
if (home_dir)
{
length= strlen(home_dir);
if (home_dir[length-1] == FN_LIBCHAR)
length--; /* Don't test last '/' */
}
if (length > 1 && length < d_length)
{ /* test if /xx/yy -> ~/yy */
if (memcmp(to,home_dir,length) == 0 && to[length] == FN_LIBCHAR)
{
to[0]=FN_HOMELIB; /* Filename begins with ~ */
(void) strmov_overlapp(to+1,to+length);
}
}
if (! cwd_err)
{ /* Test if cwd is ~/... */
if (length > 1 && length < buff_length)
{
if (memcmp(buff,home_dir,length) == 0 && buff[length] == FN_LIBCHAR)
{
buff[0]=FN_HOMELIB;
(void) strmov_overlapp(buff+1,buff+length);
}
}
if (is_prefix(to,buff))
{
length= strlen(buff);
if (to[length])
(void) strmov_overlapp(to,to+length); /* Remove everything before */
else
{
to[0]= FN_CURLIB; /* Put ./ instead of cwd */
to[1]= FN_LIBCHAR;
to[2]= '\0';
}
}
}
}
DBUG_PRINT("exit",("to: '%s'",to));
DBUG_VOID_RETURN;
} | O3 | c | pack_dirname:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
callq 0x2db69
leaq -0x240(%rbp), %rdi
movl $0x200, %esi # imm = 0x200
xorl %edx, %edx
callq 0x2f1e0
movl %eax, %r14d
testl %r14d, %r14d
je 0x2da41
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x2dbff
testq %rax, %rax
je 0x2da9f
movq %rax, %r15
movl %r14d, -0x244(%rbp)
leaq 0x33c543(%rip), %rax # 0x369f18
movq (%rax), %r13
testq %r13, %r13
je 0x2da90
movq %r13, %rdi
callq 0x24120
movq %rax, %r12
xorl %eax, %eax
cmpb $0x2f, -0x1(%r13,%r12)
sete %al
subq %rax, %r12
cmpq $0x2, %r12
setae %r14b
setb %al
cmpq %r15, %r12
setae %cl
orb %al, %cl
jne 0x2da96
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x242f0
movb $0x1, %r14b
testl %eax, %eax
jne 0x2da96
cmpb $0x2f, (%rbx,%r12)
jne 0x2da96
leaq (%rbx,%r12), %rsi
movb $0x7e, (%rbx)
leaq 0x1(%rbx), %rdi
callq 0x5eca4
jmp 0x2da96
leaq -0x240(%rbp), %rdi
callq 0x24120
movq %rax, %r15
movzbl (%rbx), %eax
testl %eax, %eax
movq %r15, -0x250(%rbp)
je 0x2d9b0
cmpl $0x2f, %eax
je 0x2d9b0
movq %rbx, %rdi
callq 0x24120
leaq 0x1(%rax), %r8
leaq -0x240(%rbp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x31994
jmp 0x2d9b0
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpl $0x0, -0x244(%rbp)
je 0x2dac4
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x2db64
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq -0x250(%rbp), %r12
setb %al
andb %al, %r14b
cmpb $0x1, %r14b
jne 0x2db1a
leaq 0x33c43a(%rip), %rax # 0x369f18
movq (%rax), %rsi
leaq -0x240(%rbp), %rdi
movq %r12, %rdx
callq 0x242f0
testl %eax, %eax
jne 0x2db1a
cmpb $0x2f, -0x240(%rbp,%r12)
jne 0x2db1a
leaq (%r12,%rbp), %rsi
addq $-0x240, %rsi # imm = 0xFDC0
leaq -0x23f(%rbp), %rdi
movb $0x7e, -0x1(%rdi)
callq 0x5eca4
leaq -0x240(%rbp), %rsi
movq %rbx, %rdi
callq 0x5c5cc
testl %eax, %eax
je 0x2da9f
leaq -0x240(%rbp), %rdi
callq 0x24120
cmpb $0x0, (%rbx,%rax)
je 0x2db56
addq %rbx, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5eca4
jmp 0x2da9f
movw $0x2f2e, (%rbx) # imm = 0x2F2E
movb $0x0, 0x2(%rbx)
jmp 0x2da9f
callq 0x24370
| pack_dirname:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 228h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
call intern_filename
lea rdi, [rbp+var_240]
mov esi, 200h
xor edx, edx
call my_getwd
mov r14d, eax
test r14d, r14d
jz loc_2DA41
loc_2D9B0:
mov rdi, rbx
mov rsi, rbx
call cleanup_dirname
test rax, rax
jz loc_2DA9F
mov r15, rax
mov [rbp+var_244], r14d
lea rax, home_dir
mov r13, [rax]
test r13, r13
jz loc_2DA90
mov rdi, r13
call _strlen
mov r12, rax
xor eax, eax
cmp byte ptr [r13+r12-1], 2Fh ; '/'
setz al
sub r12, rax
cmp r12, 2
setnb r14b
setb al
cmp r12, r15
setnb cl
or cl, al
jnz loc_2DA96
mov rdi, rbx
mov rsi, r13
mov rdx, r12
call _bcmp
mov r14b, 1
test eax, eax
jnz short loc_2DA96
cmp byte ptr [rbx+r12], 2Fh ; '/'
jnz short loc_2DA96
lea rsi, [rbx+r12]
mov byte ptr [rbx], 7Eh ; '~'
lea rdi, [rbx+1]
call strmov_overlapp
jmp short loc_2DA96
loc_2DA41:
lea rdi, [rbp+var_240]
call _strlen
mov r15, rax
movzx eax, byte ptr [rbx]
test eax, eax
mov [rbp+var_250], r15
jz loc_2D9B0
cmp eax, 2Fh ; '/'
jz loc_2D9B0
mov rdi, rbx
call _strlen
lea r8, [rax+1]
lea rdx, [rbp+var_240]
mov rdi, rbx
xor esi, esi
mov rcx, r15
call bchange
jmp loc_2D9B0
loc_2DA90:
xor r14d, r14d
xor r12d, r12d
loc_2DA96:
cmp [rbp+var_244], 0
jz short loc_2DAC4
loc_2DA9F:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_2DB64
add rsp, 228h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2DAC4:
cmp r12, [rbp+var_250]
setb al
and r14b, al
cmp r14b, 1
jnz short loc_2DB1A
lea rax, home_dir
mov rsi, [rax]
lea rdi, [rbp+var_240]
mov rdx, r12
call _bcmp
test eax, eax
jnz short loc_2DB1A
cmp [rbp+r12+var_240], 2Fh ; '/'
jnz short loc_2DB1A
lea rsi, [r12+rbp]
add rsi, 0FFFFFFFFFFFFFDC0h
lea rdi, [rbp+var_23F]
mov byte ptr [rdi-1], 7Eh ; '~'
call strmov_overlapp
loc_2DB1A:
lea rsi, [rbp+var_240]
mov rdi, rbx
call is_prefix
test eax, eax
jz loc_2DA9F
lea rdi, [rbp+var_240]
call _strlen
cmp byte ptr [rbx+rax], 0
jz short loc_2DB56
add rax, rbx
mov rdi, rbx
mov rsi, rax
call strmov_overlapp
jmp loc_2DA9F
loc_2DB56:
mov word ptr [rbx], 2F2Eh
mov byte ptr [rbx+2], 0
jmp loc_2DA9F
loc_2DB64:
call ___stack_chk_fail
| unsigned long long pack_dirname(char *a1, long long a2)
{
int v2; // r14d
long long v3; // rax
unsigned long long v4; // r15
long long v5; // r13
long long v6; // rax
unsigned long long v7; // r12
bool v8; // r14
long long v9; // r15
long long v10; // rax
long long v12; // rax
unsigned long long v13; // [rsp+0h] [rbp-250h]
int v14; // [rsp+Ch] [rbp-244h]
char v15; // [rsp+10h] [rbp-240h] BYREF
_BYTE v16[527]; // [rsp+11h] [rbp-23Fh] BYREF
unsigned long long v17; // [rsp+220h] [rbp-30h]
v17 = __readfsqword(0x28u);
intern_filename(a1, a2);
v2 = my_getwd(&v15, 512LL, 0LL);
if ( !v2 )
{
v9 = strlen(&v15);
v13 = v9;
if ( *a1 )
{
if ( *a1 != 47 )
{
v10 = strlen(a1);
bchange(a1, 0LL, &v15, v9, v10 + 1);
}
}
}
v3 = cleanup_dirname(a1, a1);
if ( v3 )
{
v4 = v3;
v14 = v2;
v5 = home_dir;
if ( home_dir )
{
v6 = strlen(home_dir);
v7 = v6 - (*(_BYTE *)(v5 + v6 - 1) == 47);
v8 = v7 >= 2;
if ( v7 >= 2 && v7 < v4 )
{
v8 = 1;
if ( !(unsigned int)bcmp(a1, v5, v7) && a1[v7] == 47 )
{
*a1 = 126;
strmov_overlapp(a1 + 1, &a1[v7]);
}
}
}
else
{
v8 = 0;
v7 = 0LL;
}
if ( !v14 )
{
if ( v7 < v13 && v8 && !(unsigned int)bcmp(&v15, home_dir, v7) && v16[v7 - 1] == 47 )
{
v15 = 126;
strmov_overlapp(v16, &v16[v7 - 1]);
}
if ( (unsigned int)is_prefix(a1, &v15) )
{
v12 = strlen(&v15);
if ( a1[v12] )
strmov_overlapp(a1, &a1[v12]);
else
strcpy(a1, "./");
}
}
}
return __readfsqword(0x28u);
}
| pack_dirname:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x228
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x0012db69
LEA RDI,[RBP + -0x240]
MOV ESI,0x200
XOR EDX,EDX
CALL 0x0012f1e0
MOV R14D,EAX
TEST R14D,R14D
JZ 0x0012da41
LAB_0012d9b0:
MOV RDI,RBX
MOV RSI,RBX
CALL 0x0012dbff
TEST RAX,RAX
JZ 0x0012da9f
MOV R15,RAX
MOV dword ptr [RBP + -0x244],R14D
LEA RAX,[0x469f18]
MOV R13,qword ptr [RAX]
TEST R13,R13
JZ 0x0012da90
MOV RDI,R13
CALL 0x00124120
MOV R12,RAX
XOR EAX,EAX
CMP byte ptr [R13 + R12*0x1 + -0x1],0x2f
SETZ AL
SUB R12,RAX
CMP R12,0x2
SETNC R14B
SETC AL
CMP R12,R15
SETNC CL
OR CL,AL
JNZ 0x0012da96
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R12
CALL 0x001242f0
MOV R14B,0x1
TEST EAX,EAX
JNZ 0x0012da96
CMP byte ptr [RBX + R12*0x1],0x2f
JNZ 0x0012da96
LEA RSI,[RBX + R12*0x1]
MOV byte ptr [RBX],0x7e
LEA RDI,[RBX + 0x1]
CALL 0x0015eca4
JMP 0x0012da96
LAB_0012da41:
LEA RDI,[RBP + -0x240]
CALL 0x00124120
MOV R15,RAX
MOVZX EAX,byte ptr [RBX]
TEST EAX,EAX
MOV qword ptr [RBP + -0x250],R15
JZ 0x0012d9b0
CMP EAX,0x2f
JZ 0x0012d9b0
MOV RDI,RBX
CALL 0x00124120
LEA R8,[RAX + 0x1]
LEA RDX,[RBP + -0x240]
MOV RDI,RBX
XOR ESI,ESI
MOV RCX,R15
CALL 0x00131994
JMP 0x0012d9b0
LAB_0012da90:
XOR R14D,R14D
XOR R12D,R12D
LAB_0012da96:
CMP dword ptr [RBP + -0x244],0x0
JZ 0x0012dac4
LAB_0012da9f:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0012db64
ADD RSP,0x228
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012dac4:
CMP R12,qword ptr [RBP + -0x250]
SETC AL
AND R14B,AL
CMP R14B,0x1
JNZ 0x0012db1a
LEA RAX,[0x469f18]
MOV RSI,qword ptr [RAX]
LEA RDI,[RBP + -0x240]
MOV RDX,R12
CALL 0x001242f0
TEST EAX,EAX
JNZ 0x0012db1a
CMP byte ptr [RBP + R12*0x1 + -0x240],0x2f
JNZ 0x0012db1a
LEA RSI,[R12 + RBP*0x1]
ADD RSI,-0x240
LEA RDI,[RBP + -0x23f]
MOV byte ptr [RDI + -0x1],0x7e
CALL 0x0015eca4
LAB_0012db1a:
LEA RSI,[RBP + -0x240]
MOV RDI,RBX
CALL 0x0015c5cc
TEST EAX,EAX
JZ 0x0012da9f
LEA RDI,[RBP + -0x240]
CALL 0x00124120
CMP byte ptr [RBX + RAX*0x1],0x0
JZ 0x0012db56
ADD RAX,RBX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0015eca4
JMP 0x0012da9f
LAB_0012db56:
MOV word ptr [RBX],0x2f2e
MOV byte ptr [RBX + 0x2],0x0
JMP 0x0012da9f
LAB_0012db64:
CALL 0x00124370
|
void pack_dirname(char *param_1)
{
char *__s2;
int iVar1;
int iVar2;
ulong uVar3;
size_t sVar4;
ulong __n;
long in_FS_OFFSET;
bool bVar5;
ulong local_258;
char local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
intern_filename();
iVar1 = my_getwd(local_248,0x200,0);
if (iVar1 == 0) {
local_258 = strlen(local_248);
if ((*param_1 != '\0') && (*param_1 != '/')) {
sVar4 = strlen(param_1);
bchange(param_1,0,local_248,local_258,sVar4 + 1);
}
}
uVar3 = cleanup_dirname(param_1,param_1);
__s2 = home_dir;
if (uVar3 != 0) {
if (home_dir == (char *)0x0) {
bVar5 = false;
__n = 0;
}
else {
sVar4 = strlen(home_dir);
__n = sVar4 - (__s2[sVar4 - 1] == '/');
bVar5 = 1 < __n;
if (__n < uVar3 && bVar5) {
iVar2 = bcmp(param_1,__s2,__n);
bVar5 = true;
if ((iVar2 == 0) && (param_1[__n] == '/')) {
*param_1 = '~';
strmov_overlapp(param_1 + 1,param_1 + __n);
}
}
}
if (iVar1 == 0) {
if ((bool)(bVar5 & __n < local_258)) {
iVar1 = bcmp(local_248,home_dir,__n);
if ((iVar1 == 0) && (local_248[__n] == '/')) {
local_248[0] = '~';
strmov_overlapp(local_248 + 1,local_248 + __n);
}
}
iVar1 = is_prefix(param_1,local_248);
if (iVar1 != 0) {
sVar4 = strlen(local_248);
if (param_1[sVar4] == '\0') {
param_1[0] = '.';
param_1[1] = '/';
param_1[2] = '\0';
}
else {
strmov_overlapp(param_1,param_1 + sVar4);
}
}
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
25,924 | JS_DeletePropertyInt64 | bluesky950520[P]quickjs/quickjs.c | int JS_DeletePropertyInt64(JSContext *ctx, JSValue obj, int64_t idx, int flags)
{
JSAtom prop;
int res;
if ((uint64_t)idx <= JS_ATOM_MAX_INT) {
/* fast path for fast arrays */
return JS_DeleteProperty(ctx, obj, __JS_AtomFromUInt32(idx), flags);
}
prop = JS_NewAtomInt64(ctx, idx);
if (prop == JS_ATOM_NULL)
return -1;
res = JS_DeleteProperty(ctx, obj, prop, flags);
JS_FreeAtom(ctx, prop);
return res;
} | O0 | c | JS_DeletePropertyInt64:
subq $0x48, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
cmpq $0x7fffffff, 0x20(%rsp) # imm = 0x7FFFFFFF
ja 0x37fef
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl %eax, %edi
callq 0x285b0
movq 0x8(%rsp), %rdi
movl %eax, %ecx
movl 0x1c(%rsp), %r8d
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x37650
movl %eax, 0x44(%rsp)
jmp 0x3804a
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x31dd0
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x38013
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x3804a
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x37650
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x29040
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_DeletePropertyInt64:
sub rsp, 48h
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_10], rdx
mov [rsp+48h+var_20], rdi
mov [rsp+48h+var_28], rcx
mov [rsp+48h+var_2C], r8d
cmp [rsp+48h+var_28], 7FFFFFFFh
ja short loc_37FEF
mov rax, [rsp+48h+var_20]
mov [rsp+48h+var_40], rax
mov rax, [rsp+48h+var_28]
mov edi, eax
call __JS_AtomFromUInt32
mov rdi, [rsp+48h+var_40]
mov ecx, eax
mov r8d, [rsp+48h+var_2C]
mov rsi, [rsp+48h+var_18]
mov rdx, [rsp+48h+var_10]
call JS_DeleteProperty
mov [rsp+48h+var_4], eax
jmp short loc_3804A
loc_37FEF:
mov rdi, [rsp+48h+var_20]
mov rsi, [rsp+48h+var_28]
call JS_NewAtomInt64
mov [rsp+48h+var_30], eax
cmp [rsp+48h+var_30], 0
jnz short loc_38013
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp short loc_3804A
loc_38013:
mov rdi, [rsp+48h+var_20]
mov ecx, [rsp+48h+var_30]
mov r8d, [rsp+48h+var_2C]
mov rsi, [rsp+48h+var_18]
mov rdx, [rsp+48h+var_10]
call JS_DeleteProperty
mov [rsp+48h+var_34], eax
mov rdi, [rsp+48h+var_20]
mov esi, [rsp+48h+var_30]
call JS_FreeAtom
mov eax, [rsp+48h+var_34]
mov [rsp+48h+var_4], eax
loc_3804A:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
| long long JS_DeletePropertyInt64(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
__int16 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
unsigned int v13; // eax
double v14; // xmm4_8
double v15; // xmm5_8
double v16; // xmm4_8
double v17; // xmm5_8
unsigned int v19; // [rsp+14h] [rbp-34h]
unsigned int v20; // [rsp+18h] [rbp-30h]
if ( a4 > 0x7FFFFFFF )
{
v20 = JS_NewAtomInt64(a1, a4);
if ( v20 )
{
v19 = JS_DeleteProperty(a1, a2, a3, v20, a5, a6, a7, a8, a9, v16, v17, a12, a13);
JS_FreeAtom(a1, v20);
return v19;
}
else
{
return (unsigned int)-1;
}
}
else
{
v13 = _JS_AtomFromUInt32(a4);
return (unsigned int)JS_DeleteProperty(a1, a2, a3, v13, a5, a6, a7, a8, a9, v14, v15, a12, a13);
}
}
| JS_DeletePropertyInt64:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RCX
MOV dword ptr [RSP + 0x1c],R8D
CMP qword ptr [RSP + 0x20],0x7fffffff
JA 0x00137fef
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV EDI,EAX
CALL 0x001285b0
MOV RDI,qword ptr [RSP + 0x8]
MOV ECX,EAX
MOV R8D,dword ptr [RSP + 0x1c]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x00137650
MOV dword ptr [RSP + 0x44],EAX
JMP 0x0013804a
LAB_00137fef:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x00131dd0
MOV dword ptr [RSP + 0x18],EAX
CMP dword ptr [RSP + 0x18],0x0
JNZ 0x00138013
MOV dword ptr [RSP + 0x44],0xffffffff
JMP 0x0013804a
LAB_00138013:
MOV RDI,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RSP + 0x18]
MOV R8D,dword ptr [RSP + 0x1c]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x00137650
MOV dword ptr [RSP + 0x14],EAX
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0x18]
CALL 0x00129040
MOV EAX,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x44],EAX
LAB_0013804a:
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
int4
JS_DeletePropertyInt64
(int8 param_1,int8 param_2,int8 param_3,ulong param_4,int4 param_5
)
{
int4 uVar1;
int iVar2;
int4 local_4;
if (param_4 < 0x80000000) {
uVar1 = __JS_AtomFromUInt32(param_4 & 0xffffffff);
local_4 = JS_DeleteProperty(param_1,param_2,param_3,uVar1,param_5);
}
else {
iVar2 = JS_NewAtomInt64(param_1,param_4);
if (iVar2 == 0) {
local_4 = 0xffffffff;
}
else {
local_4 = JS_DeleteProperty(param_1,param_2,param_3,iVar2,param_5);
JS_FreeAtom(param_1,iVar2);
}
}
return local_4;
}
| |
25,925 | JS_DeletePropertyInt64 | bluesky950520[P]quickjs/quickjs.c | int JS_DeletePropertyInt64(JSContext *ctx, JSValue obj, int64_t idx, int flags)
{
JSAtom prop;
int res;
if ((uint64_t)idx <= JS_ATOM_MAX_INT) {
/* fast path for fast arrays */
return JS_DeleteProperty(ctx, obj, __JS_AtomFromUInt32(idx), flags);
}
prop = JS_NewAtomInt64(ctx, idx);
if (prop == JS_ATOM_NULL)
return -1;
res = JS_DeleteProperty(ctx, obj, prop, flags);
JS_FreeAtom(ctx, prop);
return res;
} | O2 | c | JS_DeletePropertyInt64:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
ja 0x210e5
orl $0x80000000, %ecx # imm = 0x80000000
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20af7
movq %r14, %rdi
movq %rcx, %rsi
callq 0x1e3a6
testl %eax, %eax
je 0x21119
movl %eax, %ebp
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %eax, %ecx
movl %ebx, %r8d
callq 0x20af7
movl %eax, %ebx
movq %r14, %rdi
movl %ebp, %esi
callq 0x1a995
movl %ebx, %eax
jmp 0x2111c
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| JS_DeletePropertyInt64:
push rbp
push r15
push r14
push r12
push rbx
mov ebx, r8d
mov r15, rdx
mov r12, rsi
mov r14, rdi
cmp rcx, 7FFFFFFFh
ja short loc_210E5
or ecx, 80000000h
mov rdi, r14
mov rsi, r12
mov rdx, r15
mov r8d, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp JS_DeleteProperty
loc_210E5:
mov rdi, r14
mov rsi, rcx
call JS_NewAtomInt64
test eax, eax
jz short loc_21119
mov ebp, eax
mov rdi, r14
mov rsi, r12
mov rdx, r15
mov ecx, eax
mov r8d, ebx
call JS_DeleteProperty
mov ebx, eax
mov rdi, r14
mov esi, ebp
call JS_FreeAtom
mov eax, ebx
jmp short loc_2111C
loc_21119:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_2111C:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long JS_DeletePropertyInt64(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
__int16 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
unsigned int v16; // eax
double v17; // xmm4_8
double v18; // xmm5_8
int v19; // ebp
unsigned int v20; // ebx
if ( a4 <= 0x7FFFFFFF )
return JS_DeleteProperty(a1, a6, a7, a8, a9, a10, a11, a12, a13, a2, a3, (unsigned int)a4 | 0x80000000, a5);
v16 = JS_NewAtomInt64(a1, a4);
if ( !v16 )
return -1LL;
v19 = v16;
v20 = JS_DeleteProperty(a1, a6, a7, a8, a9, v17, v18, a12, a13, a2, a3, v16, a5);
JS_FreeAtom(a1, v19);
return v20;
}
| JS_DeletePropertyInt64:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBX,R8D
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
CMP RCX,0x7fffffff
JA 0x001210e5
OR ECX,0x80000000
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
MOV R8D,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00120af7
LAB_001210e5:
MOV RDI,R14
MOV RSI,RCX
CALL 0x0011e3a6
TEST EAX,EAX
JZ 0x00121119
MOV EBP,EAX
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
MOV ECX,EAX
MOV R8D,EBX
CALL 0x00120af7
MOV EBX,EAX
MOV RDI,R14
MOV ESI,EBP
CALL 0x0011a995
MOV EAX,EBX
JMP 0x0012111c
LAB_00121119:
PUSH -0x1
POP RAX
LAB_0012111c:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
ulong JS_DeletePropertyInt64
(int8 param_1,int8 param_2,int8 param_3,ulong param_4,
int4 param_5)
{
int iVar1;
uint uVar2;
ulong uVar3;
if (param_4 < 0x80000000) {
uVar3 = JS_DeleteProperty(param_1,param_2,param_3,(uint)param_4 | 0x80000000,param_5);
return uVar3;
}
iVar1 = JS_NewAtomInt64(param_1,param_4);
if (iVar1 == 0) {
uVar3 = 0xffffffffffffffff;
}
else {
uVar2 = JS_DeleteProperty(param_1,param_2,param_3,iVar1,param_5);
uVar3 = (ulong)uVar2;
JS_FreeAtom(param_1,iVar1);
}
return uVar3;
}
| |
25,926 | end_key_cache_internal | eloqsql/mysys/mf_keycache.c | static
void end_key_cache_internal(KEY_CACHE *keycache, my_bool cleanup,
my_bool use_op_lock)
{
if (keycache->key_cache_inited)
{
keycache->interface_funcs->end(keycache->keycache_cb, cleanup);
if (cleanup)
{
if (keycache->keycache_cb)
{
my_free(keycache->keycache_cb);
keycache->keycache_cb= 0;
}
/*
We do not destroy op_lock if we are going to reuse the same key cache.
This happens if we are called from repartition_key_cache_internal().
*/
if (use_op_lock)
pthread_mutex_destroy(&keycache->op_lock);
keycache->key_cache_inited= 0;
}
keycache->can_be_used= 0;
}
} | O3 | c | end_key_cache_internal:
cmpb $0x0, 0x48(%rdi)
je 0x998e3
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rax
movsbl %sil, %r15d
movl %r15d, %esi
callq *0x40(%rax)
testb %r15b, %r15b
je 0x998d5
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x998c3
callq 0xa1412
movq $0x0, 0x8(%rbx)
testb %r14b, %r14b
je 0x998d1
leaq 0x58(%rbx), %rdi
callq 0x290c0
movb $0x0, 0x48(%rbx)
movb $0x0, 0x49(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| end_key_cache_internal:
cmp byte ptr [rdi+48h], 0
jz short locret_998E3
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, edx
mov rbx, rdi
mov rdi, [rdi+8]
mov rax, [rbx+10h]
movsx r15d, sil
mov esi, r15d
call qword ptr [rax+40h]
test r15b, r15b
jz short loc_998D5
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_998C3
call my_free
mov qword ptr [rbx+8], 0
loc_998C3:
test r14b, r14b
jz short loc_998D1
lea rdi, [rbx+58h]
call _pthread_mutex_destroy
loc_998D1:
mov byte ptr [rbx+48h], 0
loc_998D5:
mov byte ptr [rbx+49h], 0
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_998E3:
retn
| long long end_key_cache_internal(long long a1, char a2, char a3)
{
long long result; // rax
long long v6; // rdi
if ( *(_BYTE *)(a1 + 72) )
{
result = (*(long long ( **)(_QWORD, _QWORD))(*(_QWORD *)(a1 + 16) + 64LL))(
*(_QWORD *)(a1 + 8),
(unsigned int)a2);
if ( a2 )
{
v6 = *(_QWORD *)(a1 + 8);
if ( v6 )
{
result = my_free(v6);
*(_QWORD *)(a1 + 8) = 0LL;
}
if ( a3 )
result = pthread_mutex_destroy(a1 + 88);
*(_BYTE *)(a1 + 72) = 0;
}
*(_BYTE *)(a1 + 73) = 0;
}
return result;
}
| end_key_cache_internal:
CMP byte ptr [RDI + 0x48],0x0
JZ 0x001998e3
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,EDX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RBX + 0x10]
MOVSX R15D,SIL
MOV ESI,R15D
CALL qword ptr [RAX + 0x40]
TEST R15B,R15B
JZ 0x001998d5
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x001998c3
CALL 0x001a1412
MOV qword ptr [RBX + 0x8],0x0
LAB_001998c3:
TEST R14B,R14B
JZ 0x001998d1
LEA RDI,[RBX + 0x58]
CALL 0x001290c0
LAB_001998d1:
MOV byte ptr [RBX + 0x48],0x0
LAB_001998d5:
MOV byte ptr [RBX + 0x49],0x0
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_001998e3:
RET
|
void end_key_cache_internal(long param_1,char param_2,char param_3)
{
if (*(char *)(param_1 + 0x48) != '\0') {
(**(code **)(*(long *)(param_1 + 0x10) + 0x40))(*(int8 *)(param_1 + 8),(int)param_2);
if (param_2 != '\0') {
if (*(long *)(param_1 + 8) != 0) {
my_free();
*(int8 *)(param_1 + 8) = 0;
}
if (param_3 != '\0') {
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x58));
}
*(int1 *)(param_1 + 0x48) = 0;
}
*(int1 *)(param_1 + 0x49) = 0;
}
return;
}
| |
25,927 | ftxui::automerge(std::shared_ptr<ftxui::Node>)::Impl::Render(ftxui::Screen&) | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/dom/automerge.cpp | void Render(Screen& screen) override {
for (int y = box_.y_min; y <= box_.y_max; ++y) {
for (int x = box_.x_min; x <= box_.x_max; ++x) {
screen.PixelAt(x, y).automerge = true;
}
}
Node::Render(screen);
} | O3 | cpp | ftxui::automerge(std::shared_ptr<ftxui::Node>)::Impl::Render(ftxui::Screen&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x54(%rdi), %r15d
movl 0x58(%rdi), %ecx
cmpl %ecx, %r15d
jg 0x3742b
movl 0x50(%r14), %eax
movl 0x4c(%r14), %r12d
cmpl %eax, %r12d
jg 0x3741f
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x3985c
orb $-0x80, (%rax)
leal 0x1(%r12), %ecx
movl 0x50(%r14), %eax
cmpl %eax, %r12d
movl %ecx, %r12d
jl 0x373f9
movl 0x58(%r14), %ecx
leal 0x1(%r15), %edx
cmpl %ecx, %r15d
movl %edx, %r15d
jl 0x373f0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x23eae
nopl (%rax)
| _ZZN5ftxui9automergeESt10shared_ptrINS_4NodeEEEN4Impl6RenderERNS_6ScreenE:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov r15d, [rdi+54h]
mov ecx, [rdi+58h]
cmp r15d, ecx
jg short loc_3742B
mov eax, [r14+50h]
loc_373F0:
mov r12d, [r14+4Ch]
cmp r12d, eax
jg short loc_3741F
loc_373F9:
mov rdi, rbx; this
mov esi, r12d; int
mov edx, r15d; int
call _ZN5ftxui6Screen7PixelAtEii; ftxui::Screen::PixelAt(int,int)
or byte ptr [rax], 80h
lea ecx, [r12+1]
mov eax, [r14+50h]
cmp r12d, eax
mov r12d, ecx
jl short loc_373F9
mov ecx, [r14+58h]
loc_3741F:
lea edx, [r15+1]
cmp r15d, ecx
mov r15d, edx
jl short loc_373F0
loc_3742B:
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _ZN5ftxui4Node6RenderERNS_6ScreenE; ftxui::Node::Render(ftxui::Screen &)
| long long ftxui::automerge(std::shared_ptr<ftxui::Node>)::Impl::Render(ftxui::Node *a1, ftxui::Screen *a2)
{
int v2; // r15d
int v3; // ecx
int v4; // eax
int v5; // r12d
_BYTE *v6; // rax
bool v7; // cc
v2 = *((_DWORD *)a1 + 21);
v3 = *((_DWORD *)a1 + 22);
if ( v2 <= v3 )
{
v4 = *((_DWORD *)a1 + 20);
do
{
v5 = *((_DWORD *)a1 + 19);
if ( v5 <= v4 )
{
do
{
v6 = (_BYTE *)ftxui::Screen::PixelAt(a2, v5, v2);
*v6 |= 0x80u;
v4 = *((_DWORD *)a1 + 20);
v7 = v5++ < v4;
}
while ( v7 );
v3 = *((_DWORD *)a1 + 22);
}
v7 = v2++ < v3;
}
while ( v7 );
}
return ftxui::Node::Render(a1, a2);
}
| Screen&):
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV R15D,dword ptr [RDI + 0x54]
MOV ECX,dword ptr [RDI + 0x58]
CMP R15D,ECX
JG 0x0013742b
MOV EAX,dword ptr [R14 + 0x50]
LAB_001373f0:
MOV R12D,dword ptr [R14 + 0x4c]
CMP R12D,EAX
JG 0x0013741f
LAB_001373f9:
MOV RDI,RBX
MOV ESI,R12D
MOV EDX,R15D
CALL 0x0013985c
OR byte ptr [RAX],0x80
LEA ECX,[R12 + 0x1]
MOV EAX,dword ptr [R14 + 0x50]
CMP R12D,EAX
MOV R12D,ECX
JL 0x001373f9
MOV ECX,dword ptr [R14 + 0x58]
LAB_0013741f:
LEA EDX,[R15 + 0x1]
CMP R15D,ECX
MOV R15D,EDX
JL 0x001373f0
LAB_0013742b:
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00123eae
|
/* ftxui::automerge(std::shared_ptr<ftxui::Node>)::Impl::Render(ftxui::Screen&) */
void ftxui::automerge(std::shared_ptr<ftxui::Node>)::Impl::Render(ftxui::Screen__
(Node *param_1,Screen *param_2)
{
bool bVar1;
int iVar2;
byte *pbVar3;
int iVar4;
int iVar5;
int iVar6;
iVar4 = *(int *)(param_1 + 0x58);
if (*(int *)(param_1 + 0x54) <= iVar4) {
iVar2 = *(int *)(param_1 + 0x50);
iVar6 = *(int *)(param_1 + 0x54);
do {
iVar5 = *(int *)(param_1 + 0x4c);
if (*(int *)(param_1 + 0x4c) <= iVar2) {
do {
pbVar3 = (byte *)Screen::PixelAt(param_2,iVar5,iVar6);
*pbVar3 = *pbVar3 | 0x80;
iVar2 = *(int *)(param_1 + 0x50);
bVar1 = iVar5 < iVar2;
iVar5 = iVar5 + 1;
} while (bVar1);
iVar4 = *(int *)(param_1 + 0x58);
}
bVar1 = iVar6 < iVar4;
iVar6 = iVar6 + 1;
} while (bVar1);
}
Node::Render(param_1,param_2);
return;
}
| |
25,928 | my_instr_simple | eloqsql/strings/ctype-simple.c | uint my_instr_simple(CHARSET_INFO *cs,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch)
{
register const uchar *str, *search, *end, *search_end;
if (s_length <= b_length)
{
if (!s_length)
{
if (nmatch)
{
match->beg= 0;
match->end= 0;
match->mb_len= 0;
}
return 1; /* Empty string is always found */
}
str= (const uchar*) b;
search= (const uchar*) s;
end= (const uchar*) b+b_length-s_length+1;
search_end= (const uchar*) s + s_length;
skip:
while (str != end)
{
if (cs->sort_order[*str++] == cs->sort_order[*search])
{
register const uchar *i,*j;
i= str;
j= search+1;
while (j != search_end)
if (cs->sort_order[*i++] != cs->sort_order[*j++])
goto skip;
if (nmatch > 0)
{
match[0].beg= 0;
match[0].end= (uint) (str- (const uchar*)b-1);
match[0].mb_len= match[0].end;
if (nmatch > 1)
{
match[1].beg= match[0].end;
match[1].end= (uint)(match[0].end+s_length);
match[1].mb_len= match[1].end-match[1].beg;
}
}
return 2;
}
}
}
return 0;
} | O3 | c | my_instr_simple:
xorl %eax, %eax
cmpq %rdx, %r8
ja 0xb5c84
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x10(%rbp), %r11d
testq %r8, %r8
je 0xb5c4a
addq %rsi, %rdx
subq %r8, %rdx
incq %rdx
movq %rsi, %r10
cmpq %rdx, %r10
je 0xb5c7a
movq %r10, %rbx
movq 0x58(%rdi), %r14
incq %r10
movzbl (%rbx), %r15d
movb (%r14,%r15), %r15b
movzbl (%rcx), %r12d
cmpb (%r14,%r12), %r15b
jne 0xb5bca
movl $0x1, %r15d
cmpq %r15, %r8
je 0xb5c13
movzbl (%rbx,%r15), %r12d
movb (%r14,%r12), %r12b
movzbl (%rcx,%r15), %r13d
incq %r15
cmpb (%r14,%r13), %r12b
je 0xb5bf5
jmp 0xb5bca
movl $0x2, %eax
testl %r11d, %r11d
je 0xb5c7a
movl $0x0, (%r9)
notl %esi
addl %esi, %r10d
movl %r10d, 0x4(%r9)
movl %r10d, 0x8(%r9)
cmpl $0x1, %r11d
je 0xb5c7a
movl %r10d, 0xc(%r9)
addl %r8d, %r10d
movl $0x14, %ecx
movl $0x10, %edx
jmp 0xb5c6b
testl %r11d, %r11d
je 0xb5c75
movl $0x0, (%r9)
movl $0x1, %eax
movl $0x8, %ecx
xorl %r10d, %r10d
movl $0x4, %edx
xorl %r8d, %r8d
movl %r10d, (%r9,%rdx)
movl %r8d, (%r9,%rcx)
jmp 0xb5c7a
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_instr_simple:
xor eax, eax
cmp r8, rdx
ja locret_B5C84
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov r11d, [rbp+10h]
test r8, r8
jz loc_B5C4A
add rdx, rsi
sub rdx, r8
inc rdx
mov r10, rsi
loc_B5BCA:
cmp r10, rdx
jz loc_B5C7A
mov rbx, r10
mov r14, [rdi+58h]
inc r10
movzx r15d, byte ptr [rbx]
mov r15b, [r14+r15]
movzx r12d, byte ptr [rcx]
cmp r15b, [r14+r12]
jnz short loc_B5BCA
mov r15d, 1
loc_B5BF5:
cmp r8, r15
jz short loc_B5C13
movzx r12d, byte ptr [rbx+r15]
mov r12b, [r14+r12]
movzx r13d, byte ptr [rcx+r15]
inc r15
cmp r12b, [r14+r13]
jz short loc_B5BF5
jmp short loc_B5BCA
loc_B5C13:
mov eax, 2
test r11d, r11d
jz short loc_B5C7A
mov dword ptr [r9], 0
not esi
add r10d, esi
mov [r9+4], r10d
mov [r9+8], r10d
cmp r11d, 1
jz short loc_B5C7A
mov [r9+0Ch], r10d
add r10d, r8d
mov ecx, 14h
mov edx, 10h
jmp short loc_B5C6B
loc_B5C4A:
test r11d, r11d
jz short loc_B5C75
mov dword ptr [r9], 0
mov eax, 1
mov ecx, 8
xor r10d, r10d
mov edx, 4
xor r8d, r8d
loc_B5C6B:
mov [r9+rdx], r10d
mov [r9+rcx], r8d
jmp short loc_B5C7A
loc_B5C75:
mov eax, 1
loc_B5C7A:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_B5C84:
retn
| long long my_instr_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
_DWORD *a6,
int a7)
{
long long result; // rax
long long v8; // rdx
unsigned __int8 *v9; // r10
unsigned __int8 *v10; // rbx
long long v11; // r14
long long v12; // r15
char v13; // r12
long long v14; // r13
int v15; // r10d
int v16; // r10d
long long v17; // rcx
long long v18; // rdx
result = 0LL;
if ( a5 <= a3 )
{
if ( a5 )
{
v8 = (long long)&a2[a3 - a5 + 1];
v9 = a2;
LABEL_4:
while ( v9 != (unsigned __int8 *)v8 )
{
v10 = v9;
v11 = *(_QWORD *)(a1 + 88);
++v9;
if ( *(_BYTE *)(v11 + *v10) == *(_BYTE *)(v11 + *a4) )
{
v12 = 1LL;
while ( a5 != v12 )
{
v13 = *(_BYTE *)(v11 + v10[v12]);
v14 = a4[v12++];
if ( v13 != *(_BYTE *)(v11 + v14) )
goto LABEL_4;
}
result = 2LL;
if ( a7 )
{
*a6 = 0;
v15 = ~(_DWORD)a2 + (_DWORD)v9;
a6[1] = v15;
a6[2] = v15;
if ( a7 != 1 )
{
a6[3] = v15;
v16 = a5 + v15;
v17 = 5LL;
v18 = 4LL;
goto LABEL_15;
}
}
return result;
}
}
}
else if ( a7 )
{
*a6 = 0;
result = 1LL;
v17 = 2LL;
v16 = 0;
v18 = 1LL;
LODWORD(a5) = 0;
LABEL_15:
a6[v18] = v16;
a6[v17] = a5;
}
else
{
return 1LL;
}
}
return result;
}
| my_instr_simple:
XOR EAX,EAX
CMP R8,RDX
JA 0x001b5c84
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R11D,dword ptr [RBP + 0x10]
TEST R8,R8
JZ 0x001b5c4a
ADD RDX,RSI
SUB RDX,R8
INC RDX
MOV R10,RSI
LAB_001b5bca:
CMP R10,RDX
JZ 0x001b5c7a
MOV RBX,R10
MOV R14,qword ptr [RDI + 0x58]
INC R10
MOVZX R15D,byte ptr [RBX]
MOV R15B,byte ptr [R14 + R15*0x1]
MOVZX R12D,byte ptr [RCX]
CMP R15B,byte ptr [R14 + R12*0x1]
JNZ 0x001b5bca
MOV R15D,0x1
LAB_001b5bf5:
CMP R8,R15
JZ 0x001b5c13
MOVZX R12D,byte ptr [RBX + R15*0x1]
MOV R12B,byte ptr [R14 + R12*0x1]
MOVZX R13D,byte ptr [RCX + R15*0x1]
INC R15
CMP R12B,byte ptr [R14 + R13*0x1]
JZ 0x001b5bf5
JMP 0x001b5bca
LAB_001b5c13:
MOV EAX,0x2
TEST R11D,R11D
JZ 0x001b5c7a
MOV dword ptr [R9],0x0
NOT ESI
ADD R10D,ESI
MOV dword ptr [R9 + 0x4],R10D
MOV dword ptr [R9 + 0x8],R10D
CMP R11D,0x1
JZ 0x001b5c7a
MOV dword ptr [R9 + 0xc],R10D
ADD R10D,R8D
MOV ECX,0x14
MOV EDX,0x10
JMP 0x001b5c6b
LAB_001b5c4a:
TEST R11D,R11D
JZ 0x001b5c75
MOV dword ptr [R9],0x0
MOV EAX,0x1
MOV ECX,0x8
XOR R10D,R10D
MOV EDX,0x4
XOR R8D,R8D
LAB_001b5c6b:
MOV dword ptr [R9 + RDX*0x1],R10D
MOV dword ptr [R9 + RCX*0x1],R8D
JMP 0x001b5c7a
LAB_001b5c75:
MOV EAX,0x1
LAB_001b5c7a:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_001b5c84:
RET
|
int8
my_instr_simple(long param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
int4 *param_6,int param_7)
{
byte *pbVar1;
byte *pbVar2;
int8 uVar3;
long lVar4;
long lVar5;
int iVar6;
byte *pbVar7;
byte *pbVar8;
ulong uVar9;
uVar3 = 0;
if (param_5 <= param_3) {
if (param_5 == 0) {
if (param_7 == 0) {
uVar3 = 1;
}
else {
*param_6 = 0;
uVar3 = 1;
lVar4 = 8;
iVar6 = 0;
lVar5 = 4;
param_5 = 0;
LAB_001b5c6b:
*(int *)((long)param_6 + lVar5) = iVar6;
*(int *)((long)param_6 + lVar4) = (int)param_5;
}
}
else {
pbVar8 = param_2;
while (pbVar7 = pbVar8, pbVar7 != param_2 + (param_3 - param_5) + 1) {
lVar4 = *(long *)(param_1 + 0x58);
pbVar8 = pbVar7 + 1;
if (*(char *)(lVar4 + (ulong)*pbVar7) == *(char *)(lVar4 + (ulong)*param_4)) {
uVar9 = 1;
do {
if (param_5 == uVar9) {
uVar3 = 2;
if (param_7 == 0) {
return 2;
}
*param_6 = 0;
iVar6 = (int)pbVar8 + ~(uint)param_2;
param_6[1] = iVar6;
param_6[2] = iVar6;
if (param_7 == 1) {
return 2;
}
param_6[3] = iVar6;
iVar6 = iVar6 + (int)param_5;
lVar4 = 0x14;
lVar5 = 0x10;
goto LAB_001b5c6b;
}
pbVar1 = pbVar7 + uVar9;
pbVar2 = param_4 + uVar9;
uVar9 = uVar9 + 1;
} while (*(char *)(lVar4 + (ulong)*pbVar1) == *(char *)(lVar4 + (ulong)*pbVar2));
}
}
}
}
return uVar3;
}
| |
25,929 | minja::VariableExpr::VariableExpr(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/minja.hpp | VariableExpr(const Location & location, const std::string& n)
: Expression(location), name(n) {} | O1 | cpp | minja::VariableExpr::VariableExpr(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x92e8b(%rip), %r15 # 0x12d3b8
addq $0x10, %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x9a55d
movq 0x94a39(%rip), %rcx # 0x12ef88
cmpb $0x0, (%rcx)
je 0x9a559
incl 0x8(%rax)
jmp 0x9a55d
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rbx)
leaq 0x93854(%rip), %rax # 0x12ddc0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x2344a
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9a5a8
callq 0x6e958
movq %r14, %rdi
callq 0x1bfb0
| _ZN5minja12VariableExprC2ERKNS_8LocationERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
mov rbx, rdi
lea r15, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add r15, 10h
mov [rdi], r15
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_9A55D
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_9A559
inc dword ptr [rax+8]
jmp short loc_9A55D
loc_9A559:
lock inc dword ptr [rax+8]
loc_9A55D:
mov rax, [rsi+10h]
mov [rbx+18h], rax
lea rax, _ZTVN5minja12VariableExprE; `vtable for'minja::VariableExpr
add rax, 10h
mov [rbx], rax
lea rdi, [rbx+20h]
lea rax, [rbx+30h]
mov [rbx+20h], rax
mov rsi, [rdx]
mov rdx, [rdx+8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov [rbx], r15
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_9A5A8
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9A5A8:
mov rdi, r14
call __Unwind_Resume
| long long minja::VariableExpr::VariableExpr(_QWORD *a1, _QWORD *a2, long long a3)
{
long long v3; // rax
*a1 = &`vtable for'minja::Expression + 2;
a1[1] = *a2;
v3 = a2[1];
a1[2] = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v3 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v3 + 8));
}
a1[3] = a2[2];
*a1 = &`vtable for'minja::VariableExpr + 2;
a1[4] = a1 + 6;
return std::string::_M_construct<char *>(a1 + 4, *(_BYTE **)a3, *(_QWORD *)a3 + *(_QWORD *)(a3 + 8));
}
| VariableExpr:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R15,[0x22d3b8]
ADD R15,0x10
MOV qword ptr [RDI],R15
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x0019a55d
MOV RCX,qword ptr [0x0022ef88]
CMP byte ptr [RCX],0x0
JZ 0x0019a559
INC dword ptr [RAX + 0x8]
JMP 0x0019a55d
LAB_0019a559:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0019a55d:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RBX + 0x18],RAX
LEA RAX,[0x22ddc0]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA RDI,[RBX + 0x20]
LEA RAX,[RBX + 0x30]
MOV qword ptr [RBX + 0x20],RAX
MOV RSI,qword ptr [RDX]
MOV RDX,qword ptr [RDX + 0x8]
ADD RDX,RSI
LAB_0019a589:
CALL 0x0012344a
LAB_0019a58e:
POP RBX
POP R14
POP R15
RET
|
/* minja::VariableExpr::VariableExpr(minja::Location const&, std::__cxx11::string const&) */
void __thiscall
minja::VariableExpr::VariableExpr(VariableExpr *this,Location *param_1,string *param_2)
{
long lVar1;
*(int ***)this = &PTR___cxa_pure_virtual_0022d3c8;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_0022ef88 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_evaluate_0022ddd0;
*(VariableExpr **)(this + 0x20) = this + 0x30;
/* try { // try from 0019a589 to 0019a58d has its CatchHandler @ 0019a594 */
std::__cxx11::string::_M_construct<char*>
(this + 0x20,*(long *)param_2,*(long *)(param_2 + 8) + *(long *)param_2);
return;
}
| |
25,930 | minja::VariableExpr::VariableExpr(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/minja.hpp | VariableExpr(const Location & location, const std::string& n)
: Expression(location), name(n) {} | O3 | cpp | minja::VariableExpr::VariableExpr(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbx
movq %rdi, %rbx
leaq 0x91da3(%rip), %rax # 0x12adc0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x9903c
movq (%rax), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x91375(%rip), %rax # 0x12a3b8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x99058
callq 0x6e096
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1a8e0
| _ZN5minja12VariableExprD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja12VariableExprE; `vtable for'minja::VariableExpr
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+20h]; void *
lea rax, [rbx+30h]
cmp rdi, rax
jz short loc_9903C
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9903C:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_99058
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_99058:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void minja::VariableExpr::~VariableExpr(minja::VariableExpr *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::VariableExpr + 2;
v2 = (char *)*((_QWORD *)this + 4);
if ( v2 != (char *)this + 48 )
operator delete(v2, *((_QWORD *)this + 6) + 1LL);
*(_QWORD *)this = &`vtable for'minja::Expression + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
| ~VariableExpr:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22adc0]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x20]
LEA RAX,[RBX + 0x30]
CMP RDI,RAX
JZ 0x0019903c
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0011a8e0
LAB_0019903c:
LEA RAX,[0x22a3b8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x00199058
CALL 0x0016e096
LAB_00199058:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x0011a8e0
|
/* minja::VariableExpr::~VariableExpr() */
void __thiscall minja::VariableExpr::~VariableExpr(VariableExpr *this)
{
*(int ***)this = &PTR_do_evaluate_0022add0;
if (*(VariableExpr **)(this + 0x20) != this + 0x30) {
operator_delete(*(VariableExpr **)(this + 0x20),*(long *)(this + 0x30) + 1);
}
*(int ***)this = &PTR___cxa_pure_virtual_0022a3c8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10));
}
operator_delete(this,0x40);
return;
}
| |
25,931 | 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>::size() const | monkey531[P]llama/common/./json.hpp | size_type size() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return 0;
}
case value_t::array:
{
// delegate call to array_t::size()
return m_data.m_value.array->size();
}
case value_t::object:
{
// delegate call to object_t::size()
return m_data.m_value.object->size();
}
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:
{
// all other types have size 1
return 1;
}
}
} | O1 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::size() const:
movzbl (%rdi), %eax
testl %eax, %eax
je 0x4adec
cmpl $0x1, %eax
je 0x4adc9
cmpl $0x2, %eax
jne 0x4ade7
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x4, %rax
retq
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
retq
movl $0x1, %eax
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv:
movzx eax, byte ptr [rdi]
test eax, eax
jz short locret_4ADEC
cmp eax, 1
jz short loc_4ADC9
cmp eax, 2
jnz short loc_4ADE7
mov rcx, [rdi+8]
mov rax, [rcx+8]
sub rax, [rcx]
sar rax, 4
retn
loc_4ADC9:
mov rax, [rdi+8]
mov rcx, [rax+8]
sub rcx, [rax]
sar rcx, 4
mov rax, 0AAAAAAAAAAAAAAABh
imul rax, rcx
retn
loc_4ADE7:
mov eax, 1
locret_4ADEC:
retn
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::size(
unsigned __int8 *a1)
{
long long result; // rax
result = *a1;
if ( *a1 )
{
if ( (_DWORD)result == 1 )
{
return 0xAAAAAAAAAAAAAAABLL * ((long long)(*(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL) - **((_QWORD **)a1 + 1)) >> 4);
}
else if ( (_DWORD)result == 2 )
{
return (long long)(*(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL) - **((_QWORD **)a1 + 1)) >> 4;
}
else
{
return 1LL;
}
}
return result;
}
| size:
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x0014adec
CMP EAX,0x1
JZ 0x0014adc9
CMP EAX,0x2
JNZ 0x0014ade7
MOV RCX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RCX + 0x8]
SUB RAX,qword ptr [RCX]
SAR RAX,0x4
RET
LAB_0014adc9:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,qword ptr [RAX]
SAR RCX,0x4
MOV RAX,-0x5555555555555555
IMUL RAX,RCX
RET
LAB_0014ade7:
MOV EAX,0x1
LAB_0014adec:
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::size() const */
ulong __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::size(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
ulong uVar2;
bVar1 = *this;
uVar2 = (ulong)(byte)bVar1;
if (bVar1 != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
return ((*(long **)(this + 8))[1] - **(long **)(this + 8) >> 4) * -0x5555555555555555;
}
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
return (*(long **)(this + 8))[1] - **(long **)(this + 8) >> 4;
}
uVar2 = 1;
}
return uVar2;
}
| |
25,932 | ma_column_nr_write | eloqsql/storage/maria/ma_open.c | my_bool _ma_column_nr_write(File file, uint16 *offsets, uint columns)
{
uchar *buff, *ptr, *end;
size_t size= columns*2;
my_bool res;
if (!(buff= (uchar*) my_alloca(size)))
return 1;
for (ptr= buff, end= ptr + size; ptr < end ; ptr+= 2, offsets++)
int2store(ptr, *offsets);
res= mysql_file_write(file, buff, size, MYF(MY_NABP)) != 0;
my_afree(buff);
return res;
} | O0 | c | ma_column_nr_write:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x68560
movb $0x1, -0x9(%rbp)
jmp 0x685e9
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x685b2
jmp 0x68580
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movw (%rax), %cx
movq -0x50(%rbp), %rax
movw %cx, (%rax)
jmp 0x68598
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x68574
movl -0x10(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %r8
leaq 0xe91b7(%rip), %rdi # 0x15177b
movl $0x79a, %esi # imm = 0x79A
movl $0x4, %r9d
callq 0x66df0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x51(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x68609
movb -0x51(%rbp), %al
movq %rbp, %rsp
popq %rbp
retq
callq 0x2a270
nop
| _ma_column_nr_write:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_10], edi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov eax, [rbp+var_1C]
add eax, eax
mov [rbp+var_40], rax
mov rcx, [rbp+var_40]
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_68560
mov [rbp+var_9], 1
jmp loc_685E9
loc_68560:
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rax, [rbp+var_40]
mov [rbp+var_38], rax
loc_68574:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jnb short loc_685B2
jmp short $+2
loc_68580:
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
mov cx, [rax]
mov rax, [rbp+var_50]
mov [rax], cx
jmp short $+2
loc_68598:
mov rax, [rbp+var_30]
add rax, 2
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
add rax, 2
mov [rbp+var_18], rax
jmp short loc_68574
loc_685B2:
mov edx, [rbp+var_10]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_40]
lea rdi, aWorkspaceLlm4b_14; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 79Ah
mov r9d, 4
call inline_mysql_file_write_0
cmp rax, 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_41], al
mov al, [rbp+var_41]
mov [rbp+var_9], al
loc_685E9:
mov al, [rbp+var_9]
mov [rbp+var_51], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_68609
mov al, [rbp+var_51]
mov rsp, rbp
pop rbp
retn
loc_68609:
call ___stack_chk_fail
| bool ma_column_nr_write(unsigned int a1, _WORD *a2, int a3)
{
_QWORD v4[3]; // [rsp+0h] [rbp-60h] BYREF
long long v6; // [rsp+20h] [rbp-40h]
unsigned long long v7; // [rsp+28h] [rbp-38h]
_WORD *v8; // [rsp+30h] [rbp-30h]
_WORD *v9; // [rsp+38h] [rbp-28h]
int v10; // [rsp+44h] [rbp-1Ch]
_WORD *v11; // [rsp+48h] [rbp-18h]
unsigned int v12; // [rsp+50h] [rbp-10h]
unsigned long long v14; // [rsp+58h] [rbp-8h]
v14 = __readfsqword(0x28u);
v12 = a1;
v11 = a2;
v10 = a3;
v6 = (unsigned int)(2 * a3);
v9 = (_WORD *)((char *)v4 - ((v6 + 15) & 0xFFFFFFFFFFFFFFF0LL));
if ( !v9 )
return 1;
v8 = v9;
v7 = (unsigned long long)v9 + v6;
while ( (unsigned long long)v8 < v7 )
{
v4[2] = v8;
*v8++ = *v11++;
}
return inline_mysql_file_write_0(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",
0x79Au,
v12,
(long long)v9,
v6,
4LL) != 0;
}
| _ma_column_nr_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EAX
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x40]
ADD RCX,0xf
AND RCX,-0x10
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x00168560
MOV byte ptr [RBP + -0x9],0x1
JMP 0x001685e9
LAB_00168560:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
LAB_00168574:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x001685b2
JMP 0x00168580
LAB_00168580:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x50]
MOV word ptr [RAX],CX
JMP 0x00168598
LAB_00168598:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x2
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00168574
LAB_001685b2:
MOV EDX,dword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x40]
LEA RDI,[0x25177b]
MOV ESI,0x79a
MOV R9D,0x4
CALL 0x00166df0
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x41],AL
MOV AL,byte ptr [RBP + -0x41]
MOV byte ptr [RBP + -0x9],AL
LAB_001685e9:
MOV AL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0x51],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00168609
MOV AL,byte ptr [RBP + -0x51]
MOV RSP,RBP
POP RBP
RET
LAB_00168609:
CALL 0x0012a270
|
int8 _ma_column_nr_write(int4 param_1,int2 *param_2,int param_3)
{
long lVar1;
ulong uVar2;
int2 *puVar3;
int4 uVar4;
long lVar5;
long in_FS_OFFSET;
int8 uStack_70;
int2 auStack_68 [7];
bool local_59;
int2 *local_58;
int1 local_49;
ulong local_48;
int2 *local_40;
int2 *local_38;
int2 *local_30;
int local_24;
int2 *local_20;
int4 local_18;
bool local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = (ulong)(uint)(param_3 * 2);
lVar1 = -(local_48 + 0xf & 0xfffffffffffffff0);
local_30 = (int2 *)((long)auStack_68 + lVar1);
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
if (local_30 == (int2 *)0x0) {
local_11 = true;
}
else {
local_40 = (int2 *)((long)local_30 + local_48);
for (local_38 = local_30; uVar4 = local_18, puVar3 = local_30, uVar2 = local_48,
local_38 < local_40; local_38 = local_38 + 1) {
local_58 = local_38;
*local_38 = *local_20;
local_20 = local_20 + 1;
}
*(int8 *)((long)&uStack_70 + lVar1) = 0x1685d4;
lVar5 = inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",0x79a,
uVar4,puVar3,uVar2,4);
local_49 = lVar5 != 0;
local_11 = (bool)local_49;
}
local_59 = local_11;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_11);
}
/* WARNING: Subroutine does not return */
*(int8 *)((long)&uStack_70 + lVar1) = 0x16860e;
__stack_chk_fail();
}
| |
25,933 | minja::FilterTemplateToken::FilterTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::Expression>&&) | monkey531[P]llama/common/minja.hpp | TemplateToken(Type type, const Location & location, SpaceHandling pre, SpaceHandling post) : type(type), location(location), pre_space(pre), post_space(post) {} | O1 | cpp | minja::FilterTemplateToken::FilterTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::Expression>&&):
leaq 0x93451(%rip), %rax # 0x1322e8
addq $0x10, %rax
movq %rax, (%rdi)
movl $0xf, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0x9eecf
movq 0x950c0(%rip), %r9 # 0x133f80
cmpb $0x0, (%r9)
je 0x9eecb
incl 0x8(%rax)
jmp 0x9eecf
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rdi)
movl %edx, 0x28(%rdi)
movl %ecx, 0x2c(%rdi)
leaq 0x93f64(%rip), %rax # 0x132e48
addq $0x10, %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x38(%rdi)
movups (%r8), %xmm0
movq %rax, 0x8(%r8)
movups %xmm0, 0x30(%rdi)
movq %rax, (%r8)
retq
nop
| _ZN5minja19FilterTemplateTokenC2ERKNS_8LocationENS_13SpaceHandlingES4_OSt10shared_ptrINS_10ExpressionEE:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rdi], rax
mov dword ptr [rdi+8], 0Fh
mov rax, [rsi]
mov [rdi+10h], rax
mov rax, [rsi+8]
mov [rdi+18h], rax
test rax, rax
jz short loc_9EECF
mov r9, cs:__libc_single_threaded_ptr
cmp byte ptr [r9], 0
jz short loc_9EECB
inc dword ptr [rax+8]
jmp short loc_9EECF
loc_9EECB:
lock inc dword ptr [rax+8]
loc_9EECF:
mov rax, [rsi+10h]
mov [rdi+20h], rax
mov [rdi+28h], edx
mov [rdi+2Ch], ecx
lea rax, _ZTVN5minja19FilterTemplateTokenE; `vtable for'minja::FilterTemplateToken
add rax, 10h
mov [rdi], rax
xor eax, eax
mov [rdi+38h], rax
movups xmm0, xmmword ptr [r8]
mov [r8+8], rax
movups xmmword ptr [rdi+30h], xmm0
mov [r8], rax
retn
| long long minja::FilterTemplateToken::FilterTemplateToken(
long long a1,
_QWORD *a2,
int a3,
int a4,
__int128 *a5)
{
long long v5; // rax
long long result; // rax
__int128 v7; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::TemplateToken + 2;
*(_DWORD *)(a1 + 8) = 15;
*(_QWORD *)(a1 + 16) = *a2;
v5 = a2[1];
*(_QWORD *)(a1 + 24) = v5;
if ( v5 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v5 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v5 + 8));
}
*(_QWORD *)(a1 + 32) = a2[2];
*(_DWORD *)(a1 + 40) = a3;
*(_DWORD *)(a1 + 44) = a4;
*(_QWORD *)a1 = &`vtable for'minja::FilterTemplateToken + 2;
result = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
v7 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v7;
*(_QWORD *)a5 = 0LL;
return result;
}
| FilterTemplateToken:
LEA RAX,[0x2322e8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV dword ptr [RDI + 0x8],0xf
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x18],RAX
TEST RAX,RAX
JZ 0x0019eecf
MOV R9,qword ptr [0x00233f80]
CMP byte ptr [R9],0x0
JZ 0x0019eecb
INC dword ptr [RAX + 0x8]
JMP 0x0019eecf
LAB_0019eecb:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0019eecf:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x20],RAX
MOV dword ptr [RDI + 0x28],EDX
MOV dword ptr [RDI + 0x2c],ECX
LEA RAX,[0x232e48]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x38],RAX
MOVUPS XMM0,xmmword ptr [R8]
MOV qword ptr [R8 + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV qword ptr [R8],RAX
RET
|
/* minja::FilterTemplateToken::FilterTemplateToken(minja::Location const&, minja::SpaceHandling,
minja::SpaceHandling, std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::FilterTemplateToken::FilterTemplateToken
(FilterTemplateToken *this,int8 *param_1,int4 param_3,int4 param_4,
int8 *param_5)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR__TemplateToken_002322f8;
*(int4 *)(this + 8) = 0xf;
*(int8 *)(this + 0x10) = *param_1;
lVar1 = param_1[1];
*(long *)(this + 0x18) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_00233f80 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x20) = param_1[2];
*(int4 *)(this + 0x28) = param_3;
*(int4 *)(this + 0x2c) = param_4;
*(int ***)this = &PTR__FilterTemplateToken_00232e58;
*(int8 *)(this + 0x38) = 0;
uVar2 = param_5[1];
param_5[1] = 0;
*(int8 *)(this + 0x30) = *param_5;
*(int8 *)(this + 0x38) = uVar2;
*param_5 = 0;
return;
}
| |
25,934 | my_strtoll10_mb2 | eloqsql/strings/ctype-ucs2.c | static longlong
my_strtoll10_mb2(CHARSET_INFO *cs __attribute__((unused)),
const char *nptr, char **endptr, int *error)
{
const uchar *s, *end, *start, *n_end, *true_end;
uchar UNINIT_VAR(c);
unsigned long i, j, k;
ulonglong li;
int negative;
ulong cutoff, cutoff2, cutoff3;
my_wc_t wc;
int res;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
s= (const uchar *) nptr;
/* If fixed length string */
if (endptr)
{
/*
Make sure string length is even.
Odd length indicates a bug in the caller.
Assert in debug, round in production.
*/
DBUG_ASSERT((*endptr - (const char *) s) % 2 == 0);
end= s + ((*endptr - (const char*) s) / 2) * 2;
for ( ; ; ) /* Skip leading spaces and tabs */
{
if ((res= mb_wc(cs, &wc, s, end)) <= 0)
goto no_conv;
s+= res;
if (wc != ' ' && wc != '\t')
break;
}
}
else
{
/* We don't support null terminated strings in UCS2 */
goto no_conv;
}
/* Check for a sign. */
negative= 0;
if (wc == '-')
{
*error= -1; /* Mark as negative number */
negative= 1;
if ((res= mb_wc(cs, &wc, s, end)) <= 0)
goto no_conv;
s+= res; /* wc is now expected to hold the first digit. */
cutoff= MAX_NEGATIVE_NUMBER / LFACTOR2;
cutoff2= (MAX_NEGATIVE_NUMBER % LFACTOR2) / 100;
cutoff3= MAX_NEGATIVE_NUMBER % 100;
}
else
{
*error= 0;
if (wc == '+')
{
if ((res= mb_wc(cs, &wc, s, end)) <= 0)
goto no_conv;
s+= res; /* wc is now expected to hold the first digit. */
}
cutoff= ULONGLONG_MAX / LFACTOR2;
cutoff2= ULONGLONG_MAX % LFACTOR2 / 100;
cutoff3= ULONGLONG_MAX % 100;
}
/*
The code below assumes that 'wc' holds the first digit
and 's' points to the next character after it.
Scan pre-zeros if any.
*/
if (wc == '0')
{
i= 0;
for ( ; ; s+= res)
{
if (s == end)
goto end_i; /* Return 0 */
if ((res= mb_wc(cs, &wc, s, end)) <= 0)
goto no_conv;
if (wc != '0')
break;
}
n_end= s + 2 * INIT_CNT;
}
else
{
/* Read first digit to check that it's a valid number */
if ((i= (wc - '0')) > 9)
goto no_conv;
n_end= s + 2 * (INIT_CNT-1);
}
/* Handle first 9 digits and store them in i */
if (n_end > end)
n_end= end;
for ( ; ; s+= res)
{
if ((res= mb_wc(cs, &wc, s, n_end)) <= 0)
break;
if (wc2digit_uchar(&c, wc))
goto end_i;
i= i*10+c;
}
if (s == end)
goto end_i;
/* Handle next 9 digits and store them in j */
j= 0;
start= s; /* Used to know how much to shift i */
n_end= true_end= s + 2 * INIT_CNT;
if (n_end > end)
n_end= end;
do
{
if ((res= mb_wc(cs, &wc, s, end)) <= 0)
goto no_conv;
if (wc2digit_uchar(&c, wc))
goto end_i_and_j;
s+= res;
j= j * 10 + c;
} while (s != n_end);
if (s == end)
{
if (s != true_end)
goto end_i_and_j;
goto end3;
}
/* Handle the next 1 or 2 digits and store them in k */
if ((res= mb_wc(cs, &wc, s, end)) <= 0)
goto no_conv;
if ((k= (wc - '0')) > 9)
goto end3;
s+= res;
if (s == end)
goto end4;
if ((res= mb_wc(cs, &wc, s, end)) <= 0)
goto no_conv;
if (wc2digit_uchar(&c, wc))
goto end4;
s+= res;
k= k*10+c;
*endptr= (char*) s;
/* number string should have ended here */
if (s != end && mb_wc(cs, &wc, s, end) > 0 && ((uchar) (wc - '0')) <= 9)
goto overflow;
/* Check that we didn't get an overflow with the last digit */
if (i > cutoff || (i == cutoff && ((j > cutoff2 || j == cutoff2) &&
k > cutoff3)))
goto overflow;
li=i*LFACTOR2+ (ulonglong) j*100 + k;
return (longlong) li;
overflow: /* *endptr is set here */
*error= MY_ERRNO_ERANGE;
return negative ? LONGLONG_MIN : (longlong) ULONGLONG_MAX;
end_i:
*endptr= (char*) s;
return (negative ? ((longlong) -(long) i) : (longlong) i);
end_i_and_j:
li= (ulonglong) i * lfactor[(size_t) (s-start) / 2] + j;
*endptr= (char*) s;
return (negative ? -((longlong) li) : (longlong) li);
end3:
li=(ulonglong) i*LFACTOR+ (ulonglong) j;
*endptr= (char*) s;
return (negative ? -((longlong) li) : (longlong) li);
end4:
li=(ulonglong) i*LFACTOR1+ (ulonglong) j * 10 + k;
*endptr= (char*) s;
if (negative)
{
if (li > MAX_NEGATIVE_NUMBER)
goto overflow;
return -((longlong) li);
}
return (longlong) li;
no_conv:
/* There was no number to convert. */
*error= MY_ERRNO_EDOM;
*endptr= (char *) nptr;
return 0;
} | O3 | c | my_strtoll10_mb2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
movq %rdx, -0x48(%rbp)
testq %rdx, %rdx
je 0x4bbcd
movq %rdi, %r12
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %r8
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq -0x68(%rbp), %rdx
subq %rdx, %rax
movq %rax, %r15
shrq $0x3f, %r15
addq %rax, %r15
andq $-0x2, %r15
addq %rdx, %r15
leaq -0x30(%rbp), %rsi
movq %r15, %rcx
movq %r8, -0x38(%rbp)
callq *%r8
testl %eax, %eax
jle 0x4bbcd
leaq -0x30(%rbp), %rbx
movq -0x68(%rbp), %r13
movq %r13, %rcx
movl %eax, %r13d
addq %rcx, %r13
movq -0x30(%rbp), %r14
cmpq $0x20, %r14
je 0x4bbba
cmpq $0x9, %r14
jne 0x4bbf3
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq *-0x38(%rbp)
testl %eax, %eax
jg 0x4bba1
movq -0x60(%rbp), %rax
movl $0x21, (%rax)
movq -0x48(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x2d, %r14
jne 0x4bc39
movq -0x60(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq *-0x38(%rbp)
testl %eax, %eax
jle 0x4bbcd
movl %eax, %eax
addq %rax, %r13
movl $0x8, %eax
movq %rax, -0x70(%rbp)
movl $0x15f797ae, %eax # imm = 0x15F797AE
movq %rax, -0x78(%rbp)
movl $0x57f5ff8, %eax # imm = 0x57F5FF8
movq %rax, -0x58(%rbp)
jmp 0x4bc81
movq -0x60(%rbp), %rax
movl $0x0, (%rax)
movl $0xf, %eax
movq %rax, -0x70(%rbp)
movl $0x2bef2f5c, %eax # imm = 0x2BEF2F5C
movq %rax, -0x78(%rbp)
movl $0xafebff0, %eax # imm = 0xAFEBFF0
movq %rax, -0x58(%rbp)
cmpq $0x2b, %r14
jne 0x4bc81
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq *-0x38(%rbp)
testl %eax, %eax
jle 0x4bbcd
movl %eax, %eax
addq %rax, %r13
movq -0x30(%rbp), %rax
cmpq $0x30, %rax
jne 0x4bcc3
cmpq %r15, %r13
je 0x4bcbc
leaq -0x30(%rbp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq *-0x38(%rbp)
testl %eax, %eax
jle 0x4bbcd
cmpq $0x30, -0x30(%rbp)
jne 0x4bcda
movl %eax, %eax
addq %rax, %r13
cmpq %r15, %r13
jne 0x4bc94
xorl %ebx, %ebx
jmp 0x4be90
addq $-0x30, %rax
cmpq $0x9, %rax
ja 0x4bbcd
movq %rax, %rbx
leaq 0x10(%r13), %rcx
jmp 0x4bce0
leaq 0x12(%r13), %rcx
xorl %ebx, %ebx
cmpq %r15, %rcx
cmovaq %r15, %rcx
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %rcx, -0x40(%rbp)
callq *-0x38(%rbp)
testl %eax, %eax
jle 0x4bd36
movq -0x30(%rbp), %rcx
cmpq $0x39, %rcx
ja 0x4be8d
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x4be8d
leaq (%rbx,%rbx,4), %rdx
movzbl %cl, %ecx
leaq (%rcx,%rdx,2), %rbx
movl %eax, %eax
addq %rax, %r13
movq %r12, %rdi
leaq -0x30(%rbp), %rsi
movq %r13, %rdx
movq -0x40(%rbp), %rcx
jmp 0x4bcf5
cmpq %r15, %r13
je 0x4be90
movq %rbx, -0x50(%rbp)
leaq 0x12(%r13), %rax
cmpq %r15, %rax
cmovaq %r15, %rax
movq %rax, -0x80(%rbp)
xorl %ebx, %ebx
xorl %esi, %esi
movq %rsi, -0x40(%rbp)
leaq (%rbx,%r13), %rdx
movq %r12, %rdi
leaq -0x30(%rbp), %rsi
movq %rdx, -0x88(%rbp)
movq %r15, %rcx
callq *-0x38(%rbp)
testl %eax, %eax
jle 0x4bbcd
movq -0x30(%rbp), %rcx
cmpq $0x39, %rcx
ja 0x4beaa
addb $-0x30, %cl
cmpb $0x9, %cl
movq -0x40(%rbp), %rsi
ja 0x4beae
movl %eax, %eax
addq %rax, %rbx
leaq (%rbx,%r13), %r8
leaq (%rsi,%rsi,4), %rax
movzbl %cl, %ecx
leaq (%rcx,%rax,2), %rsi
cmpq -0x80(%rbp), %r8
jne 0x4bd56
cmpq %r15, -0x80(%rbp)
je 0x4beec
movq %rsi, -0x40(%rbp)
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
movq %r8, %rbx
movq %r8, %rdx
movq %r15, %rcx
callq *-0x38(%rbp)
testl %eax, %eax
jle 0x4bbcd
movq -0x30(%rbp), %r13
addq $-0x30, %r13
cmpq $0x9, %r13
movq -0x40(%rbp), %rsi
movq %rbx, %r8
ja 0x4bef2
movl %eax, %eax
addq %rax, %r8
cmpq %r15, %r8
je 0x4bf17
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
movq %r8, %rbx
movq %r8, %rdx
movq %r15, %rcx
callq *-0x38(%rbp)
testl %eax, %eax
jle 0x4bbcd
movq -0x30(%rbp), %rcx
cmpq $0x39, %rcx
movq -0x40(%rbp), %rsi
movq %rbx, %r8
ja 0x4bf17
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x4bf17
movq %rcx, %rbx
movl %eax, %eax
addq %rax, %r8
movq -0x48(%rbp), %rax
movq %r8, (%rax)
cmpq %r15, %r8
je 0x4bf7c
movq %r8, %rdx
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq *-0x38(%rbp)
testl %eax, %eax
jle 0x4bf7c
movl $0xd0, %eax
addl -0x30(%rbp), %eax
andl $0xfe, %eax
cmpl $0xa, %eax
movq -0x50(%rbp), %rdx
jae 0x4bf80
jmp 0x4bf54
movq %r13, %r15
movq %rbx, %rax
negq %rax
cmpq $0x2d, %r14
movq -0x48(%rbp), %rcx
movq %r15, (%rcx)
cmovneq %rbx, %rax
jmp 0x4bbe4
movq -0x40(%rbp), %rsi
movq -0x88(%rbp), %r15
movq %r15, %rax
subq %r13, %rax
andq $-0x2, %rax
leaq 0x20dcaa(%rip), %rcx # 0x259b70
movq -0x50(%rbp), %rdx
imulq (%rcx,%rax,4), %rdx
addq %rsi, %rdx
movq %rdx, %rax
negq %rax
cmpq $0x2d, %r14
movq -0x48(%rbp), %rcx
movq %r15, (%rcx)
cmovneq %rdx, %rax
jmp 0x4bbe4
cmpq $0x12, %rbx
jne 0x4beb5
imulq $0x3b9aca00, -0x50(%rbp), %rax # imm = 0x3B9ACA00
addq %rax, %rsi
movq %rsi, %rax
negq %rax
cmpq $0x2d, %r14
movq -0x48(%rbp), %rcx
movq %r8, (%rcx)
cmovneq %rsi, %rax
jmp 0x4bbe4
movabsq $0x2540be400, %rax # imm = 0x2540BE400
movq -0x50(%rbp), %rcx
imulq %rax, %rcx
leaq (%rsi,%rsi,4), %rax
leaq (%rcx,%rax,2), %rax
addq %r13, %rax
movq -0x48(%rbp), %rcx
movq %r8, (%rcx)
cmpq $0x2d, %r14
jne 0x4bbe4
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, %rax
jbe 0x4bf74
xorl %eax, %eax
cmpq $0x2d, %r14
setne %al
movq -0x60(%rbp), %rcx
movl $0x22, (%rcx)
negq %rax
btsq $0x3f, %rax
jmp 0x4bbe4
negq %rax
jmp 0x4bbe4
movq -0x50(%rbp), %rdx
cmpq -0x58(%rbp), %rdx
ja 0x4bf54
leaq (,%r13,4), %rax
addq %r13, %rax
movzbl %bl, %ecx
leaq (%rcx,%rax,2), %rax
cmpq -0x58(%rbp), %rdx
jne 0x4bfae
movq -0x40(%rbp), %rcx
cmpq -0x78(%rbp), %rcx
jb 0x4bfae
cmpq -0x70(%rbp), %rax
ja 0x4bf54
movabsq $0x174876e800, %rcx # imm = 0x174876E800
imulq %rcx, %rdx
imulq $0x64, -0x40(%rbp), %rcx
addq %rax, %rdx
addq %rcx, %rdx
movq %rdx, %rax
jmp 0x4bbe4
| my_strtoll10_mb2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rbp+var_60], rcx
mov [rbp+var_68], rsi
mov [rbp+var_48], rdx
test rdx, rdx
jz short loc_4BBCD
mov r12, rdi
mov rax, [rdi+0B8h]
mov r8, [rax+28h]
mov rax, [rbp+var_48]
mov rax, [rax]
mov rdx, [rbp+var_68]
sub rax, rdx
mov r15, rax
shr r15, 3Fh
add r15, rax
and r15, 0FFFFFFFFFFFFFFFEh
add r15, rdx
lea rsi, [rbp+var_30]
mov rcx, r15
mov [rbp+var_38], r8
call r8
test eax, eax
jle short loc_4BBCD
lea rbx, [rbp+var_30]
mov r13, [rbp+var_68]
loc_4BBA1:
mov rcx, r13
mov r13d, eax
add r13, rcx
mov r14, [rbp+var_30]
cmp r14, 20h ; ' '
jz short loc_4BBBA
cmp r14, 9
jnz short loc_4BBF3
loc_4BBBA:
mov rdi, r12
mov rsi, rbx
mov rdx, r13
mov rcx, r15
call [rbp+var_38]
test eax, eax
jg short loc_4BBA1
loc_4BBCD:
mov rax, [rbp+var_60]
mov dword ptr [rax], 21h ; '!'
mov rax, [rbp+var_48]
mov rcx, [rbp+var_68]
mov [rax], rcx
xor eax, eax
loc_4BBE4:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4BBF3:
cmp r14, 2Dh ; '-'
jnz short loc_4BC39
mov rax, [rbp+var_60]
mov dword ptr [rax], 0FFFFFFFFh
lea rsi, [rbp+var_30]
mov rdi, r12
mov rdx, r13
mov rcx, r15
call [rbp+var_38]
test eax, eax
jle short loc_4BBCD
mov eax, eax
add r13, rax
mov eax, 8
mov [rbp+var_70], rax
mov eax, 15F797AEh
mov [rbp+var_78], rax
mov eax, 57F5FF8h
mov [rbp+var_58], rax
jmp short loc_4BC81
loc_4BC39:
mov rax, [rbp+var_60]
mov dword ptr [rax], 0
mov eax, 0Fh
mov [rbp+var_70], rax
mov eax, 2BEF2F5Ch
mov [rbp+var_78], rax
mov eax, 0AFEBFF0h
mov [rbp+var_58], rax
cmp r14, 2Bh ; '+'
jnz short loc_4BC81
lea rsi, [rbp+var_30]
mov rdi, r12
mov rdx, r13
mov rcx, r15
call [rbp+var_38]
test eax, eax
jle loc_4BBCD
mov eax, eax
add r13, rax
loc_4BC81:
mov rax, [rbp+var_30]
cmp rax, 30h ; '0'
jnz short loc_4BCC3
cmp r13, r15
jz short loc_4BCBC
lea rbx, [rbp+var_30]
loc_4BC94:
mov rdi, r12
mov rsi, rbx
mov rdx, r13
mov rcx, r15
call [rbp+var_38]
test eax, eax
jle loc_4BBCD
cmp [rbp+var_30], 30h ; '0'
jnz short loc_4BCDA
mov eax, eax
add r13, rax
cmp r13, r15
jnz short loc_4BC94
loc_4BCBC:
xor ebx, ebx
jmp loc_4BE90
loc_4BCC3:
add rax, 0FFFFFFFFFFFFFFD0h
cmp rax, 9
ja loc_4BBCD
mov rbx, rax
lea rcx, [r13+10h]
jmp short loc_4BCE0
loc_4BCDA:
lea rcx, [r13+12h]
xor ebx, ebx
loc_4BCE0:
cmp rcx, r15
cmova rcx, r15
lea rsi, [rbp+var_30]
mov rdi, r12
mov rdx, r13
mov [rbp+var_40], rcx
loc_4BCF5:
call [rbp+var_38]
test eax, eax
jle short loc_4BD36
mov rcx, [rbp+var_30]
cmp rcx, 39h ; '9'
ja loc_4BE8D
add cl, 0D0h
cmp cl, 9
ja loc_4BE8D
lea rdx, [rbx+rbx*4]
movzx ecx, cl
lea rbx, [rcx+rdx*2]
mov eax, eax
add r13, rax
mov rdi, r12
lea rsi, [rbp+var_30]
mov rdx, r13
mov rcx, [rbp+var_40]
jmp short loc_4BCF5
loc_4BD36:
cmp r13, r15
jz loc_4BE90
mov [rbp+var_50], rbx
lea rax, [r13+12h]
cmp rax, r15
cmova rax, r15
mov [rbp+var_80], rax
xor ebx, ebx
xor esi, esi
loc_4BD56:
mov [rbp+var_40], rsi
lea rdx, [rbx+r13]
mov rdi, r12
lea rsi, [rbp+var_30]
mov [rbp+var_88], rdx
mov rcx, r15
call [rbp+var_38]
test eax, eax
jle loc_4BBCD
mov rcx, [rbp+var_30]
cmp rcx, 39h ; '9'
ja loc_4BEAA
add cl, 0D0h
cmp cl, 9
mov rsi, [rbp+var_40]
ja loc_4BEAE
mov eax, eax
add rbx, rax
lea r8, [rbx+r13]
lea rax, [rsi+rsi*4]
movzx ecx, cl
lea rsi, [rcx+rax*2]
cmp r8, [rbp+var_80]
jnz short loc_4BD56
cmp [rbp+var_80], r15
jz loc_4BEEC
mov [rbp+var_40], rsi
lea rsi, [rbp+var_30]
mov rdi, r12
mov rbx, r8
mov rdx, r8
mov rcx, r15
call [rbp+var_38]
test eax, eax
jle loc_4BBCD
mov r13, [rbp+var_30]
add r13, 0FFFFFFFFFFFFFFD0h
cmp r13, 9
mov rsi, [rbp+var_40]
mov r8, rbx
ja loc_4BEF2
mov eax, eax
add r8, rax
cmp r8, r15
jz loc_4BF17
lea rsi, [rbp+var_30]
mov rdi, r12
mov rbx, r8
mov rdx, r8
mov rcx, r15
call [rbp+var_38]
test eax, eax
jle loc_4BBCD
mov rcx, [rbp+var_30]
cmp rcx, 39h ; '9'
mov rsi, [rbp+var_40]
mov r8, rbx
ja loc_4BF17
add cl, 0D0h
cmp cl, 9
ja loc_4BF17
mov rbx, rcx
mov eax, eax
add r8, rax
mov rax, [rbp+var_48]
mov [rax], r8
cmp r8, r15
jz loc_4BF7C
mov rdx, r8
lea rsi, [rbp+var_30]
mov rdi, r12
mov rcx, r15
call [rbp+var_38]
test eax, eax
jle loc_4BF7C
mov eax, 0D0h
add eax, dword ptr [rbp+var_30]
and eax, 0FEh
cmp eax, 0Ah
mov rdx, [rbp+var_50]
jnb loc_4BF80
jmp loc_4BF54
loc_4BE8D:
mov r15, r13
loc_4BE90:
mov rax, rbx
neg rax
cmp r14, 2Dh ; '-'
mov rcx, [rbp+var_48]
mov [rcx], r15
cmovnz rax, rbx
jmp loc_4BBE4
loc_4BEAA:
mov rsi, [rbp+var_40]
loc_4BEAE:
mov r15, [rbp+var_88]
loc_4BEB5:
mov rax, r15
sub rax, r13
and rax, 0FFFFFFFFFFFFFFFEh
lea rcx, lfactor
mov rdx, [rbp+var_50]
imul rdx, [rcx+rax*4]
add rdx, rsi
mov rax, rdx
neg rax
cmp r14, 2Dh ; '-'
mov rcx, [rbp+var_48]
mov [rcx], r15
cmovnz rax, rdx
jmp loc_4BBE4
loc_4BEEC:
cmp rbx, 12h
jnz short loc_4BEB5
loc_4BEF2:
imul rax, [rbp+var_50], 3B9ACA00h
add rsi, rax
mov rax, rsi
neg rax
cmp r14, 2Dh ; '-'
mov rcx, [rbp+var_48]
mov [rcx], r8
cmovnz rax, rsi
jmp loc_4BBE4
loc_4BF17:
mov rax, 2540BE400h
mov rcx, [rbp+var_50]
imul rcx, rax
lea rax, [rsi+rsi*4]
lea rax, [rcx+rax*2]
add rax, r13
mov rcx, [rbp+var_48]
mov [rcx], r8
cmp r14, 2Dh ; '-'
jnz loc_4BBE4
mov rcx, 8000000000000000h
cmp rax, rcx
jbe short loc_4BF74
loc_4BF54:
xor eax, eax
cmp r14, 2Dh ; '-'
setnz al
mov rcx, [rbp+var_60]
mov dword ptr [rcx], 22h ; '"'
neg rax
bts rax, 3Fh ; '?'
jmp loc_4BBE4
loc_4BF74:
neg rax
jmp loc_4BBE4
loc_4BF7C:
mov rdx, [rbp+var_50]
loc_4BF80:
cmp rdx, [rbp+var_58]
ja short loc_4BF54
lea rax, ds:0[r13*4]
add rax, r13
movzx ecx, bl
lea rax, [rcx+rax*2]
cmp rdx, [rbp+var_58]
jnz short loc_4BFAE
mov rcx, [rbp+var_40]
cmp rcx, [rbp+var_78]
jb short loc_4BFAE
cmp rax, [rbp+var_70]
ja short loc_4BF54
loc_4BFAE:
mov rcx, 174876E800h
imul rdx, rcx
imul rcx, [rbp+var_40], 64h ; 'd'
add rdx, rax
add rdx, rcx
mov rax, rdx
jmp loc_4BBE4
| unsigned long long my_strtoll10_mb2(long long a1, long long a2, unsigned long long *a3, _DWORD *a4)
{
long long v4; // r12
unsigned long long v5; // r15
int v6; // eax
unsigned long long v7; // r13
long long v8; // r14
unsigned long long result; // rax
int v10; // eax
int v11; // eax
int v12; // eax
long long v13; // rbx
unsigned long long i; // rdx
int v15; // eax
unsigned long long v16; // rax
long long v17; // rbx
long long v18; // rsi
int v19; // eax
unsigned long long v20; // r8
unsigned long long v21; // rbx
int v22; // eax
long long v23; // r13
unsigned long long v24; // r8
unsigned long long v25; // rbx
int v26; // eax
unsigned __int8 v27; // bl
unsigned long long v28; // r8
unsigned long long v29; // rdx
long long v30; // rdx
long long v31; // rsi
unsigned long long v32; // rax
unsigned long long v33; // [rsp+10h] [rbp-80h]
unsigned long long v34; // [rsp+18h] [rbp-78h]
unsigned long long v35; // [rsp+20h] [rbp-70h]
unsigned long long v38; // [rsp+38h] [rbp-58h]
long long v39; // [rsp+40h] [rbp-50h]
long long v41; // [rsp+50h] [rbp-40h]
unsigned long long v42; // [rsp+50h] [rbp-40h]
long long ( *v43)(long long, _QWORD *, long long, unsigned long long); // [rsp+58h] [rbp-38h]
_QWORD v44[6]; // [rsp+60h] [rbp-30h] BYREF
if ( !a3 )
goto LABEL_7;
v4 = a1;
v5 = a2 + ((*a3 - a2 + ((*a3 - a2) >> 63)) & 0xFFFFFFFFFFFFFFFELL);
v43 = *(long long ( **)(long long, _QWORD *, long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 40LL);
v6 = v43(a1, v44, a2, v5);
if ( v6 <= 0 )
goto LABEL_7;
v7 = a2;
while ( 1 )
{
v7 += (unsigned int)v6;
v8 = v44[0];
if ( v44[0] != 32LL && v44[0] != 9LL )
break;
v6 = v43(a1, v44, v7, v5);
if ( v6 <= 0 )
goto LABEL_7;
}
if ( v44[0] == 45LL )
{
*a4 = -1;
v10 = v43(a1, v44, v7, v5);
if ( v10 <= 0 )
goto LABEL_7;
v7 += (unsigned int)v10;
v35 = 8LL;
v34 = 368547758LL;
v38 = 92233720LL;
}
else
{
*a4 = 0;
v35 = 15LL;
v34 = 737095516LL;
v38 = 184467440LL;
if ( v8 == 43 )
{
v11 = v43(a1, v44, v7, v5);
if ( v11 <= 0 )
goto LABEL_7;
v7 += (unsigned int)v11;
}
}
if ( v44[0] == 48LL )
{
if ( v7 == v5 )
{
LABEL_20:
v13 = 0LL;
goto LABEL_49;
}
while ( 1 )
{
v12 = v43(a1, v44, v7, v5);
if ( v12 <= 0 )
goto LABEL_7;
if ( v44[0] != 48LL )
break;
v7 += (unsigned int)v12;
if ( v7 == v5 )
goto LABEL_20;
}
v13 = 0LL;
goto LABEL_24;
}
if ( (unsigned long long)(v44[0] - 48LL) > 9 )
{
LABEL_7:
*a4 = 33;
*a3 = a2;
return 0LL;
}
v13 = v44[0] - 48LL;
LABEL_24:
for ( i = v7; ; i = v7 )
{
v15 = ((long long ( *)(long long, _QWORD *, unsigned long long))v43)(a1, v44, i);
if ( v15 <= 0 )
break;
if ( v44[0] > 0x39uLL || (unsigned __int8)(LOBYTE(v44[0]) - 48) > 9u )
{
v5 = v7;
LABEL_49:
result = -v13;
*a3 = v5;
if ( v8 != 45 )
return v13;
return result;
}
v13 = (unsigned __int8)(LOBYTE(v44[0]) - 48) + 10 * v13;
v7 += (unsigned int)v15;
a1 = v4;
}
if ( v7 == v5 )
goto LABEL_49;
v39 = v13;
v16 = v7 + 18;
if ( v7 + 18 > v5 )
v16 = v5;
v33 = v16;
v17 = 0LL;
v18 = 0LL;
do
{
v41 = v18;
v19 = v43(v4, v44, v17 + v7, v5);
if ( v19 <= 0 )
goto LABEL_7;
if ( v44[0] > 0x39uLL || (unsigned __int8)(LOBYTE(v44[0]) - 48) > 9u )
{
v5 = v17 + v7;
goto LABEL_53;
}
v17 += (unsigned int)v19;
v20 = v17 + v7;
v18 = (unsigned __int8)(LOBYTE(v44[0]) - 48) + 10 * v18;
}
while ( v17 + v7 != v33 );
if ( v33 == v5 )
{
if ( v17 == 18 )
{
LABEL_57:
v31 = 1000000000 * v39 + v18;
result = -v31;
*a3 = v20;
if ( v8 != 45 )
return v31;
return result;
}
LABEL_53:
v30 = v18 + *(_QWORD *)((char *)&lfactor + 4 * ((v5 - v7) & 0xFFFFFFFFFFFFFFFELL)) * v39;
result = -v30;
*a3 = v5;
if ( v8 != 45 )
return v30;
return result;
}
v42 = (unsigned __int8)(LOBYTE(v44[0]) - 48) + 10 * v41;
v21 = v17 + v7;
v22 = v43(v4, v44, v20, v5);
if ( v22 <= 0 )
goto LABEL_7;
v23 = v44[0] - 48LL;
v20 = v21;
if ( (unsigned long long)(v44[0] - 48LL) > 9 )
goto LABEL_57;
v24 = (unsigned int)v22 + v21;
if ( v24 == v5 )
goto LABEL_60;
v25 = (unsigned int)v22 + v21;
v26 = v43(v4, v44, v24, v5);
if ( v26 <= 0 )
goto LABEL_7;
v24 = v25;
if ( v44[0] > 0x39uLL || (unsigned __int8)(LOBYTE(v44[0]) - 48) > 9u )
{
LABEL_60:
result = v23 + 10000000000LL * v39 + 10 * v18;
*a3 = v24;
if ( v8 != 45 )
return result;
if ( result > 0x8000000000000000LL )
goto LABEL_62;
return -(long long)result;
}
else
{
v27 = LOBYTE(v44[0]) - 48;
v28 = (unsigned int)v26 + v24;
*a3 = v28;
if ( v28 == v5 || (int)v43(v4, v44, v28, v5) <= 0 )
{
v29 = v39;
}
else
{
v29 = v39;
if ( ((LOBYTE(v44[0]) - 48) & 0xFEu) < 0xA )
{
LABEL_62:
*a4 = 34;
return -(long long)(v8 != 45) | 0x8000000000000000LL;
}
}
if ( v29 > v38 )
goto LABEL_62;
v32 = v27 + 10 * v23;
if ( v29 == v38 && v42 >= v34 && v32 > v35 )
goto LABEL_62;
return 100 * v42 + v32 + 100000000000LL * v29;
}
}
| my_strtoll10_mb2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x60],RCX
MOV qword ptr [RBP + -0x68],RSI
MOV qword ptr [RBP + -0x48],RDX
TEST RDX,RDX
JZ 0x0014bbcd
MOV R12,RDI
MOV RAX,qword ptr [RDI + 0xb8]
MOV R8,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x68]
SUB RAX,RDX
MOV R15,RAX
SHR R15,0x3f
ADD R15,RAX
AND R15,-0x2
ADD R15,RDX
LEA RSI,[RBP + -0x30]
MOV RCX,R15
MOV qword ptr [RBP + -0x38],R8
CALL R8
TEST EAX,EAX
JLE 0x0014bbcd
LEA RBX,[RBP + -0x30]
MOV R13,qword ptr [RBP + -0x68]
LAB_0014bba1:
MOV RCX,R13
MOV R13D,EAX
ADD R13,RCX
MOV R14,qword ptr [RBP + -0x30]
CMP R14,0x20
JZ 0x0014bbba
CMP R14,0x9
JNZ 0x0014bbf3
LAB_0014bbba:
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R13
MOV RCX,R15
CALL qword ptr [RBP + -0x38]
TEST EAX,EAX
JG 0x0014bba1
LAB_0014bbcd:
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX],0x21
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX],RCX
XOR EAX,EAX
LAB_0014bbe4:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014bbf3:
CMP R14,0x2d
JNZ 0x0014bc39
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX],0xffffffff
LEA RSI,[RBP + -0x30]
MOV RDI,R12
MOV RDX,R13
MOV RCX,R15
CALL qword ptr [RBP + -0x38]
TEST EAX,EAX
JLE 0x0014bbcd
MOV EAX,EAX
ADD R13,RAX
MOV EAX,0x8
MOV qword ptr [RBP + -0x70],RAX
MOV EAX,0x15f797ae
MOV qword ptr [RBP + -0x78],RAX
MOV EAX,0x57f5ff8
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0014bc81
LAB_0014bc39:
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX],0x0
MOV EAX,0xf
MOV qword ptr [RBP + -0x70],RAX
MOV EAX,0x2bef2f5c
MOV qword ptr [RBP + -0x78],RAX
MOV EAX,0xafebff0
MOV qword ptr [RBP + -0x58],RAX
CMP R14,0x2b
JNZ 0x0014bc81
LEA RSI,[RBP + -0x30]
MOV RDI,R12
MOV RDX,R13
MOV RCX,R15
CALL qword ptr [RBP + -0x38]
TEST EAX,EAX
JLE 0x0014bbcd
MOV EAX,EAX
ADD R13,RAX
LAB_0014bc81:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,0x30
JNZ 0x0014bcc3
CMP R13,R15
JZ 0x0014bcbc
LEA RBX,[RBP + -0x30]
LAB_0014bc94:
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R13
MOV RCX,R15
CALL qword ptr [RBP + -0x38]
TEST EAX,EAX
JLE 0x0014bbcd
CMP qword ptr [RBP + -0x30],0x30
JNZ 0x0014bcda
MOV EAX,EAX
ADD R13,RAX
CMP R13,R15
JNZ 0x0014bc94
LAB_0014bcbc:
XOR EBX,EBX
JMP 0x0014be90
LAB_0014bcc3:
ADD RAX,-0x30
CMP RAX,0x9
JA 0x0014bbcd
MOV RBX,RAX
LEA RCX,[R13 + 0x10]
JMP 0x0014bce0
LAB_0014bcda:
LEA RCX,[R13 + 0x12]
XOR EBX,EBX
LAB_0014bce0:
CMP RCX,R15
CMOVA RCX,R15
LEA RSI,[RBP + -0x30]
MOV RDI,R12
MOV RDX,R13
MOV qword ptr [RBP + -0x40],RCX
LAB_0014bcf5:
CALL qword ptr [RBP + -0x38]
TEST EAX,EAX
JLE 0x0014bd36
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,0x39
JA 0x0014be8d
ADD CL,0xd0
CMP CL,0x9
JA 0x0014be8d
LEA RDX,[RBX + RBX*0x4]
MOVZX ECX,CL
LEA RBX,[RCX + RDX*0x2]
MOV EAX,EAX
ADD R13,RAX
MOV RDI,R12
LEA RSI,[RBP + -0x30]
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0x40]
JMP 0x0014bcf5
LAB_0014bd36:
CMP R13,R15
JZ 0x0014be90
MOV qword ptr [RBP + -0x50],RBX
LEA RAX,[R13 + 0x12]
CMP RAX,R15
CMOVA RAX,R15
MOV qword ptr [RBP + -0x80],RAX
XOR EBX,EBX
XOR ESI,ESI
LAB_0014bd56:
MOV qword ptr [RBP + -0x40],RSI
LEA RDX,[RBX + R13*0x1]
MOV RDI,R12
LEA RSI,[RBP + -0x30]
MOV qword ptr [RBP + -0x88],RDX
MOV RCX,R15
CALL qword ptr [RBP + -0x38]
TEST EAX,EAX
JLE 0x0014bbcd
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,0x39
JA 0x0014beaa
ADD CL,0xd0
CMP CL,0x9
MOV RSI,qword ptr [RBP + -0x40]
JA 0x0014beae
MOV EAX,EAX
ADD RBX,RAX
LEA R8,[RBX + R13*0x1]
LEA RAX,[RSI + RSI*0x4]
MOVZX ECX,CL
LEA RSI,[RCX + RAX*0x2]
CMP R8,qword ptr [RBP + -0x80]
JNZ 0x0014bd56
CMP qword ptr [RBP + -0x80],R15
JZ 0x0014beec
MOV qword ptr [RBP + -0x40],RSI
LEA RSI,[RBP + -0x30]
MOV RDI,R12
MOV RBX,R8
MOV RDX,R8
MOV RCX,R15
CALL qword ptr [RBP + -0x38]
TEST EAX,EAX
JLE 0x0014bbcd
MOV R13,qword ptr [RBP + -0x30]
ADD R13,-0x30
CMP R13,0x9
MOV RSI,qword ptr [RBP + -0x40]
MOV R8,RBX
JA 0x0014bef2
MOV EAX,EAX
ADD R8,RAX
CMP R8,R15
JZ 0x0014bf17
LEA RSI,[RBP + -0x30]
MOV RDI,R12
MOV RBX,R8
MOV RDX,R8
MOV RCX,R15
CALL qword ptr [RBP + -0x38]
TEST EAX,EAX
JLE 0x0014bbcd
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,0x39
MOV RSI,qword ptr [RBP + -0x40]
MOV R8,RBX
JA 0x0014bf17
ADD CL,0xd0
CMP CL,0x9
JA 0x0014bf17
MOV RBX,RCX
MOV EAX,EAX
ADD R8,RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX],R8
CMP R8,R15
JZ 0x0014bf7c
MOV RDX,R8
LEA RSI,[RBP + -0x30]
MOV RDI,R12
MOV RCX,R15
CALL qword ptr [RBP + -0x38]
TEST EAX,EAX
JLE 0x0014bf7c
MOV EAX,0xd0
ADD EAX,dword ptr [RBP + -0x30]
AND EAX,0xfe
CMP EAX,0xa
MOV RDX,qword ptr [RBP + -0x50]
JNC 0x0014bf80
JMP 0x0014bf54
LAB_0014be8d:
MOV R15,R13
LAB_0014be90:
MOV RAX,RBX
NEG RAX
CMP R14,0x2d
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RCX],R15
CMOVNZ RAX,RBX
JMP 0x0014bbe4
LAB_0014beaa:
MOV RSI,qword ptr [RBP + -0x40]
LAB_0014beae:
MOV R15,qword ptr [RBP + -0x88]
LAB_0014beb5:
MOV RAX,R15
SUB RAX,R13
AND RAX,-0x2
LEA RCX,[0x359b70]
MOV RDX,qword ptr [RBP + -0x50]
IMUL RDX,qword ptr [RCX + RAX*0x4]
ADD RDX,RSI
MOV RAX,RDX
NEG RAX
CMP R14,0x2d
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RCX],R15
CMOVNZ RAX,RDX
JMP 0x0014bbe4
LAB_0014beec:
CMP RBX,0x12
JNZ 0x0014beb5
LAB_0014bef2:
IMUL RAX,qword ptr [RBP + -0x50],0x3b9aca00
ADD RSI,RAX
MOV RAX,RSI
NEG RAX
CMP R14,0x2d
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RCX],R8
CMOVNZ RAX,RSI
JMP 0x0014bbe4
LAB_0014bf17:
MOV RAX,0x2540be400
MOV RCX,qword ptr [RBP + -0x50]
IMUL RCX,RAX
LEA RAX,[RSI + RSI*0x4]
LEA RAX,[RCX + RAX*0x2]
ADD RAX,R13
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RCX],R8
CMP R14,0x2d
JNZ 0x0014bbe4
MOV RCX,-0x8000000000000000
CMP RAX,RCX
JBE 0x0014bf74
LAB_0014bf54:
XOR EAX,EAX
CMP R14,0x2d
SETNZ AL
MOV RCX,qword ptr [RBP + -0x60]
MOV dword ptr [RCX],0x22
NEG RAX
BTS RAX,0x3f
JMP 0x0014bbe4
LAB_0014bf74:
NEG RAX
JMP 0x0014bbe4
LAB_0014bf7c:
MOV RDX,qword ptr [RBP + -0x50]
LAB_0014bf80:
CMP RDX,qword ptr [RBP + -0x58]
JA 0x0014bf54
LEA RAX,[R13*0x4]
ADD RAX,R13
MOVZX ECX,BL
LEA RAX,[RCX + RAX*0x2]
CMP RDX,qword ptr [RBP + -0x58]
JNZ 0x0014bfae
MOV RCX,qword ptr [RBP + -0x40]
CMP RCX,qword ptr [RBP + -0x78]
JC 0x0014bfae
CMP RAX,qword ptr [RBP + -0x70]
JA 0x0014bf54
LAB_0014bfae:
MOV RCX,0x174876e800
IMUL RDX,RCX
IMUL RCX,qword ptr [RBP + -0x40],0x64
ADD RDX,RAX
ADD RDX,RCX
MOV RAX,RDX
JMP 0x0014bbe4
|
ulong my_strtoll10_mb2(long param_1,ulong param_2,ulong *param_3,int4 *param_4)
{
code *pcVar1;
long lVar2;
uint uVar3;
int iVar4;
ulong uVar5;
ulong uVar6;
byte bVar7;
long lVar8;
ulong uVar9;
ulong uVar10;
ulong uVar11;
ulong uVar12;
ulong uVar13;
ulong local_80;
ulong local_78;
ulong local_60;
int local_38;
int4 uStack_34;
if (param_3 != (ulong *)0x0) {
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
uVar12 = ((*param_3 - param_2) - ((long)(*param_3 - param_2) >> 0x3f) & 0xfffffffffffffffe) +
param_2;
uVar3 = (*pcVar1)(param_1,&local_38,param_2,uVar12);
if (0 < (int)uVar3) {
uVar11 = param_2;
do {
uVar11 = uVar3 + uVar11;
lVar2 = CONCAT44(uStack_34,local_38);
if ((lVar2 != 0x20) && (lVar2 != 9)) {
if (lVar2 == 0x2d) {
*param_4 = 0xffffffff;
uVar3 = (*pcVar1)(param_1,&local_38,uVar11,uVar12);
if ((int)uVar3 < 1) break;
uVar11 = uVar11 + uVar3;
local_78 = 8;
local_80 = 0x15f797ae;
local_60 = 0x57f5ff8;
}
else {
*param_4 = 0;
local_78 = 0xf;
local_80 = 0x2bef2f5c;
local_60 = 0xafebff0;
if (lVar2 == 0x2b) {
uVar3 = (*pcVar1)(param_1,&local_38,uVar11,uVar12);
if ((int)uVar3 < 1) break;
uVar11 = uVar11 + uVar3;
}
}
if (CONCAT44(uStack_34,local_38) == 0x30) {
if (uVar11 == uVar12) goto LAB_0014bcbc;
goto LAB_0014bc94;
}
uVar5 = CONCAT44(uStack_34,local_38) - 0x30;
if (uVar5 < 10) {
uVar9 = uVar11 + 0x10;
goto LAB_0014bce0;
}
break;
}
uVar3 = (*pcVar1)(param_1,&local_38,uVar11,uVar12);
} while (0 < (int)uVar3);
}
}
LAB_0014bbcd:
*param_4 = 0x21;
*param_3 = param_2;
return 0;
LAB_0014bc94:
uVar3 = (*pcVar1)(param_1,&local_38,uVar11,uVar12);
if ((int)uVar3 < 1) goto LAB_0014bbcd;
if (CONCAT44(uStack_34,local_38) != 0x30) {
uVar9 = uVar11 + 0x12;
uVar5 = 0;
LAB_0014bce0:
if (uVar12 < uVar9) {
uVar9 = uVar12;
}
while (uVar3 = (*pcVar1)(param_1,&local_38,uVar11,uVar9), 0 < (int)uVar3) {
uVar6 = uVar11;
if ((0x39 < CONCAT44(uStack_34,local_38)) || (bVar7 = (char)local_38 - 0x30, 9 < bVar7))
goto LAB_0014be90;
uVar5 = (ulong)bVar7 + uVar5 * 10;
uVar11 = uVar11 + uVar3;
}
uVar6 = uVar12;
if (uVar11 == uVar12) goto LAB_0014be90;
uVar6 = uVar11 + 0x12;
if (uVar12 < uVar11 + 0x12) {
uVar6 = uVar12;
}
lVar8 = 0;
uVar9 = 0;
while( true ) {
uVar13 = lVar8 + uVar11;
uVar3 = (*pcVar1)(param_1,&local_38,uVar13,uVar12);
if ((int)uVar3 < 1) break;
if ((0x39 < CONCAT44(uStack_34,local_38)) || (bVar7 = (char)local_38 - 0x30, 9 < bVar7)) {
LAB_0014beb5:
uVar9 = uVar5 * *(long *)((long)&lfactor + (uVar13 - uVar11 & 0xfffffffffffffffe) * 4) +
uVar9;
*param_3 = uVar13;
if (lVar2 == 0x2d) {
return -uVar9;
}
return uVar9;
}
lVar8 = lVar8 + (ulong)uVar3;
uVar10 = lVar8 + uVar11;
uVar9 = (ulong)bVar7 + uVar9 * 10;
if (uVar10 == uVar6) {
if (uVar6 == uVar12) {
uVar13 = uVar12;
if (lVar8 == 0x12) {
LAB_0014bef2:
uVar9 = uVar9 + uVar5 * 1000000000;
*param_3 = uVar10;
if (lVar2 == 0x2d) {
return -uVar9;
}
return uVar9;
}
goto LAB_0014beb5;
}
uVar3 = (*pcVar1)(param_1,&local_38,uVar10,uVar12);
if ((int)uVar3 < 1) break;
uVar11 = CONCAT44(uStack_34,local_38) - 0x30;
if (9 < uVar11) goto LAB_0014bef2;
uVar10 = uVar10 + uVar3;
if (uVar10 != uVar12) {
uVar3 = (*pcVar1)(param_1,&local_38,uVar10,uVar12);
if ((int)uVar3 < 1) break;
if ((CONCAT44(uStack_34,local_38) < 0x3a) && (bVar7 = (char)local_38 - 0x30, bVar7 < 10))
{
uVar10 = uVar10 + uVar3;
*param_3 = uVar10;
if ((((uVar10 == uVar12) ||
(iVar4 = (*pcVar1)(param_1,&local_38,uVar10,uVar12), iVar4 < 1)) ||
(9 < (local_38 + 0xd0U & 0xfe))) &&
((uVar5 <= local_60 &&
(((uVar12 = (ulong)bVar7 + uVar11 * 10, uVar5 != local_60 || (uVar9 < local_80)) ||
(uVar12 <= local_78)))))) {
return uVar5 * 100000000000 + uVar12 + uVar9 * 100;
}
goto LAB_0014bf54;
}
}
uVar11 = uVar5 * 10000000000 + uVar9 * 10 + uVar11;
*param_3 = uVar10;
if (lVar2 != 0x2d) {
return uVar11;
}
if (uVar11 < 0x8000000000000001) {
return -uVar11;
}
LAB_0014bf54:
*param_4 = 0x22;
return -(ulong)(lVar2 != 0x2d) | 0x8000000000000000;
}
}
goto LAB_0014bbcd;
}
uVar11 = uVar11 + uVar3;
if (uVar11 == uVar12) {
LAB_0014bcbc:
uVar5 = 0;
uVar6 = uVar12;
LAB_0014be90:
*param_3 = uVar6;
if (lVar2 == 0x2d) {
return -uVar5;
}
return uVar5;
}
goto LAB_0014bc94;
}
| |
25,935 | wt_init | eloqsql/mysys/waiting_threads.c | void wt_init()
{
DBUG_ENTER("wt_init");
DBUG_ASSERT(reshash.alloc.constructor != wt_resource_create);
lf_hash_init(&reshash, sizeof(WT_RESOURCE), LF_HASH_UNIQUE, 0,
sizeof_WT_RESOURCE_ID, 0, 0);
reshash.alloc.constructor= wt_resource_create;
reshash.alloc.destructor= wt_resource_destroy;
reshash.initializer= (lf_hash_initializer) wt_resource_init;
bzero(wt_wait_stats, sizeof(wt_wait_stats));
bzero(wt_cycle_stats, sizeof(wt_cycle_stats));
wt_success_stats= 0;
{ /* initialize wt_wait_table[]. from 1 us to 1 min, log e scale */
int i;
double from= log(1); /* 1 us */
double to= log(60e6); /* 1 min */
for (i= 0; i < WT_WAIT_STATS; i++)
{
wt_wait_table[i]= (ulonglong)exp((to-from)/(WT_WAIT_STATS-1)*i+from);
DBUG_ASSERT(i == 0 || wt_wait_table[i-1] != wt_wait_table[i]);
}
}
wt_init_done= 1;
DBUG_VOID_RETURN;
} | O3 | c | wt_init:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, (%rsp)
leaq 0xb669ee(%rip), %rdi # 0xc14be0
xorl %ebx, %ebx
movl $0x108, %esi # imm = 0x108
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x10, %r8d
xorl %r9d, %r9d
callq 0xad50c
leaq 0xc9(%rip), %rax # 0xae2de
movq %rax, 0xb66a44(%rip) # 0xc14c60
leaq 0x155(%rip), %rax # 0xae378
movq %rax, 0xb66a3e(%rip) # 0xc14c68
leaq 0x1b1(%rip), %rax # 0xae3e2
movq %rax, 0xb66a40(%rip) # 0xc14c78
xorpd %xmm0, %xmm0
leaq 0xb66a6d(%rip), %rax # 0xc14cb0
movapd %xmm0, (%rax)
movapd %xmm0, 0x10(%rax)
movapd %xmm0, 0x20(%rax)
movapd %xmm0, 0x30(%rax)
movapd %xmm0, 0x40(%rax)
movapd %xmm0, 0x50(%rax)
movl %ebx, 0x60(%rax)
leaq 0xb66ab6(%rip), %rdi # 0xc14d20
movl $0x108, %edx # imm = 0x108
xorl %esi, %esi
callq 0x2a290
leaq 0xb66bab(%rip), %rax # 0xc14e28
movl %ebx, (%rax)
leaq 0xb66baa(%rip), %r14 # 0xc14e30
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x3bf43(%rip), %xmm0 # 0xea1d8
addsd 0x3bf0b(%rip), %xmm0 # 0xea1a8
callq 0x2a110
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x3bec2(%rip), %xmm0 # 0xea178
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, (%r14,%rbx,8)
incq %rbx
cmpq $0x18, %rbx
jne 0xae286
movb $0x1, 0xb66c1b(%rip) # 0xc14ef0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| wt_init:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov [rsp+20h+var_20], 0
lea rdi, reshash
xor ebx, ebx
mov esi, 108h
mov edx, 1
xor ecx, ecx
mov r8d, 10h
xor r9d, r9d
call lf_hash_init
lea rax, wt_resource_create
mov cs:qword_C14C60, rax
lea rax, wt_resource_destroy
mov cs:qword_C14C68, rax
lea rax, wt_resource_init
mov cs:qword_C14C78, rax
xorpd xmm0, xmm0
lea rax, wt_wait_stats
movapd xmmword ptr [rax], xmm0
movapd xmmword ptr [rax+10h], xmm0
movapd xmmword ptr [rax+20h], xmm0
movapd xmmword ptr [rax+30h], xmm0
movapd xmmword ptr [rax+40h], xmm0
movapd xmmword ptr [rax+50h], xmm0
mov [rax+60h], ebx
lea rdi, wt_cycle_stats
mov edx, 108h
xor esi, esi
call _memset
lea rax, wt_success_stats
mov [rax], ebx
lea r14, wt_wait_table
loc_AE286:
xorps xmm0, xmm0
cvtsi2sd xmm0, ebx
mulsd xmm0, cs:qword_EA1D8
addsd xmm0, cs:qword_EA1A8
call _exp
cvttsd2si rax, xmm0
mov rcx, rax
sar rcx, 3Fh
subsd xmm0, cs:qword_EA178
cvttsd2si rdx, xmm0
and rdx, rcx
or rdx, rax
mov [r14+rbx*8], rdx
inc rbx
cmp rbx, 18h
jnz short loc_AE286
mov cs:wt_init_done, 1
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long wt_init()
{
long long v0; // rbx
long long result; // rax
v0 = 0LL;
lf_hash_init((long long)&reshash, 264, 1, 0, 16, 0LL, 0LL);
qword_C14C60 = (long long)wt_resource_create;
qword_C14C68 = (long long)wt_resource_destroy;
qword_C14C78 = (long long)wt_resource_init;
wt_wait_stats = 0LL;
*((_OWORD *)&wt_wait_stats + 1) = 0LL;
*((_OWORD *)&wt_wait_stats + 2) = 0LL;
*((_OWORD *)&wt_wait_stats + 3) = 0LL;
*((_OWORD *)&wt_wait_stats + 4) = 0LL;
*((_OWORD *)&wt_wait_stats + 5) = 0LL;
*((_DWORD *)&wt_wait_stats + 24) = 0;
memset(&wt_cycle_stats, 0LL, 264LL);
wt_success_stats = 0;
do
{
result = (unsigned int)(int)exp((double)(int)v0 * 0.7786893530515815 + 0.0);
wt_wait_table[v0++] = result;
}
while ( v0 != 24 );
wt_init_done = 1;
return result;
}
| wt_init:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV qword ptr [RSP],0x0
LEA RDI,[0xd14be0]
XOR EBX,EBX
MOV ESI,0x108
MOV EDX,0x1
XOR ECX,ECX
MOV R8D,0x10
XOR R9D,R9D
CALL 0x001ad50c
LEA RAX,[0x1ae2de]
MOV qword ptr [0x00d14c60],RAX
LEA RAX,[0x1ae378]
MOV qword ptr [0x00d14c68],RAX
LEA RAX,[0x1ae3e2]
MOV qword ptr [0x00d14c78],RAX
XORPD XMM0,XMM0
LEA RAX,[0xd14cb0]
MOVAPD xmmword ptr [RAX],XMM0
MOVAPD xmmword ptr [RAX + 0x10],XMM0
MOVAPD xmmword ptr [RAX + 0x20],XMM0
MOVAPD xmmword ptr [RAX + 0x30],XMM0
MOVAPD xmmword ptr [RAX + 0x40],XMM0
MOVAPD xmmword ptr [RAX + 0x50],XMM0
MOV dword ptr [RAX + 0x60],EBX
LEA RDI,[0xd14d20]
MOV EDX,0x108
XOR ESI,ESI
CALL 0x0012a290
LEA RAX,[0xd14e28]
MOV dword ptr [RAX],EBX
LEA R14,[0xd14e30]
LAB_001ae286:
XORPS XMM0,XMM0
CVTSI2SD XMM0,EBX
MULSD XMM0,qword ptr [0x001ea1d8]
ADDSD XMM0,qword ptr [0x001ea1a8]
CALL 0x0012a110
CVTTSD2SI RAX,XMM0
MOV RCX,RAX
SAR RCX,0x3f
SUBSD XMM0,qword ptr [0x001ea178]
CVTTSD2SI RDX,XMM0
AND RDX,RCX
OR RDX,RAX
MOV qword ptr [R14 + RBX*0x8],RDX
INC RBX
CMP RBX,0x18
JNZ 0x001ae286
MOV byte ptr [0x00d14ef0],0x1
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void wt_init(void)
{
double dVar1;
long lVar2;
lVar2 = 0;
lf_hash_init(reshash,0x108,1,0,0x10,0,0);
reshash._128_8_ = wt_resource_create;
reshash._136_8_ = wt_resource_destroy;
reshash._152_8_ = wt_resource_init;
_wt_wait_stats = 0;
uRam0000000000d14cb8 = 0;
_DAT_00d14cc0 = 0;
uRam0000000000d14cc8 = 0;
_DAT_00d14cd0 = 0;
uRam0000000000d14cd8 = 0;
_DAT_00d14ce0 = 0;
uRam0000000000d14ce8 = 0;
_DAT_00d14cf0 = 0;
uRam0000000000d14cf8 = 0;
_DAT_00d14d00 = 0;
uRam0000000000d14d08 = 0;
DAT_00d14d10 = 0;
memset(wt_cycle_stats,0,0x108);
wt_success_stats = 0;
do {
dVar1 = exp((double)(int)lVar2 * _DAT_001ea1d8 + _DAT_001ea1a8);
(&wt_wait_table)[lVar2] = (long)(dVar1 - _DAT_001ea178) & (long)dVar1 >> 0x3f | (long)dVar1;
lVar2 = lVar2 + 1;
} while (lVar2 != 0x18);
wt_init_done = 1;
return;
}
| |
25,936 | string_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::string string_join(const std::vector<std::string> & values, const std::string & separator) {
std::ostringstream result;
for (size_t i = 0; i < values.size(); ++i) {
if (i > 0) {
result << separator;
}
result << values[i];
}
return result.str();
} | O0 | cpp | string_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq %rdx, 0x1b0(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5a050
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x1b8(%rsp), %rdi
callq 0x8ae00
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xea341
cmpq $0x0, 0x30(%rsp)
jbe 0xea30b
movq 0x1b0(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x59520
jmp 0xea2ef
jmp 0xea30b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x59f70
jmp 0xea369
movq 0x1b8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf51e0
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x59520
jmp 0xea32c
jmp 0xea32e
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0xea2af
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5a3c0
jmp 0xea352
leaq 0x38(%rsp), %rdi
callq 0x59f70
movq 0x18(%rsp), %rax
addq $0x1c8, %rsp # imm = 0x1C8
retq
movq 0x28(%rsp), %rdi
callq 0x59b80
nopw %cs:(%rax,%rax)
| _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_:
sub rsp, 1C8h
mov [rsp+1C8h+var_1B8], rdi
mov rax, rdi
mov [rsp+1C8h+var_1B0], rax
mov [rsp+1C8h+var_8], rdi
mov [rsp+1C8h+var_10], rsi
mov [rsp+1C8h+var_18], rdx
lea rdi, [rsp+1C8h+var_190]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov [rsp+1C8h+var_198], 0
loc_EA2AF:
mov rax, [rsp+1C8h+var_198]
mov [rsp+1C8h+var_1C0], rax
mov rdi, [rsp+1C8h+var_10]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rcx, rax
mov rax, [rsp+1C8h+var_1C0]
cmp rax, rcx
jnb short loc_EA341
cmp [rsp+1C8h+var_198], 0
jbe short loc_EA30B
mov rsi, [rsp+1C8h+var_18]
lea rdi, [rsp+1C8h+var_190]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short $+2
loc_EA2EF:
jmp short loc_EA30B
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_30]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
jmp short loc_EA369
loc_EA30B:
mov rdi, [rsp+1C8h+var_10]
mov rsi, [rsp+1C8h+var_198]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rsi, rax
lea rdi, [rsp+1C8h+var_190]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short $+2
loc_EA32C:
jmp short $+2
loc_EA32E:
mov rax, [rsp+1C8h+var_198]
add rax, 1
mov [rsp+1C8h+var_198], rax
jmp loc_EA2AF
loc_EA341:
mov rdi, [rsp+1C8h+var_1B8]
lea rsi, [rsp+1C8h+var_190]
call __ZNKSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEE3strEv; std::ostringstream::str(void)
jmp short $+2
loc_EA352:
lea rdi, [rsp+1C8h+var_190]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, [rsp+1C8h+var_1B0]
add rsp, 1C8h
retn
loc_EA369:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| long long string_join(long long a1, _QWORD *a2, long long a3)
{
long long v3; // rax
unsigned long long i; // [rsp+30h] [rbp-198h]
_BYTE v6[376]; // [rsp+38h] [rbp-190h] BYREF
long long v7; // [rsp+1B0h] [rbp-18h]
_QWORD *v8; // [rsp+1B8h] [rbp-10h]
long long v9; // [rsp+1C0h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
std::ostringstream::basic_ostringstream(v6);
for ( i = 0LL; i < std::vector<std::string>::size(v8); ++i )
{
if ( i )
std::operator<<<char>(v6, v7);
v3 = std::vector<std::string>::operator[](v8, i);
std::operator<<<char>(v6, v3);
}
std::ostringstream::str(a1, v6);
std::ostringstream::~ostringstream(v6);
return a1;
}
| string_join:
SUB RSP,0x1c8
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x1c0],RDI
MOV qword ptr [RSP + 0x1b8],RSI
MOV qword ptr [RSP + 0x1b0],RDX
LEA RDI,[RSP + 0x38]
CALL 0x0015a050
MOV qword ptr [RSP + 0x30],0x0
LAB_001ea2af:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x1b8]
CALL 0x0018ae00
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,RCX
JNC 0x001ea341
CMP qword ptr [RSP + 0x30],0x0
JBE 0x001ea30b
MOV RSI,qword ptr [RSP + 0x1b0]
LAB_001ea2e3:
LEA RDI,[RSP + 0x38]
CALL 0x00159520
JMP 0x001ea2ef
LAB_001ea2ef:
JMP 0x001ea30b
LAB_001ea30b:
MOV RDI,qword ptr [RSP + 0x1b8]
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x001f51e0
MOV RSI,RAX
LEA RDI,[RSP + 0x38]
CALL 0x00159520
JMP 0x001ea32c
LAB_001ea32c:
JMP 0x001ea32e
LAB_001ea32e:
MOV RAX,qword ptr [RSP + 0x30]
ADD RAX,0x1
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001ea2af
LAB_001ea341:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x38]
CALL 0x0015a3c0
LAB_001ea350:
JMP 0x001ea352
LAB_001ea352:
LEA RDI,[RSP + 0x38]
CALL 0x00159f70
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x1c8
RET
|
/* string_join(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > > const&,
std::__cxx11::string const&) */
vector * string_join(vector *param_1,string *param_2)
{
ulong uVar1;
string *psVar2;
string *in_RDX;
ulong local_198;
ostringstream local_190 [376];
string *local_18;
string *local_10;
vector *local_8;
local_18 = in_RDX;
local_10 = param_2;
local_8 = param_1;
std::__cxx11::ostringstream::ostringstream(local_190);
local_198 = 0;
while( true ) {
uVar1 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_10
);
if (uVar1 <= local_198) break;
if (local_198 != 0) {
/* try { // try from 001ea2e3 to 001ea34f has its CatchHandler @ 001ea2f1 */
std::operator<<((ostream *)local_190,local_18);
}
psVar2 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
local_10,local_198);
std::operator<<((ostream *)local_190,psVar2);
local_198 = local_198 + 1;
}
std::__cxx11::ostringstream::str();
std::__cxx11::ostringstream::~ostringstream(local_190);
return param_1;
}
| |
25,937 | string_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::string string_join(const std::vector<std::string> & values, const std::string & separator) {
std::ostringstream result;
for (size_t i = 0; i < values.size(); ++i) {
if (i > 0) {
result << separator;
}
result << values[i];
}
return result.str();
} | O3 | cpp | string_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x1ab30
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x71599
movl $0x8, %r13d
xorl %ebp, %ebp
movq %rsp, %r12
testq %rbp, %rbp
je 0x7156e
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x1a9a0
movq (%r15), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r12, %rdi
callq 0x1a9a0
incq %rbp
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %rcx, %rbp
jb 0x71557
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ad50
movq 0xb89c3(%rip), %rsi # 0x129f70
movq %rsp, %rdi
callq 0x1a480
leaq 0x70(%rsp), %rdi
callq 0x1a2a0
movq %rbx, %rax
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x715d6
movq %rax, %rbx
movq 0xb8990(%rip), %rsi # 0x129f70
movq %rsp, %rdi
callq 0x1a480
leaq 0x70(%rsp), %rdi
callq 0x1a2a0
movq %rbx, %rdi
callq 0x1af20
| _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 178h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rax, [r15]
cmp [r15+8], rax
jz short loc_71599
mov r13d, 8
xor ebp, ebp
mov r12, rsp
loc_71557:
test rbp, rbp
jz short loc_7156E
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, r12
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, [r15]
loc_7156E:
mov rsi, [rax+r13-8]
mov rdx, [rax+r13]
mov rdi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
inc rbp
mov rax, [r15]
mov rcx, [r15+8]
sub rcx, rax
sar rcx, 5
add r13, 20h ; ' '
cmp rbp, rcx
jb short loc_71557
loc_71599:
lea rsi, [rsp+1A8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+1A8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 178h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_715D6:
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_68]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long string_join(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rax
long long v5; // r13
unsigned long long v6; // rbp
long long v8; // [rsp+0h] [rbp-1A8h] BYREF
_BYTE v9[104]; // [rsp+8h] [rbp-1A0h] BYREF
_BYTE v10[312]; // [rsp+70h] [rbp-138h] BYREF
std::ostringstream::basic_ostringstream(&v8);
v4 = *a2;
if ( a2[1] != *a2 )
{
v5 = 8LL;
v6 = 0LL;
do
{
if ( v6 )
{
std::__ostream_insert<char,std::char_traits<char>>(&v8, *a3, a3[1]);
v4 = *a2;
}
std::__ostream_insert<char,std::char_traits<char>>(&v8, *(_QWORD *)(v4 + v5 - 8), *(_QWORD *)(v4 + v5));
++v6;
v4 = *a2;
v5 += 32LL;
}
while ( v6 < (a2[1] - *a2) >> 5 );
}
std::stringbuf::str(a1, v9);
std::ostringstream::~ostringstream(&v8, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v10);
return a1;
}
| string_join:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x178
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDI,RSP
CALL 0x0011ab30
MOV RAX,qword ptr [R15]
CMP qword ptr [R15 + 0x8],RAX
JZ 0x00171599
MOV R13D,0x8
XOR EBP,EBP
MOV R12,RSP
LAB_00171557:
TEST RBP,RBP
JZ 0x0017156e
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
LAB_00171563:
MOV RDI,R12
CALL 0x0011a9a0
MOV RAX,qword ptr [R15]
LAB_0017156e:
MOV RSI,qword ptr [RAX + R13*0x1 + -0x8]
MOV RDX,qword ptr [RAX + R13*0x1]
MOV RDI,R12
CALL 0x0011a9a0
INC RBP
MOV RAX,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
SUB RCX,RAX
SAR RCX,0x5
ADD R13,0x20
CMP RBP,RCX
JC 0x00171557
LAB_00171599:
LEA RSI,[RSP + 0x8]
LAB_0017159e:
MOV RDI,RBX
CALL 0x0011ad50
LAB_001715a6:
MOV RSI,qword ptr [0x00229f70]
MOV RDI,RSP
CALL 0x0011a480
LEA RDI,[RSP + 0x70]
CALL 0x0011a2a0
MOV RAX,RBX
ADD RSP,0x178
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_join(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > > const&,
std::__cxx11::string const&) */
vector * string_join(vector *param_1,string *param_2)
{
long lVar1;
int8 *in_RDX;
ulong uVar2;
long lVar3;
ostringstream aoStack_1a8 [112];
ios_base local_138 [264];
std::__cxx11::ostringstream::ostringstream(aoStack_1a8);
lVar1 = *(long *)param_2;
if (*(long *)(param_2 + 8) != lVar1) {
lVar3 = 8;
uVar2 = 0;
do {
if (uVar2 != 0) {
/* try { // try from 00171563 to 0017157e has its CatchHandler @ 001715d6 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)aoStack_1a8,(char *)*in_RDX,in_RDX[1]);
lVar1 = *(long *)param_2;
}
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)aoStack_1a8,*(char **)(lVar1 + -8 + lVar3),*(long *)(lVar1 + lVar3));
uVar2 = uVar2 + 1;
lVar1 = *(long *)param_2;
lVar3 = lVar3 + 0x20;
} while (uVar2 < (ulong)(*(long *)(param_2 + 8) - lVar1 >> 5));
}
/* try { // try from 0017159e to 001715a5 has its CatchHandler @ 001715d4 */
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(aoStack_1a8);
std::ios_base::~ios_base(local_138);
return param_1;
}
| |
25,938 | pvio_socket_connect_sync_or_async | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | static int
pvio_socket_connect_sync_or_async(MARIADB_PVIO *pvio,
const struct sockaddr *name, uint namelen)
{
MYSQL *mysql= pvio->mysql;
if (mysql->options.extension && mysql->options.extension->async_context &&
mysql->options.extension->async_context->active)
{
/* even if we are not connected yet, application needs to check socket
* via mysql_get_socket api call, so we need to assign pvio */
return pvio_socket_connect_async(pvio, name, namelen);
}
return pvio_socket_internal_connect(pvio, name, namelen);
} | O3 | c | pvio_socket_connect_sync_or_async:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x480(%rax), %rax
testq %rax, %rax
je 0x310ec
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x310ec
cmpb $0x0, 0x14(%rax)
je 0x310ec
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31249
xorl %edi, %edi
callq 0x133e0
movq (%rbx), %r14
testq %r14, %r14
je 0x311b5
movq %rax, %r12
movslq 0x24(%rbx), %r15
movq %rbx, -0x58(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x305c2
movq %r14, -0x50(%rbp)
movl (%r14), %edi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x133a0
movl %eax, %r13d
xorl %edi, %edi
callq 0x133e0
subq %r12, %rax
movq %r15, -0x48(%rbp)
imulq $0x10624dd3, %r15, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
movslq %ecx, %r14
cmpq %r14, %rax
jg 0x311c3
movl $0x1, %ebx
movl %ebx, %edi
callq 0x13670
cmpl $-0x1, %r13d
jne 0x31237
callq 0x13060
movl (%rax), %eax
cmpl $0xb, %eax
je 0x3117d
cmpl $0x4, %eax
jne 0x311bd
leal (%rbx,%rbx), %r15d
movl $0xf4240, %eax # imm = 0xF4240
cmpl %eax, %ebx
cmovael %eax, %r15d
movq -0x50(%rbp), %rax
movl (%rax), %edi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x133a0
movl %eax, %r13d
xorl %edi, %edi
callq 0x133e0
subq %r12, %rax
movl %r15d, %ebx
cmpq %r14, %rax
jle 0x3115b
jmp 0x311c3
movl $0x1, %r13d
jmp 0x31237
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmpl $0x0, -0x48(%rbp)
setne %al
cmpl $-0x1, %r13d
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x31237
callq 0x13060
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmpl $0x73, (%rax)
jne 0x31237
movq %rax, %rbx
movq -0x58(%rbp), %rdi
xorl %esi, %esi
movq -0x48(%rbp), %rdx
callq 0x30508
testl %eax, %eax
jle 0x31237
leaq -0x5c(%rbp), %r8
movl $0x4, (%r8)
movq -0x50(%rbp), %rax
movl (%rax), %edi
leaq -0x3c(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x13320
testl %eax, %eax
js 0x31234
movl %eax, %r13d
movl -0x3c(%rbp), %eax
testl %eax, %eax
cmovnel %eax, %r13d
jmp 0x31237
movl (%rbx), %r13d
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| pvio_socket_connect_sync_or_async:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_2C], edx
mov [rbp+var_38], rsi
mov rbx, rdi
mov rax, [rdi+40h]
mov rax, [rax+480h]
test rax, rax
jz short loc_310EC
mov rax, [rax+28h]
test rax, rax
jz short loc_310EC
cmp byte ptr [rax+14h], 0
jz short loc_310EC
mov rdi, rbx
mov rsi, [rbp+var_38]
mov edx, [rbp+var_2C]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp pvio_socket_connect_async
loc_310EC:
xor edi, edi
call _time
mov r14, [rbx]
test r14, r14
jz loc_311B5
mov r12, rax
movsxd r15, dword ptr [rbx+24h]
mov [rbp+var_58], rbx
mov rdi, rbx
xor esi, esi
xor edx, edx
call pvio_socket_blocking
mov [rbp+var_50], r14
mov edi, [r14]
mov rsi, [rbp+var_38]
mov edx, [rbp+var_2C]
call _connect
mov r13d, eax
xor edi, edi
call _time
sub rax, r12
mov [rbp+var_48], r15
imul rcx, r15, 10624DD3h
mov rdx, rcx
shr rdx, 3Fh
sar rcx, 26h
add ecx, edx
movsxd r14, ecx
cmp rax, r14
jg short loc_311C3
mov ebx, 1
loc_3115B:
mov edi, ebx
call _usleep
cmp r13d, 0FFFFFFFFh
jnz loc_31237
call ___errno_location
mov eax, [rax]
cmp eax, 0Bh
jz short loc_3117D
cmp eax, 4
jnz short loc_311BD
loc_3117D:
lea r15d, [rbx+rbx]
mov eax, 0F4240h
cmp ebx, eax
cmovnb r15d, eax
mov rax, [rbp+var_50]
mov edi, [rax]
mov rsi, [rbp+var_38]
mov edx, [rbp+var_2C]
call _connect
mov r13d, eax
xor edi, edi
call _time
sub rax, r12
mov ebx, r15d
cmp rax, r14
jle short loc_3115B
jmp short loc_311C3
loc_311B5:
mov r13d, 1
jmp short loc_31237
loc_311BD:
mov r13d, 0FFFFFFFFh
loc_311C3:
cmp dword ptr [rbp+var_48], 0
setnz al
cmp r13d, 0FFFFFFFFh
setz cl
and cl, al
cmp cl, 1
jnz short loc_31237
call ___errno_location
mov r13d, 0FFFFFFFFh
cmp dword ptr [rax], 73h ; 's'
jnz short loc_31237
mov rbx, rax
mov rdi, [rbp+var_58]
xor esi, esi
mov rdx, [rbp+var_48]
call pvio_socket_wait_io_or_timeout
test eax, eax
jle short loc_31237
lea r8, [rbp+var_5C]
mov dword ptr [r8], 4
mov rax, [rbp+var_50]
mov edi, [rax]
lea rcx, [rbp+var_3C]
mov esi, 1
mov edx, 4
call _getsockopt
test eax, eax
js short loc_31234
mov r13d, eax
mov eax, [rbp+var_3C]
test eax, eax
cmovnz r13d, eax
jmp short loc_31237
loc_31234:
mov r13d, [rbx]
loc_31237:
mov eax, r13d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long pvio_socket_connect_sync_or_async(long long a1, long long a2, unsigned int a3)
{
long long v3; // rax
long long v4; // rax
long long v6; // rax
unsigned int *v7; // r14
long long v8; // r12
long long v9; // r15
unsigned int v10; // r13d
long long v11; // rdi
long long v12; // r14
unsigned int v13; // ebx
int v14; // eax
int v15; // r15d
unsigned int *v16; // rax
unsigned int *v17; // rbx
int v18; // eax
int v19; // [rsp+4h] [rbp-5Ch] BYREF
long long v20; // [rsp+8h] [rbp-58h]
unsigned int *v21; // [rsp+10h] [rbp-50h]
long long v22; // [rsp+18h] [rbp-48h]
unsigned int v23; // [rsp+24h] [rbp-3Ch] BYREF
long long v24; // [rsp+28h] [rbp-38h]
unsigned int v25; // [rsp+34h] [rbp-2Ch]
v25 = a3;
v24 = a2;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL);
if ( v3 )
{
v4 = *(_QWORD *)(v3 + 40);
if ( v4 )
{
if ( *(_BYTE *)(v4 + 20) )
return pvio_socket_connect_async(a1, v24, v25);
}
}
v6 = time(0LL);
v7 = *(unsigned int **)a1;
if ( *(_QWORD *)a1 )
{
v8 = v6;
v9 = *(int *)(a1 + 36);
v20 = a1;
pvio_socket_blocking((unsigned int **)a1, 0, 0LL);
v21 = v7;
v10 = connect(*v7, v24, v25);
v11 = 0LL;
v22 = v9;
v12 = (int)v9 / 1000;
if ( time(0LL) - v8 > v12 )
{
LABEL_17:
if ( (_DWORD)v22 != 0 && v10 == -1 )
{
v16 = (unsigned int *)__errno_location(v11);
v10 = -1;
if ( *v16 == 115 )
{
v17 = v16;
if ( (int)pvio_socket_wait_io_or_timeout(v20, 0, v22) > 0 )
{
v19 = 4;
v18 = getsockopt(*v21, 1LL, 4LL, &v23, &v19);
if ( v18 < 0 )
{
return *v17;
}
else
{
v10 = v18;
if ( v23 )
return v23;
}
}
}
}
}
else
{
v13 = 1;
while ( 1 )
{
v11 = v13;
usleep(v13);
if ( v10 != -1 )
break;
v14 = *(_DWORD *)__errno_location(v13);
if ( v14 != 11 && v14 != 4 )
{
v10 = -1;
goto LABEL_17;
}
v15 = 2 * v13;
if ( v13 >= 0xF4240 )
v15 = 1000000;
v10 = connect(*v21, v24, v25);
v11 = 0LL;
v13 = v15;
if ( time(0LL) - v8 > v12 )
goto LABEL_17;
}
}
}
else
{
return 1;
}
return v10;
}
| pvio_socket_connect_sync_or_async:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RBP + -0x2c],EDX
MOV qword ptr [RBP + -0x38],RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
TEST RAX,RAX
JZ 0x001310ec
MOV RAX,qword ptr [RAX + 0x28]
TEST RAX,RAX
JZ 0x001310ec
CMP byte ptr [RAX + 0x14],0x0
JZ 0x001310ec
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x2c]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00131249
LAB_001310ec:
XOR EDI,EDI
CALL 0x001133e0
MOV R14,qword ptr [RBX]
TEST R14,R14
JZ 0x001311b5
MOV R12,RAX
MOVSXD R15,dword ptr [RBX + 0x24]
MOV qword ptr [RBP + -0x58],RBX
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001305c2
MOV qword ptr [RBP + -0x50],R14
MOV EDI,dword ptr [R14]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x2c]
CALL 0x001133a0
MOV R13D,EAX
XOR EDI,EDI
CALL 0x001133e0
SUB RAX,R12
MOV qword ptr [RBP + -0x48],R15
IMUL RCX,R15,0x10624dd3
MOV RDX,RCX
SHR RDX,0x3f
SAR RCX,0x26
ADD ECX,EDX
MOVSXD R14,ECX
CMP RAX,R14
JG 0x001311c3
MOV EBX,0x1
LAB_0013115b:
MOV EDI,EBX
CALL 0x00113670
CMP R13D,-0x1
JNZ 0x00131237
CALL 0x00113060
MOV EAX,dword ptr [RAX]
CMP EAX,0xb
JZ 0x0013117d
CMP EAX,0x4
JNZ 0x001311bd
LAB_0013117d:
LEA R15D,[RBX + RBX*0x1]
MOV EAX,0xf4240
CMP EBX,EAX
CMOVNC R15D,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x2c]
CALL 0x001133a0
MOV R13D,EAX
XOR EDI,EDI
CALL 0x001133e0
SUB RAX,R12
MOV EBX,R15D
CMP RAX,R14
JLE 0x0013115b
JMP 0x001311c3
LAB_001311b5:
MOV R13D,0x1
JMP 0x00131237
LAB_001311bd:
MOV R13D,0xffffffff
LAB_001311c3:
CMP dword ptr [RBP + -0x48],0x0
SETNZ AL
CMP R13D,-0x1
SETZ CL
AND CL,AL
CMP CL,0x1
JNZ 0x00131237
CALL 0x00113060
MOV R13D,0xffffffff
CMP dword ptr [RAX],0x73
JNZ 0x00131237
MOV RBX,RAX
MOV RDI,qword ptr [RBP + -0x58]
XOR ESI,ESI
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x00130508
TEST EAX,EAX
JLE 0x00131237
LEA R8,[RBP + -0x5c]
MOV dword ptr [R8],0x4
MOV RAX,qword ptr [RBP + -0x50]
MOV EDI,dword ptr [RAX]
LEA RCX,[RBP + -0x3c]
MOV ESI,0x1
MOV EDX,0x4
CALL 0x00113320
TEST EAX,EAX
JS 0x00131234
MOV R13D,EAX
MOV EAX,dword ptr [RBP + -0x3c]
TEST EAX,EAX
CMOVNZ R13D,EAX
JMP 0x00131237
LAB_00131234:
MOV R13D,dword ptr [RBX]
LAB_00131237:
MOV EAX,R13D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong pvio_socket_connect_sync_or_async(int8 *param_1,sockaddr *param_2,socklen_t param_3)
{
long lVar1;
uint uVar2;
int iVar3;
ulong uVar4;
time_t tVar5;
time_t tVar6;
int *piVar7;
uint *puVar8;
uint __useconds;
bool bVar9;
socklen_t local_64;
int8 *local_60;
int *local_58;
long local_50;
uint local_44;
sockaddr *local_40;
socklen_t local_34;
local_40 = param_2;
local_34 = param_3;
if (((*(long *)(param_1[8] + 0x480) != 0) &&
(lVar1 = *(long *)(*(long *)(param_1[8] + 0x480) + 0x28), lVar1 != 0)) &&
(*(char *)(lVar1 + 0x14) != '\0')) {
uVar4 = pvio_socket_connect_async(param_1,param_2,param_3);
return uVar4;
}
tVar5 = time((time_t *)0x0);
local_58 = (int *)*param_1;
if (local_58 == (int *)0x0) {
uVar2 = 1;
}
else {
iVar3 = *(int *)((long)param_1 + 0x24);
local_60 = param_1;
pvio_socket_blocking(param_1,0,0);
uVar2 = connect(*local_58,local_40,local_34);
tVar6 = time((time_t *)0x0);
local_50 = (long)iVar3;
if (tVar6 - tVar5 <= (long)(iVar3 / 1000)) {
__useconds = 1;
do {
usleep(__useconds);
if (uVar2 != 0xffffffff) goto LAB_00131237;
piVar7 = __errno_location();
if ((*piVar7 != 0xb) && (*piVar7 != 4)) {
uVar2 = 0xffffffff;
break;
}
bVar9 = 999999 < __useconds;
__useconds = __useconds * 2;
if (bVar9) {
__useconds = 1000000;
}
uVar2 = connect(*local_58,local_40,local_34);
tVar6 = time((time_t *)0x0);
} while (tVar6 - tVar5 <= (long)(iVar3 / 1000));
}
if (uVar2 == 0xffffffff && (int)local_50 != 0) {
puVar8 = (uint *)__errno_location();
uVar2 = 0xffffffff;
if ((*puVar8 == 0x73) &&
(iVar3 = pvio_socket_wait_io_or_timeout(local_60,0,local_50), 0 < iVar3)) {
local_64 = 4;
uVar2 = getsockopt(*local_58,1,4,&local_44,&local_64);
if ((int)uVar2 < 0) {
uVar2 = *puVar8;
}
else if (local_44 != 0) {
uVar2 = local_44;
}
}
}
}
LAB_00131237:
return (ulong)uVar2;
}
| |
25,939 | ma_update_blob_record | eloqsql/storage/maria/ma_dynrec.c | my_bool _ma_update_blob_record(MARIA_HA *info, MARIA_RECORD_POS pos,
const uchar *oldrec __attribute__ ((unused)),
const uchar *record)
{
uchar *rec_buff;
int error;
ulong reclength,reclength2,extra;
my_bool buff_alloced;
extra= (ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER)+MARIA_SPLIT_LENGTH+
MARIA_DYN_DELETE_BLOCK_HEADER);
reclength= (info->s->base.pack_reclength+
_ma_calc_total_blob_length(info,record)+ extra);
#ifdef NOT_USED /* We now support big rows */
if (reclength > MARIA_DYN_MAX_ROW_LENGTH)
{
my_errno=HA_ERR_TO_BIG_ROW;
return 1;
}
#endif
alloc_on_stack(*info->stack_end_ptr, rec_buff, buff_alloced, reclength);
if (!rec_buff)
{
my_errno= HA_ERR_OUT_OF_MEM; /* purecov: inspected */
return(1);
}
reclength2= _ma_rec_pack(info, rec_buff+
ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER),
record);
if (!reclength2)
{
error= 1;
goto err;
}
DBUG_ASSERT(reclength2 <= reclength);
error=update_dynamic_record(info,pos,
rec_buff+ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER),
reclength2);
err:
stack_alloc_free(rec_buff, buff_alloced);
return(error != 0);
} | O3 | c | ma_update_blob_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq 0x3a0(%rax), %r12
movq %rcx, %rsi
callq 0x3cf4a
leaq (%r12,%rax), %rsi
addq $0x5c, %rsi
leaq -0x40(%rbp), %rcx
movq %rsi, (%rcx)
movq 0x78(%r14), %rax
movq (%rax), %rax
subq %rcx, %rax
subq %rsi, %rax
jbe 0x3d05c
cmpq $0x10000, %rax # imm = 0x10000
ja 0x3d044
cmpq $0x1000, %rsi # imm = 0x1000
jb 0x3d05c
cmpq $0x8001, %rax # imm = 0x8001
jb 0x3d05c
movq %rsp, %r12
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r12
movq %r12, %rsp
movb $0x1, %al
movl %eax, -0x34(%rbp)
jmp 0x3d077
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0x9fd89
testq %rax, %rax
je 0x3d0b7
movq %rax, %r12
movl $0x0, -0x34(%rbp)
leaq 0x18(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x3c5bd
testl %eax, %eax
je 0x3d0a5
movl %eax, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x3ca52
testb %al, %al
setne %bl
jmp 0x3d0a7
movb $0x1, %bl
cmpb $0x0, -0x34(%rbp)
jne 0x3d0c4
movq %r12, %rdi
callq 0x9ffb6
jmp 0x3d0c4
callq 0xa1afa
movl $0x80, (%rax)
movb $0x1, %bl
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x3d0e4
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| _ma_update_blob_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rcx
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov r12, [rax+3A0h]
mov rsi, rcx
call _ma_calc_total_blob_length
lea rsi, [r12+rax]
add rsi, 5Ch ; '\'
lea rcx, [rbp+var_40]
mov [rcx], rsi
mov rax, [r14+78h]
mov rax, [rax]
sub rax, rcx
sub rax, rsi
jbe short loc_3D05C
cmp rax, offset stru_10000
ja short loc_3D044
cmp rsi, 1000h
jb short loc_3D05C
cmp rax, 8001h
jb short loc_3D05C
loc_3D044:
mov r12, rsp
add rsi, 0Fh
and rsi, 0FFFFFFFFFFFFFFF0h
sub r12, rsi
mov rsp, r12
mov al, 1
mov [rbp+var_34], eax
jmp short loc_3D077
loc_3D05C:
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz short loc_3D0B7
mov r12, rax
mov [rbp+var_34], 0
loc_3D077:
lea r13, [r12+18h]
mov rdi, r14
mov rsi, r13
mov rdx, r15
call _ma_rec_pack
test eax, eax
jz short loc_3D0A5
mov ecx, eax
mov rdi, r14
mov rsi, rbx
mov rdx, r13
call update_dynamic_record
test al, al
setnz bl
jmp short loc_3D0A7
loc_3D0A5:
mov bl, 1
loc_3D0A7:
cmp byte ptr [rbp+var_34], 0
jnz short loc_3D0C4
mov rdi, r12
call my_free
jmp short loc_3D0C4
loc_3D0B7:
call _my_thread_var
mov dword ptr [rax], 80h
mov bl, 1
loc_3D0C4:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_3D0E4
mov eax, ebx
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3D0E4:
call ___stack_chk_fail
| long long ma_update_blob_record(long long a1, long long a2, long long a3, unsigned __int8 *a4)
{
long long v6; // r12
unsigned long long v7; // rsi
unsigned long long v8; // rax
bool v9; // cc
unsigned long long v10; // rax
unsigned __int8 *v11; // r12
long long v12; // rax
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
unsigned int v16; // eax
long long v17; // r8
unsigned long long v19; // [rsp+0h] [rbp-40h] BYREF
int v20; // [rsp+Ch] [rbp-34h]
unsigned long long v21; // [rsp+10h] [rbp-30h]
v21 = __readfsqword(0x28u);
v6 = *(_QWORD *)(*(_QWORD *)a1 + 928LL);
v7 = v6 + ma_calc_total_blob_length((_QWORD *)a1, (long long)a4) + 92;
v19 = v7;
v8 = **(_QWORD **)(a1 + 120) - (_QWORD)&v19;
v9 = v8 <= v7;
v10 = v8 - v7;
if ( v9 || v10 <= (unsigned long long)&stru_10000 && (v7 < 0x1000 || v10 < 0x8001) )
{
v12 = my_malloc(0LL, v7, 65552LL);
if ( !v12 )
{
*(_DWORD *)my_thread_var(0LL, v7, v13, v14, v15) = 128;
LOBYTE(a2) = 1;
return (unsigned int)a2;
}
v11 = (unsigned __int8 *)v12;
v20 = 0;
}
else
{
v11 = (unsigned __int8 *)&v19 - ((v7 + 15) & 0xFFFFFFFFFFFFFFF0LL);
LOBYTE(v10) = 1;
v20 = v10;
}
v16 = ma_rec_pack((unsigned __int8 *)a1, v11 + 24, a4);
if ( v16 )
LOBYTE(a2) = update_dynamic_record((_QWORD *)a1, a2, (long long)(v11 + 24), v16, v17);
else
LOBYTE(a2) = 1;
if ( !(_BYTE)v20 )
my_free(v11);
return (unsigned int)a2;
}
| _ma_update_blob_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RCX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV R12,qword ptr [RAX + 0x3a0]
MOV RSI,RCX
CALL 0x0013cf4a
LEA RSI,[R12 + RAX*0x1]
ADD RSI,0x5c
LEA RCX,[RBP + -0x40]
MOV qword ptr [RCX],RSI
MOV RAX,qword ptr [R14 + 0x78]
MOV RAX,qword ptr [RAX]
SUB RAX,RCX
SUB RAX,RSI
JBE 0x0013d05c
CMP RAX,0x10000
JA 0x0013d044
CMP RSI,0x1000
JC 0x0013d05c
CMP RAX,0x8001
JC 0x0013d05c
LAB_0013d044:
MOV R12,RSP
ADD RSI,0xf
AND RSI,-0x10
SUB R12,RSI
MOV RSP,R12
MOV AL,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0013d077
LAB_0013d05c:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x0019fd89
TEST RAX,RAX
JZ 0x0013d0b7
MOV R12,RAX
MOV dword ptr [RBP + -0x34],0x0
LAB_0013d077:
LEA R13,[R12 + 0x18]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R15
CALL 0x0013c5bd
TEST EAX,EAX
JZ 0x0013d0a5
MOV ECX,EAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R13
CALL 0x0013ca52
TEST AL,AL
SETNZ BL
JMP 0x0013d0a7
LAB_0013d0a5:
MOV BL,0x1
LAB_0013d0a7:
CMP byte ptr [RBP + -0x34],0x0
JNZ 0x0013d0c4
MOV RDI,R12
CALL 0x0019ffb6
JMP 0x0013d0c4
LAB_0013d0b7:
CALL 0x001a1afa
MOV dword ptr [RAX],0x80
MOV BL,0x1
LAB_0013d0c4:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0013d0e4
MOV EAX,EBX
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013d0e4:
CALL 0x00129270
|
ulong _ma_update_blob_record(long *param_1,int8 param_2,int8 param_3,int8 param_4)
{
long lVar1;
char cVar2;
int iVar3;
long lVar4;
ulong uVar5;
int1 *puVar6;
int4 *puVar7;
int7 uVar8;
ulong *puVar9;
long in_FS_OFFSET;
ulong local_48;
int4 local_3c;
long local_38;
puVar9 = &local_48;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *(long *)(*param_1 + 0x3a0);
lVar4 = _ma_calc_total_blob_length(param_1,param_4);
lVar1 = lVar1 + lVar4;
local_48 = lVar1 + 0x5c;
uVar5 = (*(long *)param_1[0xf] - (long)&local_48) - local_48;
uVar8 = (int7)((ulong)param_2 >> 8);
if (((ulong)(*(long *)param_1[0xf] - (long)&local_48) < local_48 || uVar5 == 0) ||
((uVar5 < 0x10001 && ((local_48 < 0x1000 || (uVar5 < 0x8001)))))) {
puVar6 = (int1 *)my_malloc(0,local_48,0x10010);
if (puVar6 == (int1 *)0x0) {
puVar7 = (int4 *)_my_thread_var();
*puVar7 = 0x80;
uVar5 = CONCAT71(uVar8,1);
goto LAB_0013d0c4;
}
local_3c = 0;
puVar9 = &local_48;
}
else {
puVar6 = (int1 *)((long)&local_48 - (lVar1 + 0x6bU & 0xfffffffffffffff0));
local_3c = (int4)CONCAT71((int7)(uVar5 >> 8),1);
puVar9 = (ulong *)puVar6;
}
*(int8 *)((long)puVar9 + -8) = 0x13d08a;
iVar3 = _ma_rec_pack(param_1,puVar6 + 0x18,param_4);
if (iVar3 == 0) {
uVar5 = CONCAT71(uVar8,1);
}
else {
*(int8 *)((long)puVar9 + -8) = 0x13d09e;
cVar2 = update_dynamic_record(param_1,param_2,puVar6 + 0x18,iVar3);
uVar5 = CONCAT71(uVar8,cVar2 != '\0');
}
if ((char)local_3c == '\0') {
*(int8 *)((long)puVar9 + -8) = 0x13d0b5;
my_free(puVar6);
}
LAB_0013d0c4:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar5 & 0xffffffff;
}
/* WARNING: Subroutine does not return */
*(code **)((long)puVar9 + -8) = _ma_delete_dynamic_record;
__stack_chk_fail();
}
| |
25,940 | ma_read_dynamic_record | eloqsql/storage/maria/ma_dynrec.c | int _ma_read_dynamic_record(MARIA_HA *info, uchar *buf,
MARIA_RECORD_POS filepos)
{
int block_of_record;
uint b_type;
MARIA_BLOCK_INFO block_info;
File file;
uchar *UNINIT_VAR(to);
uint UNINIT_VAR(left_length);
MARIA_SHARE *share= info->s;
myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
DBUG_ENTER("_ma_read_dynamic_record");
if (filepos == HA_OFFSET_ERROR)
goto err;
file= info->dfile.file;
block_of_record= 0; /* First block of record is numbered as zero. */
block_info.second_read= 0;
do
{
/* A corrupted table can have wrong pointers. (Bug# 19835) */
if (filepos == HA_OFFSET_ERROR)
goto panic;
if (info->opt_flag & WRITE_CACHE_USED &&
(info->rec_cache.pos_in_file < filepos +
MARIA_BLOCK_INFO_HEADER_LENGTH) &&
flush_io_cache(&info->rec_cache))
goto err;
info->rec_cache.seek_not_done=1;
if ((b_type= _ma_get_block_info(info, &block_info, file, filepos)) &
(BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
BLOCK_FATAL_ERROR))
{
if (b_type & (BLOCK_SYNC_ERROR | BLOCK_DELETED))
my_errno=HA_ERR_RECORD_DELETED;
goto err;
}
if (block_of_record++ == 0) /* First block */
{
info->cur_row.total_length= block_info.rec_len;
if (block_info.rec_len > (uint) share->base.max_pack_length)
goto panic;
if (share->base.blobs)
{
if (_ma_alloc_buffer(&info->rec_buff, &info->rec_buff_size,
block_info.rec_len +
share->base.extra_rec_buff_size, flag))
goto err;
}
to= info->rec_buff;
left_length=block_info.rec_len;
}
if (left_length < block_info.data_len || ! block_info.data_len)
goto panic; /* Wrong linked record */
/* copy information that is already read */
{
uint offset= (uint) (block_info.filepos - filepos);
uint prefetch_len= (sizeof(block_info.header) - offset);
filepos+= sizeof(block_info.header);
if (prefetch_len > block_info.data_len)
prefetch_len= block_info.data_len;
if (prefetch_len)
{
memcpy(to, block_info.header + offset, prefetch_len);
block_info.data_len-= prefetch_len;
left_length-= prefetch_len;
to+= prefetch_len;
}
}
/* read rest of record from file */
if (block_info.data_len)
{
if (info->opt_flag & WRITE_CACHE_USED &&
info->rec_cache.pos_in_file < filepos + block_info.data_len &&
flush_io_cache(&info->rec_cache))
goto err;
/*
What a pity that this method is not called 'file_pread' and that
there is no equivalent without seeking. We are at the right
position already. :(
*/
if (share->file_read(info, to, block_info.data_len,
filepos, MYF(MY_NABP)))
goto panic;
left_length-=block_info.data_len;
to+=block_info.data_len;
}
filepos= block_info.next_filepos;
} while (left_length);
info->update|= HA_STATE_AKTIV; /* We have a aktive record */
fast_ma_writeinfo(info);
DBUG_RETURN(_ma_rec_unpack(info,buf,info->rec_buff,block_info.rec_len) !=
MY_FILE_ERROR ? 0 : my_errno);
err:
fast_ma_writeinfo(info);
DBUG_RETURN(my_errno);
panic:
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
goto err;
} | O0 | c | ma_read_dynamic_record:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x9c(%rbp), %eax
movl %eax, -0x9c(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movsbl 0x7d9(%rax), %edx
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
cmpl $0x0, %edx
cmovnel %ecx, %eax
orl $0x10, %eax
movl %eax, %eax
movq %rax, -0xb0(%rbp)
cmpq $-0x1, -0x80(%rbp)
jne 0x3f6ef
jmp 0x3fa68
movq -0x70(%rbp), %rax
movl 0x480(%rax), %eax
movl %eax, -0x8c(%rbp)
movl $0x0, -0x84(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $-0x1, -0x80(%rbp)
jne 0x3f71c
jmp 0x3fa91
movq -0x70(%rbp), %rax
movl 0x61c(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x3f765
movq -0x70(%rbp), %rax
movq 0x4b8(%rax), %rax
movq -0x80(%rbp), %rcx
addq $0x14, %rcx
cmpq %rcx, %rax
jae 0x3f765
movq -0x70(%rbp), %rdi
addq $0x4b8, %rdi # imm = 0x4B8
movl $0x1, %esi
callq 0xe0590
cmpl $0x0, %eax
je 0x3f765
jmp 0x3fa68
movq -0x70(%rbp), %rax
movl $0x1, 0x598(%rax)
movq -0x70(%rbp), %rdi
movl -0x8c(%rbp), %edx
movq -0x80(%rbp), %rcx
leaq -0x60(%rbp), %rsi
callq 0x3da90
movl %eax, -0x88(%rbp)
andl $0x3c, %eax
cmpl $0x0, %eax
je 0x3f7b6
movl -0x88(%rbp), %eax
andl $0x14, %eax
cmpl $0x0, %eax
je 0x3f7b1
callq 0xf5a70
movl $0x86, (%rax)
jmp 0x3fa68
movl -0x84(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x84(%rbp)
cmpl $0x0, %eax
jne 0x3f86a
movq -0x48(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x48(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq 0x3b0(%rcx), %rcx
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x3f7fd
jmp 0x3fa91
movq -0xa8(%rbp), %rax
cmpl $0x0, 0x3f0(%rax)
je 0x3f84e
movq -0x70(%rbp), %rdi
addq $0x3a0, %rdi # imm = 0x3A0
movq -0x70(%rbp), %rsi
addq $0x460, %rsi # imm = 0x460
movq -0x48(%rbp), %rdx
movq -0xa8(%rbp), %rax
movl 0x424(%rax), %eax
addq %rax, %rdx
movq -0xb0(%rbp), %rcx
callq 0x64e70
cmpb $0x0, %al
je 0x3f84c
jmp 0x3fa68
jmp 0x3f84e
movq -0x70(%rbp), %rax
movq 0x3a0(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x48(%rbp), %rax
movl %eax, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
cmpq -0x40(%rbp), %rax
jb 0x3f87d
cmpq $0x0, -0x40(%rbp)
jne 0x3f882
jmp 0x3fa91
movq -0x28(%rbp), %rax
subq -0x80(%rbp), %rax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
movl %eax, %ecx
movl $0x14, %eax
subq %rcx, %rax
movl %eax, -0xb8(%rbp)
movq -0x80(%rbp), %rax
addq $0x14, %rax
movq %rax, -0x80(%rbp)
movl -0xb8(%rbp), %eax
cmpq -0x40(%rbp), %rax
jbe 0x3f8c8
movq -0x40(%rbp), %rax
movl %eax, -0xb8(%rbp)
cmpl $0x0, -0xb8(%rbp)
je 0x3f932
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl -0xb4(%rbp), %eax
addq %rax, %rsi
movl -0xb8(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movl -0xb8(%rbp), %eax
movl %eax, %ecx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0xb8(%rbp), %ecx
movl -0x9c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x9c(%rbp)
movl -0xb8(%rbp), %ecx
movq -0x98(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3f9df
movq -0x70(%rbp), %rax
movl 0x61c(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x3f986
movq -0x70(%rbp), %rax
movq 0x4b8(%rax), %rax
movq -0x80(%rbp), %rcx
addq -0x40(%rbp), %rcx
cmpq %rcx, %rax
jae 0x3f986
movq -0x70(%rbp), %rdi
addq $0x4b8, %rdi # imm = 0x4B8
movl $0x1, %esi
callq 0xe0590
cmpl $0x0, %eax
je 0x3f986
jmp 0x3fa68
movq -0xa8(%rbp), %rax
movq 0x6e0(%rax), %rax
movq -0x70(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x80(%rbp), %rcx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
je 0x3f9ba
jmp 0x3fa91
movq -0x40(%rbp), %rcx
movl -0x9c(%rbp), %eax
subq %rcx, %rax
movl %eax, -0x9c(%rbp)
movq -0x40(%rbp), %rax
addq -0x98(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpl $0x0, -0x9c(%rbp)
jne 0x3f710
movq -0x70(%rbp), %rax
movl 0x624(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x624(%rax)
movq -0x70(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x7b8(%rax)
jne 0x3fa22
movq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x35620
jmp 0x3fa24
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rax
movq 0x3a0(%rax), %rdx
movq -0x48(%rbp), %rcx
callq 0x3ef90
cmpq $-0x1, %rax
je 0x3fa50
xorl %eax, %eax
movl %eax, -0xbc(%rbp)
jmp 0x3fa5d
callq 0xf5a70
movl (%rax), %eax
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
movl %eax, -0x64(%rbp)
jmp 0x3faa1
movq -0x70(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x7b8(%rax)
jne 0x3fa83
movq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x35620
jmp 0x3fa85
callq 0xf5a70
movl (%rax), %eax
movl %eax, -0x64(%rbp)
jmp 0x3faa1
movq -0x70(%rbp), %rdi
movl $0x7f, %esi
callq 0x33260
jmp 0x3fa68
movl -0x64(%rbp), %eax
movl %eax, -0xc0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3facb
movl -0xc0(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
callq 0x2a270
| _ma_read_dynamic_record:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov [rbp+var_80], rdx
mov rax, [rbp+var_98]
mov [rbp+var_98], rax
mov eax, [rbp+var_9C]
mov [rbp+var_9C], eax
mov rax, [rbp+var_70]
mov rax, [rax]
mov [rbp+var_A8], rax
mov rax, [rbp+var_A8]
movsx edx, byte ptr [rax+7D9h]
xor eax, eax
mov ecx, 10000h
cmp edx, 0
cmovnz eax, ecx
or eax, 10h
mov eax, eax
mov [rbp+var_B0], rax
cmp [rbp+var_80], 0FFFFFFFFFFFFFFFFh
jnz short loc_3F6EF
jmp loc_3FA68
loc_3F6EF:
mov rax, [rbp+var_70]
mov eax, [rax+480h]
mov [rbp+var_8C], eax
mov [rbp+var_84], 0
mov [rbp+var_10], 0
loc_3F710:
cmp [rbp+var_80], 0FFFFFFFFFFFFFFFFh
jnz short loc_3F71C
jmp loc_3FA91
loc_3F71C:
mov rax, [rbp+var_70]
mov eax, [rax+61Ch]
and eax, 10h
cmp eax, 0
jz short loc_3F765
mov rax, [rbp+var_70]
mov rax, [rax+4B8h]
mov rcx, [rbp+var_80]
add rcx, 14h
cmp rax, rcx
jnb short loc_3F765
mov rdi, [rbp+var_70]
add rdi, 4B8h
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_3F765
jmp loc_3FA68
loc_3F765:
mov rax, [rbp+var_70]
mov dword ptr [rax+598h], 1
mov rdi, [rbp+var_70]
mov edx, [rbp+var_8C]
mov rcx, [rbp+var_80]
lea rsi, [rbp+var_60]
call _ma_get_block_info
mov [rbp+var_88], eax
and eax, 3Ch
cmp eax, 0
jz short loc_3F7B6
mov eax, [rbp+var_88]
and eax, 14h
cmp eax, 0
jz short loc_3F7B1
call _my_thread_var
mov dword ptr [rax], 86h
loc_3F7B1:
jmp loc_3FA68
loc_3F7B6:
mov eax, [rbp+var_84]
mov ecx, eax
add ecx, 1
mov [rbp+var_84], ecx
cmp eax, 0
jnz loc_3F86A
mov rcx, [rbp+var_48]
mov rax, [rbp+var_70]
mov [rax+110h], rcx
mov rax, [rbp+var_48]
mov rcx, [rbp+var_A8]
mov rcx, [rcx+3B0h]
mov ecx, ecx
cmp rax, rcx
jbe short loc_3F7FD
jmp loc_3FA91
loc_3F7FD:
mov rax, [rbp+var_A8]
cmp dword ptr [rax+3F0h], 0
jz short loc_3F84E
mov rdi, [rbp+var_70]
add rdi, 3A0h
mov rsi, [rbp+var_70]
add rsi, 460h
mov rdx, [rbp+var_48]
mov rax, [rbp+var_A8]
mov eax, [rax+424h]
add rdx, rax
mov rcx, [rbp+var_B0]
call _ma_alloc_buffer
cmp al, 0
jz short loc_3F84C
jmp loc_3FA68
loc_3F84C:
jmp short $+2
loc_3F84E:
mov rax, [rbp+var_70]
mov rax, [rax+3A0h]
mov [rbp+var_98], rax
mov rax, [rbp+var_48]
mov [rbp+var_9C], eax
loc_3F86A:
mov eax, [rbp+var_9C]
cmp rax, [rbp+var_40]
jb short loc_3F87D
cmp [rbp+var_40], 0
jnz short loc_3F882
loc_3F87D:
jmp loc_3FA91
loc_3F882:
mov rax, [rbp+var_28]
sub rax, [rbp+var_80]
mov [rbp+var_B4], eax
mov eax, [rbp+var_B4]
mov ecx, eax
mov eax, 14h
sub rax, rcx
mov [rbp+var_B8], eax
mov rax, [rbp+var_80]
add rax, 14h
mov [rbp+var_80], rax
mov eax, [rbp+var_B8]
cmp rax, [rbp+var_40]
jbe short loc_3F8C8
mov rax, [rbp+var_40]
mov [rbp+var_B8], eax
loc_3F8C8:
cmp [rbp+var_B8], 0
jz short loc_3F932
mov rdi, [rbp+var_98]
lea rsi, [rbp+var_60]
mov eax, [rbp+var_B4]
add rsi, rax
mov eax, [rbp+var_B8]
mov edx, eax
call _memcpy
mov eax, [rbp+var_B8]
mov ecx, eax
mov rax, [rbp+var_40]
sub rax, rcx
mov [rbp+var_40], rax
mov ecx, [rbp+var_B8]
mov eax, [rbp+var_9C]
sub eax, ecx
mov [rbp+var_9C], eax
mov ecx, [rbp+var_B8]
mov rax, [rbp+var_98]
mov ecx, ecx
add rax, rcx
mov [rbp+var_98], rax
loc_3F932:
cmp [rbp+var_40], 0
jz loc_3F9DF
mov rax, [rbp+var_70]
mov eax, [rax+61Ch]
and eax, 10h
cmp eax, 0
jz short loc_3F986
mov rax, [rbp+var_70]
mov rax, [rax+4B8h]
mov rcx, [rbp+var_80]
add rcx, [rbp+var_40]
cmp rax, rcx
jnb short loc_3F986
mov rdi, [rbp+var_70]
add rdi, 4B8h
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_3F986
jmp loc_3FA68
loc_3F986:
mov rax, [rbp+var_A8]
mov rax, [rax+6E0h]
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_98]
mov rdx, [rbp+var_40]
mov rcx, [rbp+var_80]
mov r8d, 4
call rax
cmp rax, 0
jz short loc_3F9BA
jmp loc_3FA91
loc_3F9BA:
mov rcx, [rbp+var_40]
mov eax, [rbp+var_9C]
sub rax, rcx
mov [rbp+var_9C], eax
mov rax, [rbp+var_40]
add rax, [rbp+var_98]
mov [rbp+var_98], rax
loc_3F9DF:
mov rax, [rbp+var_20]
mov [rbp+var_80], rax
cmp [rbp+var_9C], 0
jnz loc_3F710
mov rax, [rbp+var_70]
mov ecx, [rax+624h]
or ecx, 2
mov [rax+624h], ecx
mov rax, [rbp+var_70]
mov rax, [rax]
cmp dword ptr [rax+7B8h], 0
jnz short loc_3FA22
mov rdi, [rbp+var_70]
xor esi, esi
call _ma_writeinfo
loc_3FA22:
jmp short $+2
loc_3FA24:
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_78]
mov rax, [rbp+var_70]
mov rdx, [rax+3A0h]
mov rcx, [rbp+var_48]
call _ma_rec_unpack
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_3FA50
xor eax, eax
mov [rbp+var_BC], eax
jmp short loc_3FA5D
loc_3FA50:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_BC], eax
loc_3FA5D:
mov eax, [rbp+var_BC]
mov [rbp+var_64], eax
jmp short loc_3FAA1
loc_3FA68:
mov rax, [rbp+var_70]
mov rax, [rax]
cmp dword ptr [rax+7B8h], 0
jnz short loc_3FA83
mov rdi, [rbp+var_70]
xor esi, esi
call _ma_writeinfo
loc_3FA83:
jmp short $+2
loc_3FA85:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_64], eax
jmp short loc_3FAA1
loc_3FA91:
mov rdi, [rbp+var_70]
mov esi, 7Fh
call _ma_set_fatal_error
jmp short loc_3FA68
loc_3FAA1:
mov eax, [rbp+var_64]
mov [rbp+var_C0], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3FACB
mov eax, [rbp+var_C0]
add rsp, 0C0h
pop rbp
retn
loc_3FACB:
call ___stack_chk_fail
| long long ma_read_dynamic_record(long long a1, unsigned __int8 *a2, long long a3, long long a4, long long a5, int a6)
{
long long v6; // rdx
int v7; // eax
unsigned long long v8; // rcx
int v9; // eax
unsigned int v12; // [rsp+8h] [rbp-B8h]
int v13; // [rsp+Ch] [rbp-B4h]
long long v14; // [rsp+10h] [rbp-B0h]
long long v15; // [rsp+18h] [rbp-A8h]
unsigned int v16; // [rsp+24h] [rbp-9Ch]
long long v17; // [rsp+28h] [rbp-98h]
unsigned int v18; // [rsp+34h] [rbp-8Ch]
char block_info; // [rsp+38h] [rbp-88h]
int v20; // [rsp+3Ch] [rbp-84h]
long long v22; // [rsp+40h] [rbp-80h]
unsigned __int8 v24[24]; // [rsp+60h] [rbp-60h] BYREF
unsigned long long v25; // [rsp+78h] [rbp-48h]
unsigned long long v26; // [rsp+80h] [rbp-40h]
long long v27; // [rsp+98h] [rbp-28h]
long long v28; // [rsp+A0h] [rbp-20h]
int v29; // [rsp+B0h] [rbp-10h]
unsigned long long v30; // [rsp+B8h] [rbp-8h]
v30 = __readfsqword(0x28u);
v15 = *(_QWORD *)a1;
v6 = (unsigned int)*(char *)(*(_QWORD *)a1 + 2009LL);
v7 = 0;
v8 = 0x10000LL;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2009LL) )
v7 = 0x10000;
v14 = v7 | 0x10u;
if ( a3 == -1 )
{
LABEL_38:
if ( !*(_DWORD *)(*(_QWORD *)a1 + 1976LL) )
ma_writeinfo((long long *)a1, 0);
return *(unsigned int *)my_thread_var();
}
else
{
v18 = *(_DWORD *)(a1 + 1152);
v20 = 0;
v29 = 0;
do
{
if ( a3 == -1 )
{
LABEL_41:
ma_set_fatal_error((_DWORD *)a1, 127, v6, v8, a5, a6);
goto LABEL_38;
}
if ( (*(_DWORD *)(a1 + 1564) & 0x10) != 0
&& *(_QWORD *)(a1 + 1208) < (unsigned long long)(a3 + 20)
&& (unsigned int)my_b_flush_io_cache(a1 + 1208, 1LL) )
{
goto LABEL_38;
}
*(_DWORD *)(a1 + 1432) = 1;
block_info = ma_get_block_info(a1, v24, v18, a3, a5, a6);
if ( (block_info & 0x3C) != 0 )
{
if ( (block_info & 0x14) != 0 )
*(_DWORD *)my_thread_var() = 134;
goto LABEL_38;
}
v9 = v20;
v8 = (unsigned int)++v20;
if ( !v9 )
{
*(_QWORD *)(a1 + 272) = v25;
v8 = (unsigned int)*(_QWORD *)(v15 + 944);
if ( v25 > v8 )
goto LABEL_41;
if ( *(_DWORD *)(v15 + 1008)
&& (unsigned __int8)ma_alloc_buffer(a1 + 928, a1 + 1120, *(unsigned int *)(v15 + 1060) + v25, v14) )
{
goto LABEL_38;
}
v17 = *(_QWORD *)(a1 + 928);
v16 = v25;
}
if ( v16 < v26 || !v26 )
goto LABEL_41;
v13 = v27 - a3;
v8 = (unsigned int)(v27 - a3);
v12 = 20 - v8;
v22 = a3 + 20;
if ( (unsigned int)(20 - v8) > v26 )
v12 = v26;
if ( v12 )
{
memcpy(v17, &v24[v13], v12);
v26 -= v12;
v16 -= v12;
v8 = v12;
v17 += v12;
}
if ( v26 )
{
if ( (*(_DWORD *)(a1 + 1564) & 0x10) != 0
&& *(_QWORD *)(a1 + 1208) < v26 + v22
&& (unsigned int)my_b_flush_io_cache(a1 + 1208, 1LL) )
{
goto LABEL_38;
}
if ( (*(long long ( **)(long long, long long, unsigned long long, long long, long long))(v15 + 1760))(
a1,
v17,
v26,
v22,
4LL) )
{
goto LABEL_41;
}
v8 = v26;
v16 -= v26;
v17 += v26;
}
a3 = v28;
}
while ( v16 );
*(_DWORD *)(a1 + 1572) |= 2u;
if ( !*(_DWORD *)(*(_QWORD *)a1 + 1976LL) )
ma_writeinfo((long long *)a1, 0);
if ( ma_rec_unpack((_DWORD *)a1, a2, *(_QWORD *)(a1 + 928), v25, a5, a6) == -1 )
return *(unsigned int *)my_thread_var();
else
return 0;
}
}
| _ma_read_dynamic_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV qword ptr [RBP + -0x80],RDX
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x98],RAX
MOV EAX,dword ptr [RBP + -0x9c]
MOV dword ptr [RBP + -0x9c],EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0xa8]
MOVSX EDX,byte ptr [RAX + 0x7d9]
XOR EAX,EAX
MOV ECX,0x10000
CMP EDX,0x0
CMOVNZ EAX,ECX
OR EAX,0x10
MOV EAX,EAX
MOV qword ptr [RBP + -0xb0],RAX
CMP qword ptr [RBP + -0x80],-0x1
JNZ 0x0013f6ef
JMP 0x0013fa68
LAB_0013f6ef:
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x480]
MOV dword ptr [RBP + -0x8c],EAX
MOV dword ptr [RBP + -0x84],0x0
MOV dword ptr [RBP + -0x10],0x0
LAB_0013f710:
CMP qword ptr [RBP + -0x80],-0x1
JNZ 0x0013f71c
JMP 0x0013fa91
LAB_0013f71c:
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x61c]
AND EAX,0x10
CMP EAX,0x0
JZ 0x0013f765
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x4b8]
MOV RCX,qword ptr [RBP + -0x80]
ADD RCX,0x14
CMP RAX,RCX
JNC 0x0013f765
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,0x4b8
MOV ESI,0x1
CALL 0x001e0590
CMP EAX,0x0
JZ 0x0013f765
JMP 0x0013fa68
LAB_0013f765:
MOV RAX,qword ptr [RBP + -0x70]
MOV dword ptr [RAX + 0x598],0x1
MOV RDI,qword ptr [RBP + -0x70]
MOV EDX,dword ptr [RBP + -0x8c]
MOV RCX,qword ptr [RBP + -0x80]
LEA RSI,[RBP + -0x60]
CALL 0x0013da90
MOV dword ptr [RBP + -0x88],EAX
AND EAX,0x3c
CMP EAX,0x0
JZ 0x0013f7b6
MOV EAX,dword ptr [RBP + -0x88]
AND EAX,0x14
CMP EAX,0x0
JZ 0x0013f7b1
CALL 0x001f5a70
MOV dword ptr [RAX],0x86
LAB_0013f7b1:
JMP 0x0013fa68
LAB_0013f7b6:
MOV EAX,dword ptr [RBP + -0x84]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RBP + -0x84],ECX
CMP EAX,0x0
JNZ 0x0013f86a
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX + 0x110],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0xa8]
MOV RCX,qword ptr [RCX + 0x3b0]
MOV ECX,ECX
CMP RAX,RCX
JBE 0x0013f7fd
JMP 0x0013fa91
LAB_0013f7fd:
MOV RAX,qword ptr [RBP + -0xa8]
CMP dword ptr [RAX + 0x3f0],0x0
JZ 0x0013f84e
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,0x3a0
MOV RSI,qword ptr [RBP + -0x70]
ADD RSI,0x460
MOV RDX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0xa8]
MOV EAX,dword ptr [RAX + 0x424]
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0xb0]
CALL 0x00164e70
CMP AL,0x0
JZ 0x0013f84c
JMP 0x0013fa68
LAB_0013f84c:
JMP 0x0013f84e
LAB_0013f84e:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x3a0]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x9c],EAX
LAB_0013f86a:
MOV EAX,dword ptr [RBP + -0x9c]
CMP RAX,qword ptr [RBP + -0x40]
JC 0x0013f87d
CMP qword ptr [RBP + -0x40],0x0
JNZ 0x0013f882
LAB_0013f87d:
JMP 0x0013fa91
LAB_0013f882:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr [RBP + -0x80]
MOV dword ptr [RBP + -0xb4],EAX
MOV EAX,dword ptr [RBP + -0xb4]
MOV ECX,EAX
MOV EAX,0x14
SUB RAX,RCX
MOV dword ptr [RBP + -0xb8],EAX
MOV RAX,qword ptr [RBP + -0x80]
ADD RAX,0x14
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0xb8]
CMP RAX,qword ptr [RBP + -0x40]
JBE 0x0013f8c8
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0xb8],EAX
LAB_0013f8c8:
CMP dword ptr [RBP + -0xb8],0x0
JZ 0x0013f932
MOV RDI,qword ptr [RBP + -0x98]
LEA RSI,[RBP + -0x60]
MOV EAX,dword ptr [RBP + -0xb4]
ADD RSI,RAX
MOV EAX,dword ptr [RBP + -0xb8]
MOV EDX,EAX
CALL 0x0012a090
MOV EAX,dword ptr [RBP + -0xb8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV ECX,dword ptr [RBP + -0xb8]
MOV EAX,dword ptr [RBP + -0x9c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x9c],EAX
MOV ECX,dword ptr [RBP + -0xb8]
MOV RAX,qword ptr [RBP + -0x98]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x98],RAX
LAB_0013f932:
CMP qword ptr [RBP + -0x40],0x0
JZ 0x0013f9df
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x61c]
AND EAX,0x10
CMP EAX,0x0
JZ 0x0013f986
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x4b8]
MOV RCX,qword ptr [RBP + -0x80]
ADD RCX,qword ptr [RBP + -0x40]
CMP RAX,RCX
JNC 0x0013f986
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,0x4b8
MOV ESI,0x1
CALL 0x001e0590
CMP EAX,0x0
JZ 0x0013f986
JMP 0x0013fa68
LAB_0013f986:
MOV RAX,qword ptr [RBP + -0xa8]
MOV RAX,qword ptr [RAX + 0x6e0]
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x98]
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x80]
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
JZ 0x0013f9ba
JMP 0x0013fa91
LAB_0013f9ba:
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x9c]
SUB RAX,RCX
MOV dword ptr [RBP + -0x9c],EAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x98],RAX
LAB_0013f9df:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x80],RAX
CMP dword ptr [RBP + -0x9c],0x0
JNZ 0x0013f710
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x624]
OR ECX,0x2
MOV dword ptr [RAX + 0x624],ECX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x7b8],0x0
JNZ 0x0013fa22
MOV RDI,qword ptr [RBP + -0x70]
XOR ESI,ESI
CALL 0x00135620
LAB_0013fa22:
JMP 0x0013fa24
LAB_0013fa24:
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x70]
MOV RDX,qword ptr [RAX + 0x3a0]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x0013ef90
CMP RAX,-0x1
JZ 0x0013fa50
XOR EAX,EAX
MOV dword ptr [RBP + -0xbc],EAX
JMP 0x0013fa5d
LAB_0013fa50:
CALL 0x001f5a70
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xbc],EAX
LAB_0013fa5d:
MOV EAX,dword ptr [RBP + -0xbc]
MOV dword ptr [RBP + -0x64],EAX
JMP 0x0013faa1
LAB_0013fa68:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x7b8],0x0
JNZ 0x0013fa83
MOV RDI,qword ptr [RBP + -0x70]
XOR ESI,ESI
CALL 0x00135620
LAB_0013fa83:
JMP 0x0013fa85
LAB_0013fa85:
CALL 0x001f5a70
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x64],EAX
JMP 0x0013faa1
LAB_0013fa91:
MOV RDI,qword ptr [RBP + -0x70]
MOV ESI,0x7f
CALL 0x00133260
JMP 0x0013fa68
LAB_0013faa1:
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0xc0],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013facb
MOV EAX,dword ptr [RBP + -0xc0]
ADD RSP,0xc0
POP RBP
RET
LAB_0013facb:
CALL 0x0012a270
|
int4 _ma_read_dynamic_record(long *param_1,int8 param_2,long param_3)
{
long lVar1;
char cVar2;
uint uVar3;
int iVar4;
uint uVar5;
long lVar6;
long lVar7;
int4 *puVar8;
long in_FS_OFFSET;
int4 local_c4;
uint local_c0;
uint local_a4;
void *local_a0;
int local_8c;
long local_88;
int4 local_6c;
int1 local_68 [24];
ulong local_50;
ulong local_48;
int8 local_30;
long local_28;
int4 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar7 = *param_1;
uVar3 = 0;
if (*(char *)(lVar7 + 0x7d9) != '\0') {
uVar3 = 0x10000;
}
if (param_3 == -1) {
LAB_0013fa68:
if (*(int *)(*param_1 + 0x7b8) == 0) {
_ma_writeinfo(param_1,0);
}
puVar8 = (int4 *)_my_thread_var();
local_6c = *puVar8;
}
else {
lVar1 = param_1[0x90];
local_8c = 0;
local_18 = 0;
local_88 = param_3;
do {
if (local_88 == -1) {
LAB_0013fa91:
_ma_set_fatal_error(param_1,0x7f);
goto LAB_0013fa68;
}
if ((((*(uint *)((long)param_1 + 0x61c) & 0x10) != 0) &&
((ulong)param_1[0x97] < local_88 + 0x14U)) &&
(iVar4 = my_b_flush_io_cache(param_1 + 0x97,1), iVar4 != 0)) goto LAB_0013fa68;
*(int4 *)(param_1 + 0xb3) = 1;
uVar5 = _ma_get_block_info(param_1,local_68,(int)lVar1,local_88);
if ((uVar5 & 0x3c) != 0) {
if ((uVar5 & 0x14) != 0) {
puVar8 = (int4 *)_my_thread_var();
*puVar8 = 0x86;
}
goto LAB_0013fa68;
}
if (local_8c == 0) {
param_1[0x22] = local_50;
if ((*(ulong *)(lVar7 + 0x3b0) & 0xffffffff) < local_50) goto LAB_0013fa91;
if ((*(int *)(lVar7 + 0x3f0) != 0) &&
(cVar2 = _ma_alloc_buffer(param_1 + 0x74,param_1 + 0x8c,
local_50 + *(uint *)(lVar7 + 0x424),uVar3 | 0x10),
cVar2 != '\0')) goto LAB_0013fa68;
local_a0 = (void *)param_1[0x74];
local_a4 = (uint)local_50;
}
if ((local_a4 < local_48) || (local_48 == 0)) goto LAB_0013fa91;
uVar5 = (int)local_30 - (int)local_88;
local_c0 = 0x14 - uVar5;
if (local_48 < local_c0) {
local_c0 = (uint)local_48;
}
if (local_c0 != 0) {
memcpy(local_a0,local_68 + uVar5,(ulong)local_c0);
local_48 = local_48 - local_c0;
local_a4 = local_a4 - local_c0;
local_a0 = (void *)((long)local_a0 + (ulong)local_c0);
}
if (local_48 != 0) {
if ((((*(uint *)((long)param_1 + 0x61c) & 0x10) != 0) &&
((ulong)param_1[0x97] < local_88 + 0x14 + local_48)) &&
(iVar4 = my_b_flush_io_cache(param_1 + 0x97,1), iVar4 != 0)) goto LAB_0013fa68;
lVar6 = (**(code **)(lVar7 + 0x6e0))(param_1,local_a0,local_48,local_88 + 0x14,4);
if (lVar6 != 0) goto LAB_0013fa91;
local_a4 = local_a4 - (int)local_48;
local_a0 = (void *)(local_48 + (long)local_a0);
}
local_88 = local_28;
local_8c = local_8c + 1;
} while (local_a4 != 0);
*(uint *)((long)param_1 + 0x624) = *(uint *)((long)param_1 + 0x624) | 2;
if (*(int *)(*param_1 + 0x7b8) == 0) {
_ma_writeinfo(param_1,0);
}
lVar7 = _ma_rec_unpack(param_1,param_2,param_1[0x74],local_50);
if (lVar7 == -1) {
puVar8 = (int4 *)_my_thread_var();
local_c4 = *puVar8;
}
else {
local_c4 = 0;
}
local_6c = local_c4;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_6c;
}
| |
25,941 | ma_read_dynamic_record | eloqsql/storage/maria/ma_dynrec.c | int _ma_read_dynamic_record(MARIA_HA *info, uchar *buf,
MARIA_RECORD_POS filepos)
{
int block_of_record;
uint b_type;
MARIA_BLOCK_INFO block_info;
File file;
uchar *UNINIT_VAR(to);
uint UNINIT_VAR(left_length);
MARIA_SHARE *share= info->s;
myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
DBUG_ENTER("_ma_read_dynamic_record");
if (filepos == HA_OFFSET_ERROR)
goto err;
file= info->dfile.file;
block_of_record= 0; /* First block of record is numbered as zero. */
block_info.second_read= 0;
do
{
/* A corrupted table can have wrong pointers. (Bug# 19835) */
if (filepos == HA_OFFSET_ERROR)
goto panic;
if (info->opt_flag & WRITE_CACHE_USED &&
(info->rec_cache.pos_in_file < filepos +
MARIA_BLOCK_INFO_HEADER_LENGTH) &&
flush_io_cache(&info->rec_cache))
goto err;
info->rec_cache.seek_not_done=1;
if ((b_type= _ma_get_block_info(info, &block_info, file, filepos)) &
(BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
BLOCK_FATAL_ERROR))
{
if (b_type & (BLOCK_SYNC_ERROR | BLOCK_DELETED))
my_errno=HA_ERR_RECORD_DELETED;
goto err;
}
if (block_of_record++ == 0) /* First block */
{
info->cur_row.total_length= block_info.rec_len;
if (block_info.rec_len > (uint) share->base.max_pack_length)
goto panic;
if (share->base.blobs)
{
if (_ma_alloc_buffer(&info->rec_buff, &info->rec_buff_size,
block_info.rec_len +
share->base.extra_rec_buff_size, flag))
goto err;
}
to= info->rec_buff;
left_length=block_info.rec_len;
}
if (left_length < block_info.data_len || ! block_info.data_len)
goto panic; /* Wrong linked record */
/* copy information that is already read */
{
uint offset= (uint) (block_info.filepos - filepos);
uint prefetch_len= (sizeof(block_info.header) - offset);
filepos+= sizeof(block_info.header);
if (prefetch_len > block_info.data_len)
prefetch_len= block_info.data_len;
if (prefetch_len)
{
memcpy(to, block_info.header + offset, prefetch_len);
block_info.data_len-= prefetch_len;
left_length-= prefetch_len;
to+= prefetch_len;
}
}
/* read rest of record from file */
if (block_info.data_len)
{
if (info->opt_flag & WRITE_CACHE_USED &&
info->rec_cache.pos_in_file < filepos + block_info.data_len &&
flush_io_cache(&info->rec_cache))
goto err;
/*
What a pity that this method is not called 'file_pread' and that
there is no equivalent without seeking. We are at the right
position already. :(
*/
if (share->file_read(info, to, block_info.data_len,
filepos, MYF(MY_NABP)))
goto panic;
left_length-=block_info.data_len;
to+=block_info.data_len;
}
filepos= block_info.next_filepos;
} while (left_length);
info->update|= HA_STATE_AKTIV; /* We have a aktive record */
fast_ma_writeinfo(info);
DBUG_RETURN(_ma_rec_unpack(info,buf,info->rec_buff,block_info.rec_len) !=
MY_FILE_ERROR ? 0 : my_errno);
err:
fast_ma_writeinfo(info);
DBUG_RETURN(my_errno);
panic:
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
goto err;
} | O3 | c | ma_read_dynamic_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, -0xb8(%rbp)
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %r15
cmpb $0x0, 0x7d9(%r15)
setne %al
cmpq $-0x1, %rdx
je 0x3e582
movq %rdx, %r12
xorl %ecx, %ecx
movb %al, %cl
shll $0x10, %ecx
orq $0x10, %rcx
movq %rcx, -0xc8(%rbp)
movl 0x480(%rbx), %eax
movl %eax, -0xa4(%rbp)
leaq -0x88(%rbp), %rax
movl $0x0, 0x50(%rax)
leaq 0x4b8(%rbx), %rax
movq %rax, -0x98(%rbp)
leaq 0x3a0(%rbx), %rax
movq %rax, -0xb0(%rbp)
leaq 0x460(%rbx), %rax
movq %rax, -0xc0(%rbp)
xorl %r14d, %r14d
movq %rbx, -0xd8(%rbp)
movq %r15, -0xd0(%rbp)
cmpq $-0x1, %r12
je 0x3e575
testb $0x10, 0x61c(%rbx)
je 0x3e391
leaq 0x14(%r12), %rax
movq -0x98(%rbp), %rcx
cmpq %rax, (%rcx)
jae 0x3e391
movq -0x98(%rbp), %rdi
movl $0x1, %esi
callq 0x950b1
testl %eax, %eax
jne 0x3e582
movl $0x1, 0x598(%rbx)
movq %rbx, %rdi
leaq -0x88(%rbp), %rsi
movl -0xa4(%rbp), %edx
movq %r12, %rcx
callq 0x3d560
cmpl $0x4, %eax
jae 0x3e5c0
subl $0x1, %r14d
jae 0x3e42b
movq -0x70(%rbp), %r13
movq %r13, 0x110(%rbx)
movl 0x3b0(%r15), %eax
cmpq %rax, %r13
ja 0x3e575
cmpl $0x0, 0x3f0(%r15)
je 0x3e41a
movl 0x424(%r15), %eax
addq %rax, %r13
movq -0xb0(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq %r13, %rdx
movq -0xc8(%rbp), %rcx
callq 0x549fb
testb %al, %al
jne 0x3e582
movq -0x70(%rbp), %r13
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movl %r13d, %eax
movq -0x68(%rbp), %rdx
leaq -0x1(%rdx), %rcx
cmpq %rax, %rcx
jae 0x3e575
movl %r14d, -0x8c(%rbp)
movq -0x50(%rbp), %rax
subq %r12, %rax
movl $0x14, %ecx
subl %eax, %ecx
cmpq %rcx, %rdx
movl %edx, %r14d
cmovael %ecx, %r14d
testl %r14d, %r14d
je 0x3e4b6
movl %eax, %eax
leaq (%rax,%rbp), %rsi
addq $-0x88, %rsi
movl %r14d, %r15d
movq -0xa0(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x29080
movq -0x68(%rbp), %rdx
subl %r14d, %r13d
addq %r15, %rbx
movq %rbx, -0xa0(%rbp)
subq %r15, %rdx
movq -0xd0(%rbp), %r15
movq -0xd8(%rbp), %rbx
movq %rdx, -0x68(%rbp)
movl -0x8c(%rbp), %r14d
jne 0x3e4bd
jmp 0x3e524
movl -0x8c(%rbp), %r14d
addq $0x14, %r12
testb $0x10, 0x61c(%rbx)
je 0x3e4f7
leaq (%rdx,%r12), %rax
movq -0x98(%rbp), %rcx
cmpq %rax, (%rcx)
jae 0x3e4f7
movq -0x98(%rbp), %rdi
movl $0x1, %esi
callq 0x950b1
testl %eax, %eax
jne 0x3e582
movq -0x68(%rbp), %rdx
movl $0x4, %r8d
movq %rbx, %rdi
movq -0xa0(%rbp), %rsi
movq %r12, %rcx
callq *0x6e0(%r15)
testq %rax, %rax
jne 0x3e575
movq -0x68(%rbp), %rax
subl %eax, %r13d
addq %rax, -0xa0(%rbp)
movq -0x48(%rbp), %r12
testl %r13d, %r13d
jne 0x3e354
orb $0x2, 0x624(%rbx)
movq (%rbx), %rax
cmpl $0x0, 0x7b8(%rax)
jne 0x3e54e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x37936
movq 0x3a0(%rbx), %rdx
movq -0x70(%rbp), %rcx
movq %rbx, %rdi
movq -0xb8(%rbp), %rsi
callq 0x3de5b
movq %rax, %rcx
xorl %eax, %eax
cmpq $-0x1, %rcx
jne 0x3e59f
jmp 0x3e598
movq %rbx, %rdi
movl $0x7f, %esi
callq 0x3659c
movq (%rbx), %rax
cmpl $0x0, 0x7b8(%rax)
jne 0x3e598
movq %rbx, %rdi
xorl %esi, %esi
callq 0x37936
callq 0xa1672
movl (%rax), %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x3e5d1
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb $0x14, %al
je 0x3e582
callq 0xa1672
movl $0x86, (%rax)
jmp 0x3e582
callq 0x29270
| _ma_read_dynamic_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov [rbp+var_B8], rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r15, [rdi]
cmp byte ptr [r15+7D9h], 0
setnz al
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz loc_3E582
mov r12, rdx
xor ecx, ecx
mov cl, al
shl ecx, 10h
or rcx, 10h
mov [rbp+var_C8], rcx
mov eax, [rbx+480h]
mov [rbp+var_A4], eax
lea rax, [rbp+var_88]
mov dword ptr [rax+50h], 0
lea rax, [rbx+4B8h]
mov [rbp+var_98], rax
lea rax, [rbx+3A0h]
mov [rbp+var_B0], rax
lea rax, [rbx+460h]
mov [rbp+var_C0], rax
xor r14d, r14d
mov [rbp+var_D8], rbx
mov [rbp+var_D0], r15
loc_3E354:
cmp r12, 0FFFFFFFFFFFFFFFFh
jz loc_3E575
test byte ptr [rbx+61Ch], 10h
jz short loc_3E391
lea rax, [r12+14h]
mov rcx, [rbp+var_98]
cmp [rcx], rax
jnb short loc_3E391
mov rdi, [rbp+var_98]
mov esi, 1
call my_b_flush_io_cache
test eax, eax
jnz loc_3E582
loc_3E391:
mov dword ptr [rbx+598h], 1
mov rdi, rbx
lea rsi, [rbp+var_88]
mov edx, [rbp+var_A4]
mov rcx, r12
call _ma_get_block_info
cmp eax, 4
jnb loc_3E5C0
sub r14d, 1
jnb short loc_3E42B
mov r13, [rbp+var_70]
mov [rbx+110h], r13
mov eax, [r15+3B0h]
cmp r13, rax
ja loc_3E575
cmp dword ptr [r15+3F0h], 0
jz short loc_3E41A
mov eax, [r15+424h]
add r13, rax
mov rdi, [rbp+var_B0]
mov rsi, [rbp+var_C0]
mov rdx, r13
mov rcx, [rbp+var_C8]
call _ma_alloc_buffer
test al, al
jnz loc_3E582
mov r13, [rbp+var_70]
loc_3E41A:
mov rax, [rbp+var_B0]
mov rax, [rax]
mov [rbp+var_A0], rax
loc_3E42B:
mov eax, r13d
mov rdx, [rbp+var_68]
lea rcx, [rdx-1]
cmp rcx, rax
jnb loc_3E575
mov [rbp+var_8C], r14d
mov rax, [rbp+var_50]
sub rax, r12
mov ecx, 14h
sub ecx, eax
cmp rdx, rcx
mov r14d, edx
cmovnb r14d, ecx
test r14d, r14d
jz short loc_3E4B6
mov eax, eax
lea rsi, [rax+rbp]
add rsi, 0FFFFFFFFFFFFFF78h
mov r15d, r14d
mov rbx, [rbp+var_A0]
mov rdi, rbx
mov rdx, r15
call _memcpy
mov rdx, [rbp+var_68]
sub r13d, r14d
add rbx, r15
mov [rbp+var_A0], rbx
sub rdx, r15
mov r15, [rbp+var_D0]
mov rbx, [rbp+var_D8]
mov [rbp+var_68], rdx
mov r14d, [rbp+var_8C]
jnz short loc_3E4BD
jmp short loc_3E524
loc_3E4B6:
mov r14d, [rbp+var_8C]
loc_3E4BD:
add r12, 14h
test byte ptr [rbx+61Ch], 10h
jz short loc_3E4F7
lea rax, [rdx+r12]
mov rcx, [rbp+var_98]
cmp [rcx], rax
jnb short loc_3E4F7
mov rdi, [rbp+var_98]
mov esi, 1
call my_b_flush_io_cache
test eax, eax
jnz loc_3E582
mov rdx, [rbp+var_68]
loc_3E4F7:
mov r8d, 4
mov rdi, rbx
mov rsi, [rbp+var_A0]
mov rcx, r12
call qword ptr [r15+6E0h]
test rax, rax
jnz short loc_3E575
mov rax, [rbp+var_68]
sub r13d, eax
add [rbp+var_A0], rax
loc_3E524:
mov r12, [rbp+var_48]
test r13d, r13d
jnz loc_3E354
or byte ptr [rbx+624h], 2
mov rax, [rbx]
cmp dword ptr [rax+7B8h], 0
jnz short loc_3E54E
mov rdi, rbx
xor esi, esi
call _ma_writeinfo
loc_3E54E:
mov rdx, [rbx+3A0h]
mov rcx, [rbp+var_70]
mov rdi, rbx
mov rsi, [rbp+var_B8]
call _ma_rec_unpack
mov rcx, rax
xor eax, eax
cmp rcx, 0FFFFFFFFFFFFFFFFh
jnz short loc_3E59F
jmp short loc_3E598
loc_3E575:
mov rdi, rbx
mov esi, 7Fh
call _ma_set_fatal_error
loc_3E582:
mov rax, [rbx]
cmp dword ptr [rax+7B8h], 0
jnz short loc_3E598
mov rdi, rbx
xor esi, esi
call _ma_writeinfo
loc_3E598:
call _my_thread_var
mov eax, [rax]
loc_3E59F:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_3E5D1
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3E5C0:
test al, 14h
jz short loc_3E582
call _my_thread_var
mov dword ptr [rax], 86h
jmp short loc_3E582
loc_3E5D1:
call ___stack_chk_fail
| long long ma_read_dynamic_record(
_DWORD *a1,
unsigned __int8 *a2,
long long a3,
long long a4,
unsigned long long a5,
int a6)
{
unsigned long long v6; // r13
long long v7; // rbx
long long v8; // r15
long long v9; // r12
int v10; // r14d
unsigned int block_info; // eax
bool v12; // cf
int v13; // r14d
unsigned int v14; // r14d
bool v15; // zf
long long v16; // r12
long long result; // rax
_DWORD *v18; // [rsp+8h] [rbp-D8h]
long long v19; // [rsp+10h] [rbp-D0h]
long long v20; // [rsp+18h] [rbp-C8h]
unsigned __int8 *v21; // [rsp+20h] [rbp-C0h]
unsigned __int8 *v22; // [rsp+28h] [rbp-B8h]
_QWORD *v23; // [rsp+30h] [rbp-B0h]
unsigned int v24; // [rsp+3Ch] [rbp-A4h]
long long v25; // [rsp+40h] [rbp-A0h]
_QWORD *v26; // [rsp+48h] [rbp-98h]
int v27; // [rsp+54h] [rbp-8Ch]
unsigned __int8 v28[24]; // [rsp+58h] [rbp-88h] BYREF
unsigned long long v29; // [rsp+70h] [rbp-70h]
unsigned long long v30; // [rsp+78h] [rbp-68h]
long long v31; // [rsp+90h] [rbp-50h]
long long v32; // [rsp+98h] [rbp-48h]
int v33; // [rsp+A8h] [rbp-38h]
unsigned long long v34; // [rsp+B0h] [rbp-30h]
v22 = a2;
v7 = (long long)a1;
v34 = __readfsqword(0x28u);
v8 = *(_QWORD *)a1;
if ( a3 != -1 )
{
v9 = a3;
a4 = ((unsigned __int8)(*(_BYTE *)(*(_QWORD *)a1 + 2009LL) != 0) << 16) | 0x10LL;
v20 = a4;
v24 = a1[288];
v33 = 0;
v26 = a1 + 302;
v23 = a1 + 232;
v21 = (unsigned __int8 *)(a1 + 280);
v10 = 0;
v18 = a1;
v19 = v8;
while ( 1 )
{
if ( v9 == -1 )
{
LABEL_32:
a1 = (_DWORD *)v7;
a2 = (_BYTE *)(&dword_7C + 3);
ma_set_fatal_error((_DWORD *)v7, 127LL, a3, a4, a5, a6);
goto LABEL_33;
}
if ( (*(_BYTE *)(v7 + 1564) & 0x10) != 0 && *v26 < (unsigned long long)(v9 + 20) )
{
a1 = v26;
a2 = (_BYTE *)(&dword_0 + 1);
if ( (unsigned int)my_b_flush_io_cache(v26, 1LL) )
goto LABEL_33;
}
*(_DWORD *)(v7 + 1432) = 1;
a1 = (_DWORD *)v7;
a2 = v28;
block_info = ma_get_block_info(v7, v28, v24, v9, a5, a6);
if ( block_info >= 4 )
{
if ( (block_info & 0x14) != 0 )
*(_DWORD *)my_thread_var(v7, v28, a3, a4, a5) = 134;
goto LABEL_33;
}
v12 = v10 == 0;
v13 = v10 - 1;
if ( v12 )
{
v6 = v29;
*(_QWORD *)(v7 + 272) = v29;
if ( v6 > *(unsigned int *)(v8 + 944) )
goto LABEL_32;
if ( *(_DWORD *)(v8 + 1008) )
{
a1 = v23;
a2 = v21;
if ( (unsigned __int8)ma_alloc_buffer(v23, v21, *(unsigned int *)(v8 + 1060) + v6, v20) )
goto LABEL_33;
LODWORD(v6) = v29;
}
v25 = *v23;
}
a3 = v30;
a4 = v30 - 1;
if ( v30 - 1 >= (unsigned int)v6 )
goto LABEL_32;
v27 = v13;
v14 = v30;
if ( v30 >= (unsigned int)(20 - (v31 - v9)) )
v14 = 20 - (v31 - v9);
if ( !v14 )
break;
memcpy(v25, &v28[(unsigned int)(v31 - v9)], v14);
LODWORD(v6) = v6 - v14;
v25 += v14;
a3 = v30 - v14;
v15 = v30 == v14;
v8 = v19;
v7 = (long long)v18;
v30 = a3;
v10 = v27;
if ( !v15 )
goto LABEL_21;
LABEL_27:
v9 = v32;
if ( !(_DWORD)v6 )
{
*(_BYTE *)(v7 + 1572) |= 2u;
if ( !*(_DWORD *)(*(_QWORD *)v7 + 1976LL) )
ma_writeinfo((long long *)v7, 0LL, a3, a4, a5);
a1 = (_DWORD *)v7;
a2 = v22;
a4 = ma_rec_unpack((_DWORD *)v7, v22, *(_QWORD *)(v7 + 928), v29, a5, a6);
result = 0LL;
if ( a4 != -1 )
return result;
return *(unsigned int *)my_thread_var(a1, a2, a3, a4, a5);
}
}
v10 = v27;
LABEL_21:
v16 = v9 + 20;
if ( (*(_BYTE *)(v7 + 1564) & 0x10) != 0 && *v26 < (unsigned long long)(a3 + v16) )
{
a1 = v26;
a2 = (_BYTE *)(&dword_0 + 1);
if ( (unsigned int)my_b_flush_io_cache(v26, 1LL) )
goto LABEL_33;
a3 = v30;
}
if ( (*(long long ( **)(long long, long long, long long, long long, long long))(v8 + 1760))(v7, v25, a3, v16, 4LL) )
goto LABEL_32;
LODWORD(v6) = v6 - v30;
v25 += v30;
goto LABEL_27;
}
LABEL_33:
if ( !*(_DWORD *)(*(_QWORD *)v7 + 1976LL) )
{
a1 = (_DWORD *)v7;
a2 = 0LL;
ma_writeinfo((long long *)v7, 0LL, a3, a4, a5);
}
return *(unsigned int *)my_thread_var(a1, a2, a3, a4, a5);
}
| _ma_read_dynamic_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RBP + -0xb8],RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R15,qword ptr [RDI]
CMP byte ptr [R15 + 0x7d9],0x0
SETNZ AL
CMP RDX,-0x1
JZ 0x0013e582
MOV R12,RDX
XOR ECX,ECX
MOV CL,AL
SHL ECX,0x10
OR RCX,0x10
MOV qword ptr [RBP + -0xc8],RCX
MOV EAX,dword ptr [RBX + 0x480]
MOV dword ptr [RBP + -0xa4],EAX
LEA RAX,[RBP + -0x88]
MOV dword ptr [RAX + 0x50],0x0
LEA RAX,[RBX + 0x4b8]
MOV qword ptr [RBP + -0x98],RAX
LEA RAX,[RBX + 0x3a0]
MOV qword ptr [RBP + -0xb0],RAX
LEA RAX,[RBX + 0x460]
MOV qword ptr [RBP + -0xc0],RAX
XOR R14D,R14D
MOV qword ptr [RBP + -0xd8],RBX
MOV qword ptr [RBP + -0xd0],R15
LAB_0013e354:
CMP R12,-0x1
JZ 0x0013e575
TEST byte ptr [RBX + 0x61c],0x10
JZ 0x0013e391
LEA RAX,[R12 + 0x14]
MOV RCX,qword ptr [RBP + -0x98]
CMP qword ptr [RCX],RAX
JNC 0x0013e391
MOV RDI,qword ptr [RBP + -0x98]
MOV ESI,0x1
CALL 0x001950b1
TEST EAX,EAX
JNZ 0x0013e582
LAB_0013e391:
MOV dword ptr [RBX + 0x598],0x1
MOV RDI,RBX
LEA RSI,[RBP + -0x88]
MOV EDX,dword ptr [RBP + -0xa4]
MOV RCX,R12
CALL 0x0013d560
CMP EAX,0x4
JNC 0x0013e5c0
SUB R14D,0x1
JNC 0x0013e42b
MOV R13,qword ptr [RBP + -0x70]
MOV qword ptr [RBX + 0x110],R13
MOV EAX,dword ptr [R15 + 0x3b0]
CMP R13,RAX
JA 0x0013e575
CMP dword ptr [R15 + 0x3f0],0x0
JZ 0x0013e41a
MOV EAX,dword ptr [R15 + 0x424]
ADD R13,RAX
MOV RDI,qword ptr [RBP + -0xb0]
MOV RSI,qword ptr [RBP + -0xc0]
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0xc8]
CALL 0x001549fb
TEST AL,AL
JNZ 0x0013e582
MOV R13,qword ptr [RBP + -0x70]
LAB_0013e41a:
MOV RAX,qword ptr [RBP + -0xb0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xa0],RAX
LAB_0013e42b:
MOV EAX,R13D
MOV RDX,qword ptr [RBP + -0x68]
LEA RCX,[RDX + -0x1]
CMP RCX,RAX
JNC 0x0013e575
MOV dword ptr [RBP + -0x8c],R14D
MOV RAX,qword ptr [RBP + -0x50]
SUB RAX,R12
MOV ECX,0x14
SUB ECX,EAX
CMP RDX,RCX
MOV R14D,EDX
CMOVNC R14D,ECX
TEST R14D,R14D
JZ 0x0013e4b6
MOV EAX,EAX
LEA RSI,[RAX + RBP*0x1]
ADD RSI,-0x88
MOV R15D,R14D
MOV RBX,qword ptr [RBP + -0xa0]
MOV RDI,RBX
MOV RDX,R15
CALL 0x00129080
MOV RDX,qword ptr [RBP + -0x68]
SUB R13D,R14D
ADD RBX,R15
MOV qword ptr [RBP + -0xa0],RBX
SUB RDX,R15
MOV R15,qword ptr [RBP + -0xd0]
MOV RBX,qword ptr [RBP + -0xd8]
MOV qword ptr [RBP + -0x68],RDX
MOV R14D,dword ptr [RBP + -0x8c]
JNZ 0x0013e4bd
JMP 0x0013e524
LAB_0013e4b6:
MOV R14D,dword ptr [RBP + -0x8c]
LAB_0013e4bd:
ADD R12,0x14
TEST byte ptr [RBX + 0x61c],0x10
JZ 0x0013e4f7
LEA RAX,[RDX + R12*0x1]
MOV RCX,qword ptr [RBP + -0x98]
CMP qword ptr [RCX],RAX
JNC 0x0013e4f7
MOV RDI,qword ptr [RBP + -0x98]
MOV ESI,0x1
CALL 0x001950b1
TEST EAX,EAX
JNZ 0x0013e582
MOV RDX,qword ptr [RBP + -0x68]
LAB_0013e4f7:
MOV R8D,0x4
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0xa0]
MOV RCX,R12
CALL qword ptr [R15 + 0x6e0]
TEST RAX,RAX
JNZ 0x0013e575
MOV RAX,qword ptr [RBP + -0x68]
SUB R13D,EAX
ADD qword ptr [RBP + -0xa0],RAX
LAB_0013e524:
MOV R12,qword ptr [RBP + -0x48]
TEST R13D,R13D
JNZ 0x0013e354
OR byte ptr [RBX + 0x624],0x2
MOV RAX,qword ptr [RBX]
CMP dword ptr [RAX + 0x7b8],0x0
JNZ 0x0013e54e
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00137936
LAB_0013e54e:
MOV RDX,qword ptr [RBX + 0x3a0]
MOV RCX,qword ptr [RBP + -0x70]
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0xb8]
CALL 0x0013de5b
MOV RCX,RAX
XOR EAX,EAX
CMP RCX,-0x1
JNZ 0x0013e59f
JMP 0x0013e598
LAB_0013e575:
MOV RDI,RBX
MOV ESI,0x7f
CALL 0x0013659c
LAB_0013e582:
MOV RAX,qword ptr [RBX]
CMP dword ptr [RAX + 0x7b8],0x0
JNZ 0x0013e598
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00137936
LAB_0013e598:
CALL 0x001a1672
MOV EAX,dword ptr [RAX]
LAB_0013e59f:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0013e5d1
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013e5c0:
TEST AL,0x14
JZ 0x0013e582
CALL 0x001a1672
MOV dword ptr [RAX],0x86
JMP 0x0013e582
LAB_0013e5d1:
CALL 0x00129270
|
int4 _ma_read_dynamic_record(long *param_1,int8 param_2,long param_3)
{
ulong *puVar1;
char cVar2;
long lVar3;
char cVar4;
int iVar5;
uint uVar6;
uint uVar7;
int4 uVar8;
long lVar9;
long lVar10;
int4 *puVar11;
uint uVar12;
ulong unaff_R13;
int iVar13;
uint uVar14;
ulong __n;
long in_FS_OFFSET;
bool bVar15;
void *local_a8;
int1 local_90 [24];
ulong local_78;
ulong local_70;
int8 local_58;
long local_50;
int4 local_40;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar10 = *param_1;
cVar2 = *(char *)(lVar10 + 0x7d9);
if (param_3 == -1) {
LAB_0013e582:
if (*(int *)(*param_1 + 0x7b8) == 0) {
_ma_writeinfo(param_1,0);
}
}
else {
lVar3 = param_1[0x90];
local_40 = 0;
puVar1 = (ulong *)(param_1 + 0x97);
iVar13 = 0;
do {
if (param_3 == -1) {
LAB_0013e575:
_ma_set_fatal_error(param_1,0x7f);
goto LAB_0013e582;
}
if ((((*(byte *)((long)param_1 + 0x61c) & 0x10) != 0) && (*puVar1 < param_3 + 0x14U)) &&
(iVar5 = my_b_flush_io_cache(puVar1,1), iVar5 != 0)) goto LAB_0013e582;
*(int4 *)(param_1 + 0xb3) = 1;
uVar6 = _ma_get_block_info(param_1,local_90,(int)lVar3,param_3);
if (3 < uVar6) {
if ((uVar6 & 0x14) != 0) {
puVar11 = (int4 *)_my_thread_var();
*puVar11 = 0x86;
}
goto LAB_0013e582;
}
bVar15 = iVar13 == 0;
iVar13 = iVar13 + -1;
if (bVar15) {
param_1[0x22] = local_78;
if (*(uint *)(lVar10 + 0x3b0) < local_78) goto LAB_0013e575;
if ((*(int *)(lVar10 + 0x3f0) != 0) &&
(cVar4 = _ma_alloc_buffer(param_1 + 0x74,param_1 + 0x8c,
local_78 + *(uint *)(lVar10 + 0x424),
(ulong)(cVar2 != '\0') << 0x10 | 0x10), cVar4 != '\0'))
goto LAB_0013e582;
local_a8 = (void *)param_1[0x74];
unaff_R13 = local_78;
}
uVar6 = (uint)unaff_R13;
if ((unaff_R13 & 0xffffffff) <= local_70 - 1) goto LAB_0013e575;
uVar7 = (int)local_58 - (int)param_3;
uVar12 = 0x14 - uVar7;
uVar14 = (uint)local_70;
if (uVar12 <= local_70) {
uVar14 = uVar12;
}
if (uVar14 == 0) {
LAB_0013e4bd:
if ((((*(byte *)((long)param_1 + 0x61c) & 0x10) != 0) &&
(*puVar1 < local_70 + param_3 + 0x14)) &&
(iVar5 = my_b_flush_io_cache(puVar1,1), iVar5 != 0)) goto LAB_0013e582;
lVar9 = (**(code **)(lVar10 + 0x6e0))(param_1,local_a8,local_70,param_3 + 0x14,4);
if (lVar9 != 0) goto LAB_0013e575;
uVar6 = uVar6 - (int)local_70;
local_a8 = (void *)((long)local_a8 + local_70);
}
else {
__n = (ulong)uVar14;
memcpy(local_a8,local_90 + uVar7,__n);
uVar6 = uVar6 - uVar14;
local_a8 = (void *)((long)local_a8 + __n);
local_70 = local_70 - __n;
if (local_70 != 0) goto LAB_0013e4bd;
}
unaff_R13 = (ulong)uVar6;
param_3 = local_50;
} while (uVar6 != 0);
*(byte *)((long)param_1 + 0x624) = *(byte *)((long)param_1 + 0x624) | 2;
if (*(int *)(*param_1 + 0x7b8) == 0) {
_ma_writeinfo(param_1,0);
}
lVar10 = _ma_rec_unpack(param_1,param_2,param_1[0x74],local_78);
uVar8 = 0;
if (lVar10 != -1) goto LAB_0013e59f;
}
puVar11 = (int4 *)_my_thread_var();
uVar8 = *puVar11;
LAB_0013e59f:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar8;
}
| |
25,942 | js_map_get_size | bluesky950520[P]quickjs/quickjs.c | static JSValue js_map_get_size(JSContext *ctx, JSValue this_val, int magic)
{
JSMapState *s = JS_GetOpaque2(ctx, this_val, JS_CLASS_MAP + magic);
if (!s)
return JS_EXCEPTION;
return js_uint32(s->record_count);
} | O1 | c | js_map_get_size:
pushq %rax
addl $0x23, %ecx
callq 0x2b611
testq %rax, %rax
je 0x53d9c
movslq 0x18(%rax), %rcx
xorl %esi, %esi
movl %ecx, %eax
cvtsi2sd %rax, %xmm0
testq %rcx, %rcx
movq %xmm0, %rax
cmovnsq %rcx, %rax
movl $0x7, %edx
cmovnsq %rsi, %rdx
jmp 0x53da3
movl $0x6, %edx
xorl %eax, %eax
popq %rcx
retq
| js_map_get_size:
push rax
add ecx, 23h ; '#'
call JS_GetOpaque2
test rax, rax
jz short loc_53D9C
movsxd rcx, dword ptr [rax+18h]
xor esi, esi
mov eax, ecx
cvtsi2sd xmm0, rax
test rcx, rcx
movq rax, xmm0
cmovns rax, rcx
mov edx, 7
cmovns rdx, rsi
jmp short loc_53DA3
loc_53D9C:
mov edx, 6
xor eax, eax
loc_53DA3:
pop rcx
retn
| long long js_map_get_size(long long a1, long long a2, int a3, int a4)
{
long long Opaque2; // rax
long long v5; // rcx
long long result; // rax
Opaque2 = JS_GetOpaque2(a1, a2, a3, a4 + 35);
if ( Opaque2 )
{
v5 = *(int *)(Opaque2 + 24);
*(double *)&result = (double)*(int *)(Opaque2 + 24);
if ( v5 >= 0 )
return v5;
}
else
{
*(double *)&result = 0.0;
}
return result;
}
| js_map_get_size:
PUSH RAX
ADD ECX,0x23
CALL 0x0012b611
TEST RAX,RAX
JZ 0x00153d9c
MOVSXD RCX,dword ptr [RAX + 0x18]
XOR ESI,ESI
MOV EAX,ECX
CVTSI2SD XMM0,RAX
TEST RCX,RCX
MOVQ RAX,XMM0
CMOVNS RAX,RCX
MOV EDX,0x7
CMOVNS RDX,RSI
JMP 0x00153da3
LAB_00153d9c:
MOV EDX,0x6
XOR EAX,EAX
LAB_00153da3:
POP RCX
RET
|
int1 [16] js_map_get_size(void)
{
uint uVar1;
long lVar2;
double dVar3;
double dVar4;
int8 uVar5;
int1 auVar6 [16];
lVar2 = JS_GetOpaque2();
if (lVar2 == 0) {
dVar3 = 0.0;
uVar5 = 6;
}
else {
uVar1 = *(uint *)(lVar2 + 0x18);
dVar4 = (double)(long)(int)uVar1;
dVar3 = (double)uVar1;
if (-1 < (long)dVar4) {
dVar3 = dVar4;
}
uVar5 = 7;
if (-1 < (long)dVar4) {
uVar5 = 0;
}
}
auVar6._8_8_ = uVar5;
auVar6._0_8_ = dVar3;
return auVar6;
}
| |
25,943 | js_map_get_size | bluesky950520[P]quickjs/quickjs.c | static JSValue js_map_get_size(JSContext *ctx, JSValue this_val, int magic)
{
JSMapState *s = JS_GetOpaque2(ctx, this_val, JS_CLASS_MAP + magic);
if (!s)
return JS_EXCEPTION;
return js_uint32(s->record_count);
} | O3 | c | js_map_get_size:
addl $0x23, %ecx
cmpl $-0x1, %edx
jne 0x56061
movzwl 0x6(%rsi), %eax
cmpl %eax, %ecx
jne 0x56061
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x56061
movslq 0x18(%rax), %rcx
xorl %esi, %esi
movl %ecx, %eax
cvtsi2sd %rax, %xmm0
testq %rcx, %rcx
movq %xmm0, %rax
cmovnsq %rcx, %rax
movl $0x7, %edx
cmovnsq %rsi, %rdx
retq
pushq %rax
movl %ecx, %esi
callq 0x2bd03
movl $0x6, %edx
xorl %eax, %eax
addq $0x8, %rsp
retq
| js_map_get_size:
add ecx, 23h ; '#'
cmp edx, 0FFFFFFFFh
jnz short loc_56061
movzx eax, word ptr [rsi+6]
cmp ecx, eax
jnz short loc_56061
mov rax, [rsi+30h]
test rax, rax
jz short loc_56061
movsxd rcx, dword ptr [rax+18h]
xor esi, esi
mov eax, ecx
cvtsi2sd xmm0, rax
test rcx, rcx
movq rax, xmm0
cmovns rax, rcx
mov edx, 7
cmovns rdx, rsi
retn
loc_56061:
push rax
mov esi, ecx
call JS_ThrowTypeErrorInvalidClass
mov edx, 6
xor eax, eax
add rsp, 8
retn
| long long js_map_get_size(
long long a1,
long long a2,
int a3,
int a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
int v12; // ecx
long long v13; // rax
long long v14; // rcx
long long result; // rax
v12 = a4 + 35;
if ( a3 == -1 && v12 == *(unsigned __int16 *)(a2 + 6) && (v13 = *(_QWORD *)(a2 + 48)) != 0 )
{
v14 = *(int *)(v13 + 24);
*(double *)&result = (double)*(int *)(v13 + 24);
if ( v14 >= 0 )
return v14;
}
else
{
JS_ThrowTypeErrorInvalidClass(a1, v12, a5, a6, a7, a8, a9, a10, a11, a12);
*(double *)&result = 0.0;
}
return result;
}
| js_map_get_size:
ADD ECX,0x23
CMP EDX,-0x1
JNZ 0x00156061
MOVZX EAX,word ptr [RSI + 0x6]
CMP ECX,EAX
JNZ 0x00156061
MOV RAX,qword ptr [RSI + 0x30]
TEST RAX,RAX
JZ 0x00156061
MOVSXD RCX,dword ptr [RAX + 0x18]
XOR ESI,ESI
MOV EAX,ECX
CVTSI2SD XMM0,RAX
TEST RCX,RCX
MOVQ RAX,XMM0
CMOVNS RAX,RCX
MOV EDX,0x7
CMOVNS RDX,RSI
RET
LAB_00156061:
PUSH RAX
MOV ESI,ECX
CALL 0x0012bd03
MOV EDX,0x6
XOR EAX,EAX
ADD RSP,0x8
RET
|
int1 [16] js_map_get_size(int8 param_1,long param_2,int param_3,int param_4)
{
uint uVar1;
double dVar2;
double dVar3;
int1 auVar5 [16];
int8 uVar4;
if (((param_3 == -1) && (param_4 + 0x23U == (uint)*(ushort *)(param_2 + 6))) &&
(*(long *)(param_2 + 0x30) != 0)) {
uVar1 = *(uint *)(*(long *)(param_2 + 0x30) + 0x18);
dVar3 = (double)(long)(int)uVar1;
dVar2 = (double)uVar1;
if (-1 < (long)dVar3) {
dVar2 = dVar3;
}
uVar4 = 7;
if (-1 < (long)dVar3) {
uVar4 = 0;
}
auVar5._8_8_ = uVar4;
auVar5._0_8_ = dVar2;
return auVar5;
}
JS_ThrowTypeErrorInvalidClass(param_1,param_4 + 0x23U);
return ZEXT816(6) << 0x40;
}
| |
25,944 | ggml_argmax | ngxson[P]ggml-easy/ggml/src/ggml.c | struct ggml_tensor * ggml_argmax(
struct ggml_context * ctx,
struct ggml_tensor * a) {
GGML_ASSERT(ggml_is_matrix(a));
GGML_ASSERT(a->ne[0] <= INT32_MAX);
struct ggml_tensor * result = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, a->ne[1]);
result->op = GGML_OP_ARGMAX;
result->src[0] = a;
return result;
} | O0 | c | ggml_argmax:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x43a50
testb $0x1, %al
jne 0x4bd3d
leaq 0x68894(%rip), %rdi # 0xb45b7
movl $0x8e4, %esi # imm = 0x8E4
leaq 0x688d3(%rip), %rdx # 0xb4602
leaq 0x689f3(%rip), %rcx # 0xb4729
movb $0x0, %al
callq 0x46780
movq 0x8(%rsp), %rax
cmpq $0x7fffffff, 0x10(%rax) # imm = 0x7FFFFFFF
jle 0x4bd6d
leaq 0x68864(%rip), %rdi # 0xb45b7
movl $0x8e5, %esi # imm = 0x8E5
leaq 0x688a3(%rip), %rdx # 0xb4602
leaq 0x689d5(%rip), %rcx # 0xb473b
movb $0x0, %al
callq 0x46780
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
movl $0x1a, %esi
callq 0x47b30
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x10, 0x50(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x98(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
| ggml_argmax:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rdi, [rsp+18h+var_10]
call _ggml_is_matrix
test al, 1
jnz short loc_4BD3D
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov esi, 8E4h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsMatrixA; "ggml_is_matrix(a)"
mov al, 0
call _ggml_abort
loc_4BD3D:
mov rax, [rsp+18h+var_10]
cmp qword ptr [rax+10h], 7FFFFFFFh
jle short loc_4BD6D
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov esi, 8E5h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aANe0Int32Max; "a->ne[0] <= INT32_MAX"
mov al, 0
call _ggml_abort
loc_4BD6D:
mov rdi, [rsp+18h+var_8]
mov rax, [rsp+18h+var_10]
mov rdx, [rax+18h]
mov esi, 1Ah
call _ggml_new_tensor_1d
mov [rsp+18h+var_18], rax
mov rax, [rsp+18h+var_18]
mov dword ptr [rax+50h], 10h
mov rcx, [rsp+18h+var_10]
mov rax, [rsp+18h+var_18]
mov [rax+98h], rcx
mov rax, [rsp+18h+var_18]
add rsp, 18h
retn
| long long ggml_argmax(long long a1, long long a2)
{
long long result; // rax
if ( !ggml_is_matrix(a2) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
2276,
(long long)"GGML_ASSERT(%s) failed",
"ggml_is_matrix(a)");
if ( *(long long *)(a2 + 16) > 0x7FFFFFFF )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
2277,
(long long)"GGML_ASSERT(%s) failed",
"a->ne[0] <= INT32_MAX");
result = ggml_new_tensor_1d(a1, 0x1Au, *(_QWORD *)(a2 + 24));
*(_DWORD *)(result + 80) = 16;
*(_QWORD *)(result + 152) = a2;
return result;
}
| ggml_argmax:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00143a50
TEST AL,0x1
JNZ 0x0014bd3d
LEA RDI,[0x1b45b7]
MOV ESI,0x8e4
LEA RDX,[0x1b4602]
LEA RCX,[0x1b4729]
MOV AL,0x0
CALL 0x00146780
LAB_0014bd3d:
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RAX + 0x10],0x7fffffff
JLE 0x0014bd6d
LEA RDI,[0x1b45b7]
MOV ESI,0x8e5
LEA RDX,[0x1b4602]
LEA RCX,[0x1b473b]
MOV AL,0x0
CALL 0x00146780
LAB_0014bd6d:
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RAX + 0x18]
MOV ESI,0x1a
CALL 0x00147b30
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX + 0x50],0x10
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP]
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RSP]
ADD RSP,0x18
RET
|
long ggml_argmax(int8 param_1,long param_2)
{
ulong uVar1;
long lVar2;
uVar1 = ggml_is_matrix(param_2);
if ((uVar1 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",0x8e4,
"GGML_ASSERT(%s) failed","ggml_is_matrix(a)");
}
if (0x7fffffff < *(long *)(param_2 + 0x10)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",0x8e5,
"GGML_ASSERT(%s) failed","a->ne[0] <= INT32_MAX");
}
lVar2 = ggml_new_tensor_1d(param_1,0x1a,*(int8 *)(param_2 + 0x18));
*(int4 *)(lVar2 + 0x50) = 0x10;
*(long *)(lVar2 + 0x98) = param_2;
return lVar2;
}
| |
25,945 | my_mb_wc_eucjpms | eloqsql/strings/ctype-eucjpms.c | static int
my_mb_wc_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII code set: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
if (hi >= 0xA1 && hi <= 0xFE) /* JIS X 0208 code set: [A1..FE][A1..FE] */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
return (*pwc= jisx0208_eucjpms_to_unicode[(hi << 8) + s[1]]) ? 2 :
(s[1] < 0xA1 || s[1] > 0xFE) ? MY_CS_ILSEQ : -2;
}
/* JIS-X-0201 HALF WIDTH KATAKANA: [8E][A1..DF] -> [U+FF61..U+FF9F] */
if (hi == 0x8E)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (s[1] < 0xA1 || s[1] > 0xDF)
return MY_CS_ILSEQ;
*pwc= 0xFEC0 + s[1]; /* 0xFFC0 = 0xFF61 - 0xA1 */
return 2;
}
if (hi == 0x8F) /* JIS X 0212 code set: [8F][A1..FE][A1..FE] */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
return (*pwc= jisx0212_eucjpms_to_unicode[(((int) s[1]) << 8) + s[2]]) ?
3 :
(s[1] < 0xA1 || s[1] > 0xFE || s[2] < 0xA1 || s[2] > 0xFE) ?
MY_CS_ILSEQ : -3;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_eucjpms:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xb7eda
movzbl (%rdx), %edi
testb %dil, %dil
js 0xb7edc
movq %rdi, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leal 0x5f(%rdi), %eax
cmpb $0x5d, %al
ja 0xb7f28
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xb7eda
movzbl 0x1(%rdx), %eax
shll $0x9, %edi
leal (%rdi,%rax,2), %eax
leaq 0xad7fe(%rip), %rcx # 0x165700
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0xb7eda
movb 0x1(%rdx), %al
incb %al
xorl %ecx, %ecx
cmpb $-0x5e, %al
setb %cl
leal -0x2(,%rcx,2), %eax
jmp 0xb7eda
cmpq $0x8f, %rdi
je 0xb7f6c
cmpl $0x8e, %edi
jne 0xb7fae
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0xb7eda
movzbl 0x1(%rdx), %ecx
leal 0x20(%rcx), %edx
movl $0x0, %eax
cmpb $-0x3f, %dl
jb 0xb7eda
addq $0xfec0, %rcx # imm = 0xFEC0
movq %rcx, (%rsi)
movl $0x2, %eax
jmp 0xb7eda
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0xb7eda
movzwl 0x1(%rdx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq 0xcd770(%rip), %rcx # 0x185700
movzwl (%rcx,%rax,2), %ecx
movq %rcx, (%rsi)
movl $0x3, %eax
testq %rcx, %rcx
jne 0xb7eda
movb 0x1(%rdx), %al
incb %al
cmpb $-0x5e, %al
jae 0xb7fb5
xorl %eax, %eax
jmp 0xb7eda
movb 0x2(%rdx), %cl
movl $0x0, %eax
cmpb $-0x5f, %cl
jb 0xb7eda
xorl %eax, %eax
cmpb $-0x1, %cl
sete %al
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
jmp 0xb7eda
| my_mb_wc_eucjpms:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_B7EDA
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_B7EDC
mov [rsi], rdi
mov eax, 1
loc_B7EDA:
pop rbp
retn
loc_B7EDC:
lea eax, [rdi+5Fh]
cmp al, 5Dh ; ']'
ja short loc_B7F28
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_B7EDA
movzx eax, byte ptr [rdx+1]
shl edi, 9
lea eax, [rdi+rax*2]
lea rcx, jisx0208_eucjpms_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_B7EDA
mov al, [rdx+1]
inc al
xor ecx, ecx
cmp al, 0A2h
setb cl
lea eax, ds:0FFFFFFFFFFFFFFFEh[rcx*2]
jmp short loc_B7EDA
loc_B7F28:
cmp rdi, 8Fh
jz short loc_B7F6C
cmp edi, 8Eh
jnz short loc_B7FAE
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_B7EDA
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx+20h]
mov eax, 0
cmp dl, 0C1h
jb short loc_B7EDA
add rcx, 0FEC0h
mov [rsi], rcx
mov eax, 2
jmp loc_B7EDA
loc_B7F6C:
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_B7EDA
movzx eax, word ptr [rdx+1]
rol ax, 8
movzx eax, ax
lea rcx, jisx0212_eucjpms_to_unicode
movzx ecx, word ptr [rcx+rax*2]
mov [rsi], rcx
mov eax, 3
test rcx, rcx
jnz loc_B7EDA
mov al, [rdx+1]
inc al
cmp al, 0A2h
jnb short loc_B7FB5
loc_B7FAE:
xor eax, eax
jmp loc_B7EDA
loc_B7FB5:
mov cl, [rdx+2]
mov eax, 0
cmp cl, 0A1h
jb loc_B7EDA
xor eax, eax
cmp cl, 0FFh
setz al
lea eax, [rax+rax*2]
add eax, 0FFFFFFFDh
jmp loc_B7EDA
| long long my_mb_wc_eucjpms(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
long long v7; // rcx
long long v8; // rcx
unsigned __int8 v9; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x5Du )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = jisx0208_eucjpms_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
return 2 * (unsigned int)((unsigned __int8)(a3[1] + 1) < 0xA2u) - 2;
}
return result;
}
if ( v5 != 143 )
{
if ( (_DWORD)v5 == 142 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v7 = a3[1];
result = 0LL;
if ( (unsigned __int8)(v7 + 32) >= 0xC1u )
{
*a2 = v7 + 65216;
return 2LL;
}
}
return result;
}
return 0LL;
}
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) > a4 )
return result;
v8 = jisx0212_eucjpms_to_unicode[(unsigned __int16)__ROL2__(*(_WORD *)(a3 + 1), 8)];
*a2 = v8;
result = 3LL;
if ( v8 )
return result;
if ( (unsigned __int8)(a3[1] + 1) < 0xA2u )
return 0LL;
v9 = a3[2];
result = 0LL;
if ( v9 >= 0xA1u )
return 3 * (unsigned int)(v9 == 0xFF) - 3;
return result;
}
| my_mb_wc_eucjpms:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001b7eda
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x001b7edc
MOV qword ptr [RSI],RDI
MOV EAX,0x1
LAB_001b7eda:
POP RBP
RET
LAB_001b7edc:
LEA EAX,[RDI + 0x5f]
CMP AL,0x5d
JA 0x001b7f28
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001b7eda
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EDI,0x9
LEA EAX,[RDI + RAX*0x2]
LEA RCX,[0x265700]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x001b7eda
MOV AL,byte ptr [RDX + 0x1]
INC AL
XOR ECX,ECX
CMP AL,0xa2
SETC CL
LEA EAX,[-0x2 + RCX*0x2]
JMP 0x001b7eda
LAB_001b7f28:
CMP RDI,0x8f
JZ 0x001b7f6c
CMP EDI,0x8e
JNZ 0x001b7fae
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001b7eda
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + 0x20]
MOV EAX,0x0
CMP DL,0xc1
JC 0x001b7eda
ADD RCX,0xfec0
MOV qword ptr [RSI],RCX
MOV EAX,0x2
JMP 0x001b7eda
LAB_001b7f6c:
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x001b7eda
MOVZX EAX,word ptr [RDX + 0x1]
ROL AX,0x8
MOVZX EAX,AX
LEA RCX,[0x285700]
MOVZX ECX,word ptr [RCX + RAX*0x2]
MOV qword ptr [RSI],RCX
MOV EAX,0x3
TEST RCX,RCX
JNZ 0x001b7eda
MOV AL,byte ptr [RDX + 0x1]
INC AL
CMP AL,0xa2
JNC 0x001b7fb5
LAB_001b7fae:
XOR EAX,EAX
JMP 0x001b7eda
LAB_001b7fb5:
MOV CL,byte ptr [RDX + 0x2]
MOV EAX,0x0
CMP CL,0xa1
JC 0x001b7eda
XOR EAX,EAX
CMP CL,0xff
SETZ AL
LEA EAX,[RAX + RAX*0x2]
ADD EAX,-0x3
JMP 0x001b7eda
|
int my_mb_wc_eucjpms(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if ((byte)(bVar1 + 0x5f) < 0x5e) {
iVar3 = -0x66;
if (param_3 + 2 <= param_4) {
uVar2 = *(ushort *)
(jisx0208_eucjpms_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
iVar3 = 2;
if ((ulong)uVar2 == 0) {
iVar3 = (uint)((byte)(param_3[1] + 1) < 0xa2) * 2 + -2;
}
}
}
else {
if ((ulong)bVar1 == 0x8f) {
if (param_4 < param_3 + 3) {
return -0x67;
}
uVar2 = *(ushort *)
(&jisx0212_eucjpms_to_unicode +
(ulong)(ushort)(*(ushort *)(param_3 + 1) << 8 | *(ushort *)(param_3 + 1) >> 8) *
2);
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 3;
}
if (0xa1 < (byte)(param_3[1] + 1)) {
if (param_3[2] < 0xa1) {
return 0;
}
return (uint)(param_3[2] == 0xff) * 3 + -3;
}
}
else if (bVar1 == 0x8e) {
if (param_4 < param_3 + 2) {
return -0x66;
}
if ((byte)(param_3[1] + 0x20) < 0xc1) {
return 0;
}
*param_2 = (ulong)param_3[1] + 0xfec0;
return 2;
}
iVar3 = 0;
}
}
else {
*param_2 = (ulong)bVar1;
iVar3 = 1;
}
}
return iVar3;
}
| |
25,946 | ftxui::inverted(std::shared_ptr<ftxui::Node>) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/dom/inverted.cpp | Element inverted(Element child) {
return std::make_shared<Inverted>(std::move(child));
} | O1 | cpp | ftxui::inverted(std::shared_ptr<ftxui::Node>):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
movl $0x70, %edi
callq 0xb3e0
movq %rax, %rbx
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbx)
leaq 0x203b9(%rip), %rax # 0x59c10
movq %rax, (%rbx)
movq %rbx, %r15
addq $0x10, %r15
movq (%r12), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq 0x8(%r12), %rcx
movq %rax, 0x8(%r12)
movq %rcx, 0x8(%rsi)
movq %rax, (%r12)
movq %r15, %rdi
callq 0x23124
leaq 0x203cc(%rip), %rax # 0x59c60
movq %rax, (%r15)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x398a6
callq 0x14c7c
movq %r15, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x398ce
callq 0x14c7c
movl $0x70, %esi
movq %rbx, %rdi
callq 0xb400
movq %r14, %rdi
callq 0xb780
nop
| _ZN5ftxui8invertedESt10shared_ptrINS_4NodeEE:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r12, rsi
mov r14, rdi
mov edi, 70h ; 'p'; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov rax, 100000001h
mov [rbx+8], rax
lea rax, off_59C10
mov [rbx], rax
mov r15, rbx
add r15, 10h
mov rax, [r12]
lea rsi, [rsp+38h+var_30]
mov [rsi], rax
xor eax, eax
mov [rsi+8], rax
mov rcx, [r12+8]
mov [r12+8], rax
mov [rsi+8], rcx
mov [r12], rax
mov rdi, r15
call _ZN5ftxui13NodeDecoratorC2ESt10shared_ptrINS_4NodeEE; ftxui::NodeDecorator::NodeDecorator(std::shared_ptr<ftxui::Node>)
lea rax, off_59C60
mov [r15], rax
mov rdi, [rsp+38h+var_28]
test rdi, rdi
jz short loc_398A6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_398A6:
mov [r14], r15
mov [r14+8], rbx
mov rax, r14
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rsp+arg_8]
test rdi, rdi
jz short loc_398CE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_398CE:
mov esi, 70h ; 'p'; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r14
call __Unwind_Resume
| _QWORD * ftxui::inverted(_QWORD *a1, long long *a2)
{
_QWORD *v2; // rbx
volatile signed __int32 *v3; // rcx
long long v5; // [rsp+8h] [rbp-30h] BYREF
volatile signed __int32 *v6; // [rsp+10h] [rbp-28h]
v2 = (_QWORD *)operator new(0x70uLL);
v2[1] = 0x100000001LL;
*v2 = off_59C10;
v5 = *a2;
v6 = 0LL;
v3 = (volatile signed __int32 *)a2[1];
a2[1] = 0LL;
v6 = v3;
*a2 = 0LL;
ftxui::NodeDecorator::NodeDecorator(v2 + 2, &v5);
v2[2] = off_59C60;
if ( v6 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v6);
*a1 = v2 + 2;
a1[1] = v2;
return a1;
}
| inverted:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RSI
MOV R14,RDI
MOV EDI,0x70
CALL 0x0010b3e0
MOV RBX,RAX
MOV RAX,0x100000001
MOV qword ptr [RBX + 0x8],RAX
LEA RAX,[0x159c10]
MOV qword ptr [RBX],RAX
MOV R15,RBX
ADD R15,0x10
MOV RAX,qword ptr [R12]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
XOR EAX,EAX
MOV qword ptr [RSI + 0x8],RAX
MOV RCX,qword ptr [R12 + 0x8]
MOV qword ptr [R12 + 0x8],RAX
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [R12],RAX
LAB_00139885:
MOV RDI,R15
CALL 0x00123124
LAB_0013988d:
LEA RAX,[0x159c60]
MOV qword ptr [R15],RAX
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x001398a6
CALL 0x00114c7c
LAB_001398a6:
MOV qword ptr [R14],R15
MOV qword ptr [R14 + 0x8],RBX
MOV RAX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ftxui::inverted(std::shared_ptr<ftxui::Node>) */
ftxui * __thiscall ftxui::inverted(ftxui *this,int8 *param_2)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *this_00;
int8 *puVar1;
NodeDecorator *pNVar2;
puVar1 = (int8 *)operator_new(0x70);
puVar1[1] = 0x100000001;
*puVar1 = &PTR___Sp_counted_ptr_inplace_00159c10;
pNVar2 = (NodeDecorator *)(puVar1 + 2);
this_00 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_2[1];
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 00139885 to 0013988c has its CatchHandler @ 001398bc */
NodeDecorator::NodeDecorator(pNVar2);
*(int ***)pNVar2 = &PTR__Node_00159c60;
if (this_00 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this_00);
}
*(NodeDecorator **)this = pNVar2;
*(int8 **)(this + 8) = puVar1;
return this;
}
| |
25,947 | get_current_logfile | eloqsql/storage/maria/ma_loghandler.c | static TRANSLOG_FILE *get_current_logfile()
{
TRANSLOG_FILE *file;
DBUG_ENTER("get_current_logfile");
mysql_rwlock_rdlock(&log_descriptor.open_files_lock);
DBUG_PRINT("info", ("max_file: %lu min_file: %lu open_files: %lu",
(ulong) log_descriptor.max_file,
(ulong) log_descriptor.min_file,
(ulong) log_descriptor.open_files.elements));
DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
log_descriptor.open_files.elements);
file= *dynamic_element(&log_descriptor.open_files, 0, TRANSLOG_FILE **);
mysql_rwlock_unlock(&log_descriptor.open_files_lock);
DBUG_RETURN(file);
} | O0 | c | get_current_logfile:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3e7a21(%rip), %rdi # 0x47b410
addq $0x258, %rdi # imm = 0x258
leaq 0xbf2b0(%rip), %rsi # 0x152cad
movl $0x43f, %edx # imm = 0x43F
callq 0x8f620
jmp 0x93a09
jmp 0x93a0b
jmp 0x93a0d
movq 0x3e7c24(%rip), %rax # 0x47b638
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0x3e79ee(%rip), %rdi # 0x47b410
addq $0x258, %rdi # imm = 0x258
callq 0x8e4b0
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
| get_current_logfile:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rdi, log_descriptor
add rdi, 258h
lea rsi, aWorkspaceLlm4b_17; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 43Fh
call inline_mysql_rwlock_rdlock_0
jmp short $+2
loc_93A09:
jmp short $+2
loc_93A0B:
jmp short $+2
loc_93A0D:
mov rax, cs:qword_47B638
mov rax, [rax]
mov [rbp+var_8], rax
lea rdi, log_descriptor
add rdi, 258h
call inline_mysql_rwlock_unlock_2
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
add rsp, 10h
pop rbp
retn
| long long get_current_logfile()
{
long long v1; // [rsp+8h] [rbp-8h]
inline_mysql_rwlock_rdlock_0(
(long long)&log_descriptor[75],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x43Fu);
v1 = *(_QWORD *)qword_47B638;
inline_mysql_rwlock_unlock_2((long long)&log_descriptor[75]);
return v1;
}
| get_current_logfile:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RDI,[0x57b410]
ADD RDI,0x258
LEA RSI,[0x252cad]
MOV EDX,0x43f
CALL 0x0018f620
JMP 0x00193a09
LAB_00193a09:
JMP 0x00193a0b
LAB_00193a0b:
JMP 0x00193a0d
LAB_00193a0d:
MOV RAX,qword ptr [0x0057b638]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[0x57b410]
ADD RDI,0x258
CALL 0x0018e4b0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x10
POP RBP
RET
|
int8 get_current_logfile(void)
{
int8 uVar1;
inline_mysql_rwlock_rdlock
(&DAT_0057b668,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x43f);
uVar1 = *DAT_0057b638;
inline_mysql_rwlock_unlock(&DAT_0057b668);
return uVar1;
}
| |
25,948 | cpu_get_num_math() | monkey531[P]llama/common/common.cpp | int32_t cpu_get_num_math() {
#if defined(__x86_64__) && defined(__linux__) && !defined(__ANDROID__)
int n_cpu = sysconf(_SC_NPROCESSORS_ONLN);
if (n_cpu < 1) {
return cpu_get_num_physical_cores();
}
if (is_hybrid_cpu()) {
cpu_set_t affinity;
if (!pthread_getaffinity_np(pthread_self(), sizeof(affinity), &affinity)) {
int result = cpu_count_math_cpus(n_cpu);
pthread_setaffinity_np(pthread_self(), sizeof(affinity), &affinity);
if (result > 0) {
return result;
}
}
}
#endif
return cpu_get_num_physical_cores();
} | O3 | cpp | cpu_get_num_math():
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movl $0x54, %edi
callq 0x1a5a0
movq %rax, %rbx
testl %ebx, %ebx
jle 0x723dd
movl $0x7, %eax
xorl %ecx, %ecx
movq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
testw %dx, %dx
jns 0x72406
callq 0x1a780
movq %rax, %r14
leaq 0x80(%rsp), %rdx
movl $0x80, %esi
movq %rax, %rdi
callq 0x1af50
testl %eax, %eax
jne 0x72406
xorl %r15d, %r15d
movq %rsp, %r12
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x3ff, %r15d # imm = 0x3FF
ja 0x7237f
movl $0x1, %eax
movl %r15d, %ecx
shlq %cl, %rax
movl %r15d, %ecx
shrl $0x6, %ecx
orq %rax, (%rsp,%rcx,8)
movl $0x80, %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x1af00
testl %eax, %eax
jne 0x723f1
xorl %ecx, %ecx
movl $0x1a, %eax
movq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
andl $0xff000000, %eax # imm = 0xFF000000
xorl %ecx, %ecx
cmpl $0x20000000, %eax # imm = 0x20000000
setne %cl
addl %ecx, %ebp
addl %ecx, %r15d
incl %r15d
cmpl %ebx, %r15d
jl 0x72337
leaq 0x80(%rsp), %rdx
movl $0x80, %esi
movq %r14, %rdi
callq 0x1af00
testl %ebp, %ebp
jne 0x7240d
jmp 0x72406
addq $0x100, %rsp # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x71f5c
leaq 0x80(%rsp), %rdx
movl $0x80, %esi
movq %r14, %rdi
callq 0x1af00
callq 0x71f5c
movl %eax, %ebp
movl %ebp, %eax
addq $0x100, %rsp # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _Z16cpu_get_num_mathv:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 100h
mov edi, 54h ; 'T'
call _sysconf
mov rbx, rax
test ebx, ebx
jle loc_723DD
mov eax, 7
xor ecx, ecx
mov rsi, rbx
cpuid
xchg rsi, rbx
test dx, dx
jns loc_72406
call _pthread_self
mov r14, rax
lea rdx, [rsp+128h+var_A8]
mov esi, 80h
mov rdi, rax
call _pthread_getaffinity_np
test eax, eax
jnz loc_72406
xor r15d, r15d
mov r12, rsp
xor ebp, ebp
loc_72337:
xorps xmm0, xmm0
movaps [rsp+128h+var_B8], xmm0
movaps [rsp+128h+var_C8], xmm0
movaps [rsp+128h+var_D8], xmm0
movaps [rsp+128h+var_E8], xmm0
movaps [rsp+128h+var_F8], xmm0
movaps [rsp+128h+var_108], xmm0
movaps [rsp+128h+var_118], xmm0
movaps [rsp+128h+var_128], xmm0
cmp r15d, 3FFh
ja short loc_7237F
mov eax, 1
mov ecx, r15d
shl rax, cl
mov ecx, r15d
shr ecx, 6
or qword ptr [rsp+rcx*8+128h+var_128], rax
loc_7237F:
mov esi, 80h
mov rdi, r14
mov rdx, r12
call _pthread_setaffinity_np
test eax, eax
jnz short loc_723F1
xor ecx, ecx
mov eax, 1Ah
mov rsi, rbx
cpuid
xchg rsi, rbx
and eax, 0FF000000h
xor ecx, ecx
cmp eax, 20000000h
setnz cl
add ebp, ecx
add r15d, ecx
inc r15d
cmp r15d, ebx
jl loc_72337
lea rdx, [rsp+128h+var_A8]
mov esi, 80h
mov rdi, r14
call _pthread_setaffinity_np
test ebp, ebp
jnz short loc_7240D
jmp short loc_72406
loc_723DD:
add rsp, 100h
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _Z26cpu_get_num_physical_coresv; cpu_get_num_physical_cores(void)
loc_723F1:
lea rdx, [rsp+128h+var_A8]
mov esi, 80h
mov rdi, r14
call _pthread_setaffinity_np
loc_72406:
call _Z26cpu_get_num_physical_coresv; cpu_get_num_physical_cores(void)
mov ebp, eax
loc_7240D:
mov eax, ebp
add rsp, 100h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long cpu_get_num_math(void)
{
long long v0; // rbx
long long v2; // rsi
long long v7; // rbx
long long v8; // rsi
long long v9; // rt0
long long v10; // r14
unsigned int v11; // r15d
unsigned int v12; // ebp
long long v13; // rcx
long long v14; // r8
long long v15; // r9
long long v17; // rsi
long long v22; // rcx
__int128 v24; // [rsp+0h] [rbp-128h] BYREF
__int128 v25; // [rsp+10h] [rbp-118h]
__int128 v26; // [rsp+20h] [rbp-108h]
__int128 v27; // [rsp+30h] [rbp-F8h]
__int128 v28; // [rsp+40h] [rbp-E8h]
__int128 v29; // [rsp+50h] [rbp-D8h]
__int128 v30; // [rsp+60h] [rbp-C8h]
__int128 v31; // [rsp+70h] [rbp-B8h]
_BYTE v32[168]; // [rsp+80h] [rbp-A8h] BYREF
v0 = sysconf(84LL);
if ( (int)v0 <= 0 )
return cpu_get_num_physical_cores();
_RAX = 7LL;
v2 = v0;
__asm { cpuid }
v9 = v2;
v8 = _RBX;
v7 = v9;
if ( (_RDX & 0x8000u) != 0LL )
{
v10 = pthread_self(84LL, v8, _RDX, _RCX);
if ( !(unsigned int)pthread_getaffinity_np(v10, 128LL, v32) )
{
v11 = 0;
v12 = 0;
do
{
v31 = 0LL;
v30 = 0LL;
v29 = 0LL;
v28 = 0LL;
v27 = 0LL;
v26 = 0LL;
v25 = 0LL;
v24 = 0LL;
if ( v11 <= 0x3FF )
*((_QWORD *)&v24 + (v11 >> 6)) |= 1LL << v11;
if ( (unsigned int)((long long ( *)(long long, long long, __int128 *))pthread_setaffinity_np)(
v10,
128LL,
&v24) )
{
pthread_setaffinity_np(
v10,
128LL,
v32,
v13,
v14,
v15,
v24,
*((_QWORD *)&v24 + 1),
v25,
*((_QWORD *)&v25 + 1),
v26,
*((_QWORD *)&v26 + 1),
v27,
*((_QWORD *)&v27 + 1),
v28,
*((_QWORD *)&v28 + 1),
v29,
*((_QWORD *)&v29 + 1),
v30,
*((_QWORD *)&v30 + 1),
v31,
*((_QWORD *)&v31 + 1));
return (unsigned int)cpu_get_num_physical_cores();
}
_RAX = 26LL;
v17 = v7;
__asm { cpuid }
v7 = v17;
v22 = (_RAX & 0xFF000000) != 0x20000000;
v12 += v22;
v11 += v22 + 1;
}
while ( (int)v11 < (int)v17 );
pthread_setaffinity_np(
v10,
128LL,
v32,
v22,
v14,
v15,
v24,
*((_QWORD *)&v24 + 1),
v25,
*((_QWORD *)&v25 + 1),
v26,
*((_QWORD *)&v26 + 1),
v27,
*((_QWORD *)&v27 + 1),
v28,
*((_QWORD *)&v28 + 1),
v29,
*((_QWORD *)&v29 + 1),
v30,
*((_QWORD *)&v30 + 1),
v31,
*((_QWORD *)&v31 + 1));
if ( v12 )
return v12;
}
}
return (unsigned int)cpu_get_num_physical_cores();
}
| cpu_get_num_math:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x100
MOV EDI,0x54
CALL 0x0011a5a0
MOV RBX,RAX
TEST EBX,EBX
JLE 0x001723dd
MOV EAX,0x7
XOR ECX,ECX
MOV RSI,RBX
CPUID
XCHG RBX,RSI
TEST DX,DX
JNS 0x00172406
CALL 0x0011a780
MOV R14,RAX
LEA RDX,[RSP + 0x80]
MOV ESI,0x80
MOV RDI,RAX
CALL 0x0011af50
TEST EAX,EAX
JNZ 0x00172406
XOR R15D,R15D
MOV R12,RSP
XOR EBP,EBP
LAB_00172337:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP],XMM0
CMP R15D,0x3ff
JA 0x0017237f
MOV EAX,0x1
MOV ECX,R15D
SHL RAX,CL
MOV ECX,R15D
SHR ECX,0x6
OR qword ptr [RSP + RCX*0x8],RAX
LAB_0017237f:
MOV ESI,0x80
MOV RDI,R14
MOV RDX,R12
CALL 0x0011af00
TEST EAX,EAX
JNZ 0x001723f1
XOR ECX,ECX
MOV EAX,0x1a
MOV RSI,RBX
CPUID
XCHG RBX,RSI
AND EAX,0xff000000
XOR ECX,ECX
CMP EAX,0x20000000
SETNZ CL
ADD EBP,ECX
ADD R15D,ECX
INC R15D
CMP R15D,EBX
JL 0x00172337
LEA RDX,[RSP + 0x80]
MOV ESI,0x80
MOV RDI,R14
CALL 0x0011af00
TEST EBP,EBP
JNZ 0x0017240d
JMP 0x00172406
LAB_001723dd:
ADD RSP,0x100
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00171f5c
LAB_001723f1:
LEA RDX,[RSP + 0x80]
MOV ESI,0x80
MOV RDI,R14
CALL 0x0011af00
LAB_00172406:
CALL 0x00171f5c
MOV EBP,EAX
LAB_0017240d:
MOV EAX,EBP
ADD RSP,0x100
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x0017239d) */
/* WARNING: Removing unreachable block (ram,0x001722fc) */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cpu_get_num_math() */
ulong cpu_get_num_math(void)
{
long lVar1;
uint *puVar2;
uint uVar3;
int iVar4;
long lVar5;
pthread_t __th;
ulong uVar6;
uint uVar7;
uint uVar8;
cpu_set_t local_128;
cpu_set_t local_a8;
lVar5 = sysconf(0x54);
if ((int)lVar5 < 1) {
uVar6 = cpu_get_num_physical_cores();
return uVar6;
}
lVar1 = cpuid_Extended_Feature_Enumeration_info(7);
if ((short)*(int4 *)(lVar1 + 8) < 0) {
__th = pthread_self();
iVar4 = pthread_getaffinity_np(__th,0x80,&local_a8);
if (iVar4 == 0) {
uVar8 = 0;
uVar7 = 0;
do {
local_128.__bits[0xe] = 0;
local_128.__bits[0xf] = 0;
local_128.__bits[0xc] = 0;
local_128.__bits[0xd] = 0;
local_128.__bits[10] = 0;
local_128.__bits[0xb] = 0;
local_128.__bits[8] = 0;
local_128.__bits[9] = 0;
local_128.__bits[6] = 0;
local_128.__bits[7] = 0;
local_128.__bits[4] = 0;
local_128.__bits[5] = 0;
local_128.__bits[2] = 0;
local_128.__bits[3] = 0;
local_128.__bits[0] = 0;
local_128.__bits[1] = 0;
if (uVar8 < 0x400) {
local_128.__bits[uVar8 >> 6] = local_128.__bits[uVar8 >> 6] | 1L << ((byte)uVar8 & 0x3f);
}
iVar4 = pthread_setaffinity_np(__th,0x80,&local_128);
if (iVar4 != 0) {
pthread_setaffinity_np(__th,0x80,&local_a8);
goto LAB_00172406;
}
puVar2 = (uint *)cpuid(0x1a);
uVar3 = (uint)((*puVar2 & 0xff000000) != 0x20000000);
uVar7 = uVar7 + uVar3;
uVar8 = uVar8 + uVar3 + 1;
} while ((int)uVar8 < (int)lVar5);
pthread_setaffinity_np(__th,0x80,&local_a8);
if (uVar7 != 0) goto LAB_0017240d;
}
}
LAB_00172406:
uVar7 = cpu_get_num_physical_cores();
LAB_0017240d:
return (ulong)uVar7;
}
| |
25,949 | js_for_in_next | bluesky950520[P]quickjs/quickjs.c | static __exception int js_for_in_next(JSContext *ctx, JSValue *sp)
{
JSValue enum_obj;
JSObject *p;
JSAtom prop;
JSForInIterator *it;
int ret;
enum_obj = sp[-1];
/* fail safe */
if (JS_VALUE_GET_TAG(enum_obj) != JS_TAG_OBJECT)
goto done;
p = JS_VALUE_GET_OBJ(enum_obj);
if (p->class_id != JS_CLASS_FOR_IN_ITERATOR)
goto done;
it = p->u.for_in_iterator;
for(;;) {
if (it->is_array) {
if (it->idx >= it->array_length)
goto done;
prop = __JS_AtomFromUInt32(it->idx);
it->idx++;
} else {
JSShape *sh = p->shape;
JSShapeProperty *prs;
if (it->idx >= sh->prop_count)
goto done;
prs = get_shape_prop(sh) + it->idx;
prop = prs->atom;
it->idx++;
if (prop == JS_ATOM_NULL || !(prs->flags & JS_PROP_ENUMERABLE))
continue;
}
// check if the property was deleted unless we're dealing with a proxy
JSValue obj = it->obj;
if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
JSObject *p = JS_VALUE_GET_OBJ(obj);
if (p->class_id == JS_CLASS_PROXY)
break;
}
ret = JS_HasProperty(ctx, obj, prop);
if (ret < 0)
return ret;
if (ret)
break;
}
/* return the property */
sp[0] = JS_AtomToValue(ctx, prop);
sp[1] = JS_FALSE;
return 0;
done:
/* return the end */
sp[0] = JS_UNDEFINED;
sp[1] = JS_TRUE;
return 0;
} | O0 | c | js_for_in_next:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq -0x10(%rax), %rcx
movq %rcx, 0x90(%rsp)
movq -0x8(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
cmpl $-0x1, %eax
je 0x6db99
jmp 0x6dd9c
movq 0x90(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x11, %eax
je 0x6dbbf
jmp 0x6dd9c
movq 0x88(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x6dc19
movq 0x78(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x78(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jb 0x6dbf2
jmp 0x6dd9c
movq 0x78(%rsp), %rax
movl 0x18(%rax), %edi
callq 0x2e8a0
movl %eax, 0x84(%rsp)
movq 0x78(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x6dc9f
movq 0x88(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x68(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jb 0x6dc41
jmp 0x6dd9c
movq 0x68(%rsp), %rdi
callq 0x32570
movq 0x78(%rsp), %rcx
movl 0x18(%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x84(%rsp)
movq 0x78(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
cmpl $0x0, 0x84(%rsp)
je 0x6dc98
movq 0x60(%rsp), %rax
movl (%rax), %eax
shrl $0x1a, %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x6dc9d
jmp 0x6dbd0
jmp 0x6dc9f
movq 0x78(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
cmpl $-0x1, %eax
jne 0x6dcdb
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x30, %eax
jne 0x6dcd9
jmp 0x6dd22
jmp 0x6dcdb
movq 0xa8(%rsp), %rdi
movl 0x84(%rsp), %ecx
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x371c0
movl %eax, 0x74(%rsp)
cmpl $0x0, 0x74(%rsp)
jge 0x6dd14
movl 0x74(%rsp), %eax
movl %eax, 0xb4(%rsp)
jmp 0x6ddfc
cmpl $0x0, 0x74(%rsp)
je 0x6dd1d
jmp 0x6dd22
jmp 0x6dbd0
movq 0xa0(%rsp), %rax
movq %rax, (%rsp)
movq 0xa8(%rsp), %rdi
movl 0x84(%rsp), %esi
callq 0x2f120
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xa0(%rsp), %rax
movl $0x0, 0x28(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, 0xb4(%rsp)
jmp 0x6ddfc
movq 0xa0(%rsp), %rax
movl $0x0, 0x18(%rsp)
movq $0x3, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xa0(%rsp), %rax
movl $0x1, 0x8(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nopl (%rax,%rax)
| js_for_in_next:
sub rsp, 0B8h
mov [rsp+0B8h+var_10], rdi
mov [rsp+0B8h+var_18], rsi
mov rax, [rsp+0B8h+var_18]
mov rcx, [rax-10h]
mov [rsp+0B8h+var_28], rcx
mov rax, [rax-8]
mov [rsp+0B8h+var_20], rax
mov rax, [rsp+0B8h+var_20]
cmp eax, 0FFFFFFFFh
jz short loc_6DB99
jmp loc_6DD9C
loc_6DB99:
mov rax, [rsp+0B8h+var_28]
mov [rsp+0B8h+var_30], rax
mov rax, [rsp+0B8h+var_30]
movzx eax, word ptr [rax+6]
cmp eax, 11h
jz short loc_6DBBF
jmp loc_6DD9C
loc_6DBBF:
mov rax, [rsp+0B8h+var_30]
mov rax, [rax+30h]
mov [rsp+0B8h+var_40], rax
loc_6DBD0:
mov rax, [rsp+0B8h+var_40]
cmp dword ptr [rax+10h], 0
jz short loc_6DC19
mov rax, [rsp+0B8h+var_40]
mov eax, [rax+18h]
mov rcx, [rsp+0B8h+var_40]
cmp eax, [rcx+14h]
jb short loc_6DBF2
jmp loc_6DD9C
loc_6DBF2:
mov rax, [rsp+0B8h+var_40]
mov edi, [rax+18h]
call __JS_AtomFromUInt32
mov [rsp+0B8h+var_34], eax
mov rax, [rsp+0B8h+var_40]
mov ecx, [rax+18h]
add ecx, 1
mov [rax+18h], ecx
jmp loc_6DC9F
loc_6DC19:
mov rax, [rsp+0B8h+var_30]
mov rax, [rax+18h]
mov [rsp+0B8h+var_50], rax
mov rax, [rsp+0B8h+var_40]
mov eax, [rax+18h]
mov rcx, [rsp+0B8h+var_50]
cmp eax, [rcx+28h]
jb short loc_6DC41
jmp loc_6DD9C
loc_6DC41:
mov rdi, [rsp+0B8h+var_50]
call get_shape_prop
mov rcx, [rsp+0B8h+var_40]
mov ecx, [rcx+18h]
shl rcx, 3
add rax, rcx
mov [rsp+0B8h+var_58], rax
mov rax, [rsp+0B8h+var_58]
mov eax, [rax+4]
mov [rsp+0B8h+var_34], eax
mov rax, [rsp+0B8h+var_40]
mov ecx, [rax+18h]
add ecx, 1
mov [rax+18h], ecx
cmp [rsp+0B8h+var_34], 0
jz short loc_6DC98
mov rax, [rsp+0B8h+var_58]
mov eax, [rax]
shr eax, 1Ah
and eax, 4
cmp eax, 0
jnz short loc_6DC9D
loc_6DC98:
jmp loc_6DBD0
loc_6DC9D:
jmp short $+2
loc_6DC9F:
mov rax, [rsp+0B8h+var_40]
mov rcx, [rax]
mov [rsp+0B8h+var_68], rcx
mov rax, [rax+8]
mov [rsp+0B8h+var_60], rax
mov rax, [rsp+0B8h+var_60]
cmp eax, 0FFFFFFFFh
jnz short loc_6DCDB
mov rax, [rsp+0B8h+var_68]
mov [rsp+0B8h+var_70], rax
mov rax, [rsp+0B8h+var_70]
movzx eax, word ptr [rax+6]
cmp eax, 30h ; '0'
jnz short loc_6DCD9
jmp short loc_6DD22
loc_6DCD9:
jmp short $+2
loc_6DCDB:
mov rdi, [rsp+0B8h+var_10]
mov ecx, [rsp+0B8h+var_34]
mov rsi, [rsp+0B8h+var_68]
mov rdx, [rsp+0B8h+var_60]
call JS_HasProperty
mov [rsp+0B8h+var_44], eax
cmp [rsp+0B8h+var_44], 0
jge short loc_6DD14
mov eax, [rsp+0B8h+var_44]
mov [rsp+0B8h+var_4], eax
jmp loc_6DDFC
loc_6DD14:
cmp [rsp+0B8h+var_44], 0
jz short loc_6DD1D
jmp short loc_6DD22
loc_6DD1D:
jmp loc_6DBD0
loc_6DD22:
mov rax, [rsp+0B8h+var_18]
mov [rsp+0B8h+var_B8], rax
mov rdi, [rsp+0B8h+var_10]
mov esi, [rsp+0B8h+var_34]
call JS_AtomToValue
mov rcx, rax
mov rax, [rsp+0B8h+var_B8]
mov [rsp+0B8h+var_80], rcx
mov [rsp+0B8h+var_78], rdx
mov rcx, [rsp+0B8h+var_80]
mov [rax], rcx
mov rcx, [rsp+0B8h+var_78]
mov [rax+8], rcx
mov rax, [rsp+0B8h+var_18]
mov dword ptr [rsp+0B8h+var_90], 0
mov [rsp+0B8h+var_88], 1
mov rcx, [rsp+0B8h+var_90]
mov [rax+10h], rcx
mov rcx, [rsp+0B8h+var_88]
mov [rax+18h], rcx
mov [rsp+0B8h+var_4], 0
jmp short loc_6DDFC
loc_6DD9C:
mov rax, [rsp+0B8h+var_18]
mov dword ptr [rsp+0B8h+var_A0], 0
mov [rsp+0B8h+var_98], 3
mov rcx, [rsp+0B8h+var_A0]
mov [rax], rcx
mov rcx, [rsp+0B8h+var_98]
mov [rax+8], rcx
mov rax, [rsp+0B8h+var_18]
mov dword ptr [rsp+0B8h+var_B0], 1
mov [rsp+0B8h+var_A8], 1
mov rcx, [rsp+0B8h+var_B0]
mov [rax+10h], rcx
mov rcx, [rsp+0B8h+var_A8]
mov [rax+18h], rcx
mov [rsp+0B8h+var_4], 0
loc_6DDFC:
mov eax, [rsp+0B8h+var_4]
add rsp, 0B8h
retn
| long long js_for_in_next(long long a1, long long *a2)
{
long long v2; // rdx
long long v4; // [rsp+8h] [rbp-B0h]
long long v5; // [rsp+18h] [rbp-A0h]
long long v6; // [rsp+28h] [rbp-90h]
long long v7; // [rsp+50h] [rbp-68h]
long long v8; // [rsp+58h] [rbp-60h]
_DWORD *v9; // [rsp+60h] [rbp-58h]
long long v10; // [rsp+68h] [rbp-50h]
int HasProperty; // [rsp+74h] [rbp-44h]
long long v12; // [rsp+78h] [rbp-40h]
unsigned int v13; // [rsp+84h] [rbp-34h]
long long v14; // [rsp+90h] [rbp-28h]
v14 = *(a2 - 2);
if ( (unsigned int)*(a2 - 1) != -1 || *(_WORD *)(v14 + 6) != 17 )
{
LABEL_17:
LODWORD(v5) = 0;
*a2 = v5;
a2[1] = 3LL;
LODWORD(v4) = 1;
a2[2] = v4;
a2[3] = 1LL;
return 0;
}
v12 = *(_QWORD *)(v14 + 48);
do
{
while ( !*(_DWORD *)(v12 + 16) )
{
v10 = *(_QWORD *)(v14 + 24);
if ( *(_DWORD *)(v12 + 24) >= *(_DWORD *)(v10 + 40) )
goto LABEL_17;
v9 = (_DWORD *)(8LL * *(unsigned int *)(v12 + 24) + get_shape_prop(v10));
v13 = v9[1];
++*(_DWORD *)(v12 + 24);
if ( v13 && ((*v9 >> 26) & 4) != 0 )
goto LABEL_11;
}
if ( *(_DWORD *)(v12 + 24) >= *(_DWORD *)(v12 + 20) )
goto LABEL_17;
v13 = _JS_AtomFromUInt32(*(_DWORD *)(v12 + 24));
++*(_DWORD *)(v12 + 24);
LABEL_11:
v7 = *(_QWORD *)v12;
v8 = *(_QWORD *)(v12 + 8);
if ( (_DWORD)v8 == -1 && *(_WORD *)(v7 + 6) == 48 )
break;
HasProperty = JS_HasProperty(a1, v7, v8, v13);
if ( HasProperty < 0 )
return (unsigned int)HasProperty;
}
while ( !HasProperty );
*a2 = JS_AtomToValue(a1, v13);
a2[1] = v2;
LODWORD(v6) = 0;
a2[2] = v6;
a2[3] = 1LL;
return 0;
}
| js_for_in_next:
SUB RSP,0xb8
MOV qword ptr [RSP + 0xa8],RDI
MOV qword ptr [RSP + 0xa0],RSI
MOV RAX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RAX + -0x10]
MOV qword ptr [RSP + 0x90],RCX
MOV RAX,qword ptr [RAX + -0x8]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x98]
CMP EAX,-0x1
JZ 0x0016db99
JMP 0x0016dd9c
LAB_0016db99:
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x11
JZ 0x0016dbbf
JMP 0x0016dd9c
LAB_0016dbbf:
MOV RAX,qword ptr [RSP + 0x88]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x78],RAX
LAB_0016dbd0:
MOV RAX,qword ptr [RSP + 0x78]
CMP dword ptr [RAX + 0x10],0x0
JZ 0x0016dc19
MOV RAX,qword ptr [RSP + 0x78]
MOV EAX,dword ptr [RAX + 0x18]
MOV RCX,qword ptr [RSP + 0x78]
CMP EAX,dword ptr [RCX + 0x14]
JC 0x0016dbf2
JMP 0x0016dd9c
LAB_0016dbf2:
MOV RAX,qword ptr [RSP + 0x78]
MOV EDI,dword ptr [RAX + 0x18]
CALL 0x0012e8a0
MOV dword ptr [RSP + 0x84],EAX
MOV RAX,qword ptr [RSP + 0x78]
MOV ECX,dword ptr [RAX + 0x18]
ADD ECX,0x1
MOV dword ptr [RAX + 0x18],ECX
JMP 0x0016dc9f
LAB_0016dc19:
MOV RAX,qword ptr [RSP + 0x88]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV EAX,dword ptr [RAX + 0x18]
MOV RCX,qword ptr [RSP + 0x68]
CMP EAX,dword ptr [RCX + 0x28]
JC 0x0016dc41
JMP 0x0016dd9c
LAB_0016dc41:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00132570
MOV RCX,qword ptr [RSP + 0x78]
MOV ECX,dword ptr [RCX + 0x18]
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RSP + 0x84],EAX
MOV RAX,qword ptr [RSP + 0x78]
MOV ECX,dword ptr [RAX + 0x18]
ADD ECX,0x1
MOV dword ptr [RAX + 0x18],ECX
CMP dword ptr [RSP + 0x84],0x0
JZ 0x0016dc98
MOV RAX,qword ptr [RSP + 0x60]
MOV EAX,dword ptr [RAX]
SHR EAX,0x1a
AND EAX,0x4
CMP EAX,0x0
JNZ 0x0016dc9d
LAB_0016dc98:
JMP 0x0016dbd0
LAB_0016dc9d:
JMP 0x0016dc9f
LAB_0016dc9f:
MOV RAX,qword ptr [RSP + 0x78]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0x50],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x58]
CMP EAX,-0x1
JNZ 0x0016dcdb
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x30
JNZ 0x0016dcd9
JMP 0x0016dd22
LAB_0016dcd9:
JMP 0x0016dcdb
LAB_0016dcdb:
MOV RDI,qword ptr [RSP + 0xa8]
MOV ECX,dword ptr [RSP + 0x84]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
CALL 0x001371c0
MOV dword ptr [RSP + 0x74],EAX
CMP dword ptr [RSP + 0x74],0x0
JGE 0x0016dd14
MOV EAX,dword ptr [RSP + 0x74]
MOV dword ptr [RSP + 0xb4],EAX
JMP 0x0016ddfc
LAB_0016dd14:
CMP dword ptr [RSP + 0x74],0x0
JZ 0x0016dd1d
JMP 0x0016dd22
LAB_0016dd1d:
JMP 0x0016dbd0
LAB_0016dd22:
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0xa8]
MOV ESI,dword ptr [RSP + 0x84]
CALL 0x0012f120
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],RDX
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0xa0]
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x1
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x18],RCX
MOV dword ptr [RSP + 0xb4],0x0
JMP 0x0016ddfc
LAB_0016dd9c:
MOV RAX,qword ptr [RSP + 0xa0]
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x3
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0xa0]
MOV dword ptr [RSP + 0x8],0x1
MOV qword ptr [RSP + 0x10],0x1
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV dword ptr [RSP + 0xb4],0x0
LAB_0016ddfc:
MOV EAX,dword ptr [RSP + 0xb4]
ADD RSP,0xb8
RET
|
int js_for_in_next(int8 param_1,int1 (*param_2) [16])
{
long lVar1;
long *plVar2;
int iVar3;
long lVar4;
uint *puVar5;
int1 auVar6 [16];
int4 uStack_ac;
uint uStack_9c;
uint uStack_8c;
uint local_34;
lVar1 = *(long *)param_2[-1];
if (((int)*(int8 *)(param_2[-1] + 8) == -1) && (*(short *)(lVar1 + 6) == 0x11)) {
plVar2 = *(long **)(lVar1 + 0x30);
LAB_0016dbd0:
do {
if ((int)plVar2[2] == 0) {
if (*(uint *)(*(long *)(lVar1 + 0x18) + 0x28) <= *(uint *)(plVar2 + 3)) goto LAB_0016dd9c;
lVar4 = get_shape_prop(*(long *)(lVar1 + 0x18));
puVar5 = (uint *)(lVar4 + (ulong)*(uint *)(plVar2 + 3) * 8);
local_34 = puVar5[1];
*(int *)(plVar2 + 3) = (int)plVar2[3] + 1;
if ((local_34 == 0) || ((*puVar5 >> 0x1a & 4) == 0)) goto LAB_0016dbd0;
}
else {
if (*(uint *)((long)plVar2 + 0x14) <= *(uint *)(plVar2 + 3)) goto LAB_0016dd9c;
local_34 = __JS_AtomFromUInt32((int)plVar2[3]);
*(int *)(plVar2 + 3) = (int)plVar2[3] + 1;
}
if (((int)plVar2[1] == -1) && (*(short *)(*plVar2 + 6) == 0x30)) break;
iVar3 = JS_HasProperty(param_1,*plVar2,plVar2[1],local_34);
if (iVar3 < 0) {
return iVar3;
}
} while (iVar3 == 0);
auVar6 = JS_AtomToValue(param_1,local_34);
*param_2 = auVar6;
*(ulong *)param_2[1] = (ulong)uStack_8c << 0x20;
*(int8 *)(param_2[1] + 8) = 1;
}
else {
LAB_0016dd9c:
*(ulong *)*param_2 = (ulong)uStack_9c << 0x20;
*(int8 *)(*param_2 + 8) = 3;
*(ulong *)param_2[1] = CONCAT44(uStack_ac,1);
*(int8 *)(param_2[1] + 8) = 1;
}
return 0;
}
| |
25,950 | rlCompileShader | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | unsigned int rlCompileShader(const char *shaderCode, int type)
{
unsigned int shader = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
shader = glCreateShader(type);
glShaderSource(shader, 1, &shaderCode, NULL);
GLint success = 0;
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (success == GL_FALSE)
{
switch (type)
{
case GL_VERTEX_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shader); break;
case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shader); break;
//case GL_GEOMETRY_SHADER:
#if defined(GRAPHICS_API_OPENGL_43)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shader); break;
#elif defined(GRAPHICS_API_OPENGL_33)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shader); break;
#endif
default: break;
}
int maxLength = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
if (maxLength > 0)
{
int length = 0;
char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
glGetShaderInfoLog(shader, maxLength, &length, log);
TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader, log);
RL_FREE(log);
}
shader = 0;
}
else
{
switch (type)
{
case GL_VERTEX_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shader); break;
case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shader); break;
//case GL_GEOMETRY_SHADER:
#if defined(GRAPHICS_API_OPENGL_43)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shader); break;
#elif defined(GRAPHICS_API_OPENGL_33)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shader); break;
#endif
default: break;
}
}
#endif
return shader;
} | O0 | c | rlCompileShader:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq 0x16159b(%rip), %rax # 0x2186a8
movl -0xc(%rbp), %edi
callq *%rax
movl %eax, -0x10(%rbp)
movq 0x16275c(%rip), %rax # 0x219878
movl -0x10(%rbp), %edi
movl $0x1, %esi
leaq -0x8(%rbp), %rdx
xorl %ecx, %ecx
callq *%rax
movl $0x0, -0x14(%rbp)
movq 0x161436(%rip), %rax # 0x218570
movl -0x10(%rbp), %edi
callq *%rax
movq 0x161d22(%rip), %rax # 0x218e68
movl -0x10(%rbp), %edi
movl $0x8b81, %esi # imm = 0x8B81
leaq -0x14(%rbp), %rdx
callq *%rax
cmpl $0x0, -0x14(%rbp)
jne 0xb724d
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x8b30, %eax # imm = 0x8B30
je 0xb719d
jmp 0xb716d
movl -0x2c(%rbp), %eax
subl $0x8b31, %eax # imm = 0x8B31
je 0xb7185
jmp 0xb7179
movl -0x2c(%rbp), %eax
subl $0x91b9, %eax # imm = 0x91B9
je 0xb71b5
jmp 0xb71cd
movl -0x10(%rbp), %edx
movl $0x4, %edi
leaq 0xfdd2c(%rip), %rsi # 0x1b4ec0
movb $0x0, %al
callq 0x182c40
jmp 0xb71cf
movl -0x10(%rbp), %edx
movl $0x4, %edi
leaq 0xfdd49(%rip), %rsi # 0x1b4ef5
movb $0x0, %al
callq 0x182c40
jmp 0xb71cf
movl -0x10(%rbp), %edx
movl $0x4, %edi
leaq 0xfdd68(%rip), %rsi # 0x1b4f2c
movb $0x0, %al
callq 0x182c40
jmp 0xb71cf
jmp 0xb71cf
movl $0x0, -0x18(%rbp)
movq 0x161c8b(%rip), %rax # 0x218e68
movl -0x10(%rbp), %edi
movl $0x8b84, %esi # imm = 0x8B84
leaq -0x18(%rbp), %rdx
callq *%rax
cmpl $0x0, -0x18(%rbp)
jle 0xb7244
movl $0x0, -0x1c(%rbp)
movslq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xa340
movq %rax, -0x28(%rbp)
movq 0x161c37(%rip), %rax # 0x218e48
movl -0x10(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x28(%rbp), %rcx
leaq -0x1c(%rbp), %rdx
callq *%rax
movl -0x10(%rbp), %edx
movq -0x28(%rbp), %rcx
movl $0x4, %edi
leaq 0xfdd3b(%rip), %rsi # 0x1b4f6f
movb $0x0, %al
callq 0x182c40
movq -0x28(%rbp), %rdi
callq 0xa640
movl $0x0, -0x10(%rbp)
jmp 0xb72c0
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x8b30, %eax # imm = 0x8B30
je 0xb728c
jmp 0xb725c
movl -0x30(%rbp), %eax
subl $0x8b31, %eax # imm = 0x8B31
je 0xb7274
jmp 0xb7268
movl -0x30(%rbp), %eax
subl $0x91b9, %eax # imm = 0x91B9
je 0xb72a4
jmp 0xb72bc
movl -0x10(%rbp), %edx
movl $0x3, %edi
leaq 0xfdd0e(%rip), %rsi # 0x1b4f91
movb $0x0, %al
callq 0x182c40
jmp 0xb72be
movl -0x10(%rbp), %edx
movl $0x3, %edi
leaq 0xfdd2a(%rip), %rsi # 0x1b4fc5
movb $0x0, %al
callq 0x182c40
jmp 0xb72be
movl -0x10(%rbp), %edx
movl $0x4, %edi
leaq 0xfdc79(%rip), %rsi # 0x1b4f2c
movb $0x0, %al
callq 0x182c40
jmp 0xb72be
jmp 0xb72be
jmp 0xb72c0
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| rlCompileShader:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], 0
mov rax, cs:glad_glCreateShader
mov edi, [rbp+var_C]
call rax ; glad_glCreateShader
mov [rbp+var_10], eax
mov rax, cs:glad_glShaderSource
mov edi, [rbp+var_10]
mov esi, 1
lea rdx, [rbp+var_8]
xor ecx, ecx
call rax ; glad_glShaderSource
mov [rbp+var_14], 0
mov rax, cs:glad_glCompileShader
mov edi, [rbp+var_10]
call rax ; glad_glCompileShader
mov rax, cs:glad_glGetShaderiv
mov edi, [rbp+var_10]
mov esi, 8B81h
lea rdx, [rbp+var_14]
call rax ; glad_glGetShaderiv
cmp [rbp+var_14], 0
jnz loc_B724D
mov eax, [rbp+var_C]
mov [rbp+var_2C], eax
sub eax, 8B30h
jz short loc_B719D
jmp short $+2
loc_B716D:
mov eax, [rbp+var_2C]
sub eax, 8B31h
jz short loc_B7185
jmp short $+2
loc_B7179:
mov eax, [rbp+var_2C]
sub eax, 91B9h
jz short loc_B71B5
jmp short loc_B71CD
loc_B7185:
mov edx, [rbp+var_10]
mov edi, 4
lea rsi, aShaderIdIFaile_0; "SHADER: [ID %i] Failed to compile verte"...
mov al, 0
call TraceLog
jmp short loc_B71CF
loc_B719D:
mov edx, [rbp+var_10]
mov edi, 4
lea rsi, aShaderIdIFaile_1; "SHADER: [ID %i] Failed to compile fragm"...
mov al, 0
call TraceLog
jmp short loc_B71CF
loc_B71B5:
mov edx, [rbp+var_10]
mov edi, 4
lea rsi, aShaderComputeS; "SHADER: Compute shaders not enabled. De"...
mov al, 0
call TraceLog
jmp short loc_B71CF
loc_B71CD:
jmp short $+2
loc_B71CF:
mov [rbp+var_18], 0
mov rax, cs:glad_glGetShaderiv
mov edi, [rbp+var_10]
mov esi, 8B84h
lea rdx, [rbp+var_18]
call rax ; glad_glGetShaderiv
cmp [rbp+var_18], 0
jle short loc_B7244
mov [rbp+var_1C], 0
movsxd rdi, [rbp+var_18]
mov esi, 1
call _calloc
mov [rbp+var_28], rax
mov rax, cs:glad_glGetShaderInfoLog
mov edi, [rbp+var_10]
mov esi, [rbp+var_18]
mov rcx, [rbp+var_28]
lea rdx, [rbp+var_1C]
call rax ; glad_glGetShaderInfoLog
mov edx, [rbp+var_10]
mov rcx, [rbp+var_28]
mov edi, 4
lea rsi, aShaderIdICompi; "SHADER: [ID %i] Compile error: %s"
mov al, 0
call TraceLog
mov rdi, [rbp+var_28]
call _free
loc_B7244:
mov [rbp+var_10], 0
jmp short loc_B72C0
loc_B724D:
mov eax, [rbp+var_C]
mov [rbp+var_30], eax
sub eax, 8B30h
jz short loc_B728C
jmp short $+2
loc_B725C:
mov eax, [rbp+var_30]
sub eax, 8B31h
jz short loc_B7274
jmp short $+2
loc_B7268:
mov eax, [rbp+var_30]
sub eax, 91B9h
jz short loc_B72A4
jmp short loc_B72BC
loc_B7274:
mov edx, [rbp+var_10]
mov edi, 3
lea rsi, aShaderIdIVerte; "SHADER: [ID %i] Vertex shader compiled "...
mov al, 0
call TraceLog
jmp short loc_B72BE
loc_B728C:
mov edx, [rbp+var_10]
mov edi, 3
lea rsi, aShaderIdIFragm; "SHADER: [ID %i] Fragment shader compile"...
mov al, 0
call TraceLog
jmp short loc_B72BE
loc_B72A4:
mov edx, [rbp+var_10]
mov edi, 4
lea rsi, aShaderComputeS; "SHADER: Compute shaders not enabled. De"...
mov al, 0
call TraceLog
jmp short loc_B72BE
loc_B72BC:
jmp short $+2
loc_B72BE:
jmp short $+2
loc_B72C0:
mov eax, [rbp+var_10]
add rsp, 30h
pop rbp
retn
| long long rlCompileShader(long long a1, unsigned int a2)
{
int v2; // ecx
int v3; // r8d
int v4; // r9d
int v5; // r8d
int v6; // r9d
long long v8; // [rsp+8h] [rbp-28h]
int v9; // [rsp+14h] [rbp-1Ch] BYREF
int v10; // [rsp+18h] [rbp-18h] BYREF
int v11; // [rsp+1Ch] [rbp-14h] BYREF
unsigned int Shader; // [rsp+20h] [rbp-10h]
unsigned int v13; // [rsp+24h] [rbp-Ch]
long long v14; // [rsp+28h] [rbp-8h] BYREF
v14 = a1;
v13 = a2;
Shader = glad_glCreateShader(a2);
glad_glShaderSource(Shader, 1LL, &v14, 0LL);
v11 = 0;
glad_glCompileShader(Shader);
glad_glGetShaderiv(Shader, 35713LL, &v11);
if ( v11 )
{
switch ( v13 )
{
case 0x8B30u:
TraceLog(3, (unsigned int)"SHADER: [ID %i] Fragment shader compiled successfully", Shader, v2, v3, v4);
break;
case 0x8B31u:
TraceLog(3, (unsigned int)"SHADER: [ID %i] Vertex shader compiled successfully", Shader, v2, v3, v4);
break;
case 0x91B9u:
TraceLog(
4,
(unsigned int)"SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43",
Shader,
v2,
v3,
v4);
break;
}
}
else
{
switch ( v13 )
{
case 0x8B30u:
TraceLog(4, (unsigned int)"SHADER: [ID %i] Failed to compile fragment shader code", Shader, v2, v3, v4);
break;
case 0x8B31u:
TraceLog(4, (unsigned int)"SHADER: [ID %i] Failed to compile vertex shader code", Shader, v2, v3, v4);
break;
case 0x91B9u:
TraceLog(
4,
(unsigned int)"SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43",
Shader,
v2,
v3,
v4);
break;
}
v10 = 0;
glad_glGetShaderiv(Shader, 35716LL, &v10);
if ( v10 > 0 )
{
v9 = 0;
v8 = calloc(v10, 1LL);
glad_glGetShaderInfoLog(Shader, (unsigned int)v10, &v9, v8);
TraceLog(4, (unsigned int)"SHADER: [ID %i] Compile error: %s", Shader, v8, v5, v6);
free(v8);
}
return 0;
}
return Shader;
}
| rlCompileShader:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [0x003186a8]
MOV EDI,dword ptr [RBP + -0xc]
CALL RAX
MOV dword ptr [RBP + -0x10],EAX
MOV RAX,qword ptr [0x00319878]
MOV EDI,dword ptr [RBP + -0x10]
MOV ESI,0x1
LEA RDX,[RBP + -0x8]
XOR ECX,ECX
CALL RAX
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [0x00318570]
MOV EDI,dword ptr [RBP + -0x10]
CALL RAX
MOV RAX,qword ptr [0x00318e68]
MOV EDI,dword ptr [RBP + -0x10]
MOV ESI,0x8b81
LEA RDX,[RBP + -0x14]
CALL RAX
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001b724d
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x2c],EAX
SUB EAX,0x8b30
JZ 0x001b719d
JMP 0x001b716d
LAB_001b716d:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x8b31
JZ 0x001b7185
JMP 0x001b7179
LAB_001b7179:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x91b9
JZ 0x001b71b5
JMP 0x001b71cd
LAB_001b7185:
MOV EDX,dword ptr [RBP + -0x10]
MOV EDI,0x4
LEA RSI,[0x2b4ec0]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001b71cf
LAB_001b719d:
MOV EDX,dword ptr [RBP + -0x10]
MOV EDI,0x4
LEA RSI,[0x2b4ef5]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001b71cf
LAB_001b71b5:
MOV EDX,dword ptr [RBP + -0x10]
MOV EDI,0x4
LEA RSI,[0x2b4f2c]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001b71cf
LAB_001b71cd:
JMP 0x001b71cf
LAB_001b71cf:
MOV dword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [0x00318e68]
MOV EDI,dword ptr [RBP + -0x10]
MOV ESI,0x8b84
LEA RDX,[RBP + -0x18]
CALL RAX
CMP dword ptr [RBP + -0x18],0x0
JLE 0x001b7244
MOV dword ptr [RBP + -0x1c],0x0
MOVSXD RDI,dword ptr [RBP + -0x18]
MOV ESI,0x1
CALL 0x0010a340
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [0x00318e48]
MOV EDI,dword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
LEA RDX,[RBP + -0x1c]
CALL RAX
MOV EDX,dword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV EDI,0x4
LEA RSI,[0x2b4f6f]
MOV AL,0x0
CALL 0x00282c40
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0010a640
LAB_001b7244:
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001b72c0
LAB_001b724d:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x30],EAX
SUB EAX,0x8b30
JZ 0x001b728c
JMP 0x001b725c
LAB_001b725c:
MOV EAX,dword ptr [RBP + -0x30]
SUB EAX,0x8b31
JZ 0x001b7274
JMP 0x001b7268
LAB_001b7268:
MOV EAX,dword ptr [RBP + -0x30]
SUB EAX,0x91b9
JZ 0x001b72a4
JMP 0x001b72bc
LAB_001b7274:
MOV EDX,dword ptr [RBP + -0x10]
MOV EDI,0x3
LEA RSI,[0x2b4f91]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001b72be
LAB_001b728c:
MOV EDX,dword ptr [RBP + -0x10]
MOV EDI,0x3
LEA RSI,[0x2b4fc5]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001b72be
LAB_001b72a4:
MOV EDX,dword ptr [RBP + -0x10]
MOV EDI,0x4
LEA RSI,[0x2b4f2c]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001b72be
LAB_001b72bc:
JMP 0x001b72be
LAB_001b72be:
JMP 0x001b72c0
LAB_001b72c0:
MOV EAX,dword ptr [RBP + -0x10]
ADD RSP,0x30
POP RBP
RET
|
int4 rlCompileShader(int8 param_1,int param_2)
{
void *__ptr;
int4 local_24;
int local_20;
int local_1c;
int4 local_18;
int local_14;
int8 local_10;
local_18 = 0;
local_14 = param_2;
local_10 = param_1;
local_18 = (*glad_glCreateShader)(param_2);
(*glad_glShaderSource)(local_18,1,&local_10,0);
local_1c = 0;
(*glad_glCompileShader)(local_18);
(*glad_glGetShaderiv)(local_18,0x8b81,&local_1c);
if (local_1c == 0) {
if (local_14 == 0x8b30) {
TraceLog(4,"SHADER: [ID %i] Failed to compile fragment shader code",local_18);
}
else if (local_14 == 0x8b31) {
TraceLog(4,"SHADER: [ID %i] Failed to compile vertex shader code",local_18);
}
else if (local_14 == 0x91b9) {
TraceLog(4,"SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43",local_18);
}
local_20 = 0;
(*glad_glGetShaderiv)(local_18,0x8b84,&local_20);
if (0 < local_20) {
local_24 = 0;
__ptr = calloc((long)local_20,1);
(*glad_glGetShaderInfoLog)(local_18,local_20,&local_24,__ptr);
TraceLog(4,"SHADER: [ID %i] Compile error: %s",local_18,__ptr);
free(__ptr);
}
local_18 = 0;
}
else if (local_14 == 0x8b30) {
TraceLog(3,"SHADER: [ID %i] Fragment shader compiled successfully",local_18);
}
else if (local_14 == 0x8b31) {
TraceLog(3,"SHADER: [ID %i] Vertex shader compiled successfully",local_18);
}
else if (local_14 == 0x91b9) {
TraceLog(4,"SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43",local_18);
}
return local_18;
}
| |
25,951 | rlCompileShader | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | unsigned int rlCompileShader(const char *shaderCode, int type)
{
unsigned int shader = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
shader = glCreateShader(type);
glShaderSource(shader, 1, &shaderCode, NULL);
GLint success = 0;
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (success == GL_FALSE)
{
switch (type)
{
case GL_VERTEX_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shader); break;
case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shader); break;
//case GL_GEOMETRY_SHADER:
#if defined(GRAPHICS_API_OPENGL_43)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shader); break;
#elif defined(GRAPHICS_API_OPENGL_33)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shader); break;
#endif
default: break;
}
int maxLength = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
if (maxLength > 0)
{
int length = 0;
char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
glGetShaderInfoLog(shader, maxLength, &length, log);
TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader, log);
RL_FREE(log);
}
shader = 0;
}
else
{
switch (type)
{
case GL_VERTEX_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shader); break;
case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shader); break;
//case GL_GEOMETRY_SHADER:
#if defined(GRAPHICS_API_OPENGL_43)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shader); break;
#elif defined(GRAPHICS_API_OPENGL_33)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shader); break;
#endif
default: break;
}
}
#endif
return shader;
} | O1 | c | rlCompileShader:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
leaq 0x18(%rsp), %r14
movq %rdi, (%r14)
movl %esi, %edi
callq *0xd8a55(%rip) # 0x13f5d8
movl %eax, %ebx
movl %eax, %edi
movl $0x1, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq *0xd9c11(%rip) # 0x1407a8
leaq 0x14(%rsp), %r14
movl $0x0, (%r14)
movl %ebx, %edi
callq *0xd88f5(%rip) # 0x13f4a0
movl %ebx, %edi
movl $0x8b81, %esi # imm = 0x8B81
movq %r14, %rdx
callq *0xd91dd(%rip) # 0x13fd98
cmpl $0x0, (%r14)
je 0x66be6
cmpl $0x8b30, %ebp # imm = 0x8B30
je 0x66c15
cmpl $0x91b9, %ebp # imm = 0x91B9
je 0x66c07
cmpl $0x8b31, %ebp # imm = 0x8B31
jne 0x66cc0
leaq 0x7e8d5(%rip), %rsi # 0xe54b9
jmp 0x66c1c
cmpl $0x91b9, %ebp # imm = 0x91B9
je 0x66c38
cmpl $0x8b31, %ebp # imm = 0x8B31
je 0x66c2f
cmpl $0x8b30, %ebp # imm = 0x8B30
jne 0x66c4d
leaq 0x7e818(%rip), %rsi # 0xe541d
jmp 0x66c3f
leaq 0x7e846(%rip), %rsi # 0xe5454
movl $0x4, %edi
jmp 0x66c21
leaq 0x7e8d1(%rip), %rsi # 0xe54ed
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0xbfa73
jmp 0x66cc0
leaq 0x7e7b2(%rip), %rsi # 0xe53e8
jmp 0x66c3f
leaq 0x7e815(%rip), %rsi # 0xe5454
movl $0x4, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0xbfa73
leaq 0x10(%rsp), %r14
movl $0x0, (%r14)
movl %ebx, %edi
movl $0x8b84, %esi # imm = 0x8B84
movq %r14, %rdx
callq *0xd912f(%rip) # 0x13fd98
movslq (%r14), %r14
testq %r14, %r14
jle 0x66cbe
leaq 0xc(%rsp), %r15
movl $0x0, (%r15)
movl $0x1, %esi
movq %r14, %rdi
callq 0x9330
movq %rax, %r12
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
movq %rax, %rcx
callq *0xd90da(%rip) # 0x13fd78
leaq 0x7e7f2(%rip), %rsi # 0xe5497
movl $0x4, %edi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0xbfa73
movq %r12, %rdi
callq 0x9650
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| rlCompileShader:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov ebp, esi
lea r14, [rsp+48h+var_30]
mov [r14], rdi
mov edi, esi
call cs:glad_glCreateShader
mov ebx, eax
mov edi, eax
mov esi, 1
mov rdx, r14
xor ecx, ecx
call cs:glad_glShaderSource
lea r14, [rsp+48h+var_34]
mov dword ptr [r14], 0
mov edi, ebx
call cs:glad_glCompileShader
mov edi, ebx
mov esi, 8B81h
mov rdx, r14
call cs:glad_glGetShaderiv
cmp dword ptr [r14], 0
jz short loc_66BE6
cmp ebp, 8B30h
jz short loc_66C15
cmp ebp, 91B9h
jz short loc_66C07
cmp ebp, 8B31h
jnz loc_66CC0
lea rsi, aShaderIdIVerte; "SHADER: [ID %i] Vertex shader compiled "...
jmp short loc_66C1C
loc_66BE6:
cmp ebp, 91B9h
jz short loc_66C38
cmp ebp, 8B31h
jz short loc_66C2F
cmp ebp, 8B30h
jnz short loc_66C4D
lea rsi, aShaderIdIFaile_0; "SHADER: [ID %i] Failed to compile fragm"...
jmp short loc_66C3F
loc_66C07:
lea rsi, aShaderComputeS; "SHADER: Compute shaders not enabled. De"...
mov edi, 4
jmp short loc_66C21
loc_66C15:
lea rsi, aShaderIdIFragm; "SHADER: [ID %i] Fragment shader compile"...
loc_66C1C:
mov edi, 3
loc_66C21:
mov edx, ebx
xor eax, eax
call TraceLog
jmp loc_66CC0
loc_66C2F:
lea rsi, aShaderIdIFaile_1; "SHADER: [ID %i] Failed to compile verte"...
jmp short loc_66C3F
loc_66C38:
lea rsi, aShaderComputeS; "SHADER: Compute shaders not enabled. De"...
loc_66C3F:
mov edi, 4
mov edx, ebx
xor eax, eax
call TraceLog
loc_66C4D:
lea r14, [rsp+48h+var_38]
mov dword ptr [r14], 0
mov edi, ebx
mov esi, 8B84h
mov rdx, r14
call cs:glad_glGetShaderiv
movsxd r14, dword ptr [r14]
test r14, r14
jle short loc_66CBE
lea r15, [rsp+48h+var_3C]
mov dword ptr [r15], 0
mov esi, 1
mov rdi, r14
call _calloc
mov r12, rax
mov edi, ebx
mov esi, r14d
mov rdx, r15
mov rcx, rax
call cs:glad_glGetShaderInfoLog
lea rsi, aShaderIdICompi; "SHADER: [ID %i] Compile error: %s"
mov edi, 4
mov edx, ebx
mov rcx, r12
xor eax, eax
call TraceLog
mov rdi, r12
call _free
loc_66CBE:
xor ebx, ebx
loc_66CC0:
mov eax, ebx
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long rlCompileShader(long long a1, unsigned int a2)
{
long long Shader; // rbx
int v3; // ecx
int v4; // r8d
int v5; // r9d
const char *v6; // rsi
const char *v7; // rsi
int v8; // edi
unsigned int v9; // r14d
long long v10; // r12
int v11; // r8d
int v12; // r9d
int v14; // [rsp+Ch] [rbp-3Ch] BYREF
unsigned int v15; // [rsp+10h] [rbp-38h] BYREF
int v16; // [rsp+14h] [rbp-34h] BYREF
_QWORD v17[6]; // [rsp+18h] [rbp-30h] BYREF
v17[0] = a1;
Shader = (unsigned int)glad_glCreateShader(a2);
glad_glShaderSource(Shader, 1LL, v17, 0LL);
v16 = 0;
glad_glCompileShader((unsigned int)Shader);
glad_glGetShaderiv((unsigned int)Shader, 35713LL, &v16);
if ( !v16 )
{
switch ( a2 )
{
case 0x91B9u:
v7 = "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43";
break;
case 0x8B31u:
v7 = "SHADER: [ID %i] Failed to compile vertex shader code";
break;
case 0x8B30u:
v7 = "SHADER: [ID %i] Failed to compile fragment shader code";
break;
default:
LABEL_17:
v15 = 0;
glad_glGetShaderiv((unsigned int)Shader, 35716LL, &v15);
v9 = v15;
if ( (int)v15 > 0LL )
{
v14 = 0;
v10 = calloc((int)v15, 1LL);
glad_glGetShaderInfoLog((unsigned int)Shader, v9, &v14, v10);
TraceLog(4, (unsigned int)"SHADER: [ID %i] Compile error: %s", Shader, v10, v11, v12);
free(v10);
}
LODWORD(Shader) = 0;
return (unsigned int)Shader;
}
TraceLog(4, (_DWORD)v7, Shader, v3, v4, v5);
goto LABEL_17;
}
switch ( a2 )
{
case 0x8B30u:
v6 = "SHADER: [ID %i] Fragment shader compiled successfully";
goto LABEL_12;
case 0x91B9u:
v6 = "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43";
v8 = 4;
LABEL_13:
TraceLog(v8, (_DWORD)v6, Shader, v3, v4, v5);
return (unsigned int)Shader;
case 0x8B31u:
v6 = "SHADER: [ID %i] Vertex shader compiled successfully";
LABEL_12:
v8 = 3;
goto LABEL_13;
}
return (unsigned int)Shader;
}
| rlCompileShader:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV EBP,ESI
LEA R14,[RSP + 0x18]
MOV qword ptr [R14],RDI
MOV EDI,ESI
CALL qword ptr [0x0023f5d8]
MOV EBX,EAX
MOV EDI,EAX
MOV ESI,0x1
MOV RDX,R14
XOR ECX,ECX
CALL qword ptr [0x002407a8]
LEA R14,[RSP + 0x14]
MOV dword ptr [R14],0x0
MOV EDI,EBX
CALL qword ptr [0x0023f4a0]
MOV EDI,EBX
MOV ESI,0x8b81
MOV RDX,R14
CALL qword ptr [0x0023fd98]
CMP dword ptr [R14],0x0
JZ 0x00166be6
CMP EBP,0x8b30
JZ 0x00166c15
CMP EBP,0x91b9
JZ 0x00166c07
CMP EBP,0x8b31
JNZ 0x00166cc0
LEA RSI,[0x1e54b9]
JMP 0x00166c1c
LAB_00166be6:
CMP EBP,0x91b9
JZ 0x00166c38
CMP EBP,0x8b31
JZ 0x00166c2f
CMP EBP,0x8b30
JNZ 0x00166c4d
LEA RSI,[0x1e541d]
JMP 0x00166c3f
LAB_00166c07:
LEA RSI,[0x1e5454]
MOV EDI,0x4
JMP 0x00166c21
LAB_00166c15:
LEA RSI,[0x1e54ed]
LAB_00166c1c:
MOV EDI,0x3
LAB_00166c21:
MOV EDX,EBX
XOR EAX,EAX
CALL 0x001bfa73
JMP 0x00166cc0
LAB_00166c2f:
LEA RSI,[0x1e53e8]
JMP 0x00166c3f
LAB_00166c38:
LEA RSI,[0x1e5454]
LAB_00166c3f:
MOV EDI,0x4
MOV EDX,EBX
XOR EAX,EAX
CALL 0x001bfa73
LAB_00166c4d:
LEA R14,[RSP + 0x10]
MOV dword ptr [R14],0x0
MOV EDI,EBX
MOV ESI,0x8b84
MOV RDX,R14
CALL qword ptr [0x0023fd98]
MOVSXD R14,dword ptr [R14]
TEST R14,R14
JLE 0x00166cbe
LEA R15,[RSP + 0xc]
MOV dword ptr [R15],0x0
MOV ESI,0x1
MOV RDI,R14
CALL 0x00109330
MOV R12,RAX
MOV EDI,EBX
MOV ESI,R14D
MOV RDX,R15
MOV RCX,RAX
CALL qword ptr [0x0023fd78]
LEA RSI,[0x1e5497]
MOV EDI,0x4
MOV EDX,EBX
MOV RCX,R12
XOR EAX,EAX
CALL 0x001bfa73
MOV RDI,R12
CALL 0x00109650
LAB_00166cbe:
XOR EBX,EBX
LAB_00166cc0:
MOV EAX,EBX
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int4 rlCompileShader(int8 param_1,int param_2)
{
int iVar1;
int4 uVar2;
void *__ptr;
char *pcVar3;
int8 uVar4;
int4 local_3c;
int local_38;
int local_34;
int8 local_30;
local_30 = param_1;
uVar2 = (*glad_glCreateShader)(param_2);
(*glad_glShaderSource)(uVar2,1,&local_30,0);
local_34 = 0;
(*glad_glCompileShader)(uVar2);
(*glad_glGetShaderiv)(uVar2,0x8b81,&local_34);
if (local_34 == 0) {
if (param_2 == 0x91b9) {
pcVar3 = "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43";
}
else if (param_2 == 0x8b31) {
pcVar3 = "SHADER: [ID %i] Failed to compile vertex shader code";
}
else {
if (param_2 != 0x8b30) goto LAB_00166c4d;
pcVar3 = "SHADER: [ID %i] Failed to compile fragment shader code";
}
TraceLog(4,pcVar3,uVar2);
LAB_00166c4d:
local_38 = 0;
(*glad_glGetShaderiv)(uVar2,0x8b84,&local_38);
iVar1 = local_38;
if (0 < (long)local_38) {
local_3c = 0;
__ptr = calloc((long)local_38,1);
(*glad_glGetShaderInfoLog)(uVar2,iVar1,&local_3c,__ptr);
TraceLog(4,"SHADER: [ID %i] Compile error: %s",uVar2,__ptr);
free(__ptr);
}
return 0;
}
if (param_2 == 0x8b30) {
pcVar3 = "SHADER: [ID %i] Fragment shader compiled successfully";
}
else {
if (param_2 == 0x91b9) {
pcVar3 = "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43";
uVar4 = 4;
goto LAB_00166c21;
}
if (param_2 != 0x8b31) {
return uVar2;
}
pcVar3 = "SHADER: [ID %i] Vertex shader compiled successfully";
}
uVar4 = 3;
LAB_00166c21:
TraceLog(uVar4,pcVar3,uVar2);
return uVar2;
}
| |
25,952 | rlCompileShader | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | unsigned int rlCompileShader(const char *shaderCode, int type)
{
unsigned int shader = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
shader = glCreateShader(type);
glShaderSource(shader, 1, &shaderCode, NULL);
GLint success = 0;
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (success == GL_FALSE)
{
switch (type)
{
case GL_VERTEX_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shader); break;
case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shader); break;
//case GL_GEOMETRY_SHADER:
#if defined(GRAPHICS_API_OPENGL_43)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shader); break;
#elif defined(GRAPHICS_API_OPENGL_33)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shader); break;
#endif
default: break;
}
int maxLength = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
if (maxLength > 0)
{
int length = 0;
char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
glGetShaderInfoLog(shader, maxLength, &length, log);
TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader, log);
RL_FREE(log);
}
shader = 0;
}
else
{
switch (type)
{
case GL_VERTEX_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shader); break;
case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shader); break;
//case GL_GEOMETRY_SHADER:
#if defined(GRAPHICS_API_OPENGL_43)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shader); break;
#elif defined(GRAPHICS_API_OPENGL_33)
case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shader); break;
#endif
default: break;
}
}
#endif
return shader;
} | O2 | c | rlCompileShader:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
leaq 0x18(%rsp), %r14
movq %rdi, (%r14)
movl %esi, %edi
callq *0xd014f(%rip) # 0x125608
movl %eax, %ebx
pushq $0x1
popq %rsi
movl %eax, %edi
movq %r14, %rdx
xorl %ecx, %ecx
callq *0xd130d(%rip) # 0x1267d8
leaq 0x14(%rsp), %r14
andl $0x0, (%r14)
movl %ebx, %edi
callq *0xcfff4(%rip) # 0x1254d0
movl %ebx, %edi
movl $0x8b81, %esi # imm = 0x8B81
movq %r14, %rdx
callq *0xd08dc(%rip) # 0x125dc8
cmpl $0x0, (%r14)
je 0x55517
cmpl $0x8b30, %ebp # imm = 0x8B30
je 0x55543
cmpl $0x91b9, %ebp # imm = 0x91B9
je 0x55538
cmpl $0x8b31, %ebp # imm = 0x8B31
jne 0x555e0
leaq 0x701a4(%rip), %rsi # 0xc56b9
jmp 0x5554a
cmpl $0x91b9, %ebp # imm = 0x91B9
je 0x55564
cmpl $0x8b31, %ebp # imm = 0x8B31
je 0x5555b
cmpl $0x8b30, %ebp # imm = 0x8B30
jne 0x55577
leaq 0x700e7(%rip), %rsi # 0xc561d
jmp 0x5556b
leaq 0x70115(%rip), %rsi # 0xc5654
pushq $0x4
jmp 0x5554c
leaq 0x701a3(%rip), %rsi # 0xc56ed
pushq $0x3
popq %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0xa128b
jmp 0x555e0
leaq 0x70086(%rip), %rsi # 0xc55e8
jmp 0x5556b
leaq 0x700e9(%rip), %rsi # 0xc5654
pushq $0x4
popq %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0xa128b
leaq 0x10(%rsp), %r14
andl $0x0, (%r14)
movl %ebx, %edi
movl $0x8b84, %esi # imm = 0x8B84
movq %r14, %rdx
callq *0xd0838(%rip) # 0x125dc8
movslq (%r14), %r14
testq %r14, %r14
jle 0x555de
leaq 0xc(%rsp), %r15
andl $0x0, (%r15)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x9320
movq %rax, %r12
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
movq %rax, %rcx
callq *0xd07e8(%rip) # 0x125da8
leaq 0x700d0(%rip), %rsi # 0xc5697
pushq $0x4
popq %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0xa128b
movq %r12, %rdi
callq 0x9640
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| rlCompileShader:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov ebp, esi
lea r14, [rsp+48h+var_30]
mov [r14], rdi
mov edi, esi
call cs:glad_glCreateShader
mov ebx, eax
push 1
pop rsi
mov edi, eax
mov rdx, r14
xor ecx, ecx
call cs:glad_glShaderSource
lea r14, [rsp+48h+var_34]
and dword ptr [r14], 0
mov edi, ebx
call cs:glad_glCompileShader
mov edi, ebx
mov esi, 8B81h
mov rdx, r14
call cs:glad_glGetShaderiv
cmp dword ptr [r14], 0
jz short loc_55517
cmp ebp, 8B30h
jz short loc_55543
cmp ebp, 91B9h
jz short loc_55538
cmp ebp, 8B31h
jnz loc_555E0
lea rsi, aShaderIdIVerte; "SHADER: [ID %i] Vertex shader compiled "...
jmp short loc_5554A
loc_55517:
cmp ebp, 91B9h
jz short loc_55564
cmp ebp, 8B31h
jz short loc_5555B
cmp ebp, 8B30h
jnz short loc_55577
lea rsi, aShaderIdIFaile_0; "SHADER: [ID %i] Failed to compile fragm"...
jmp short loc_5556B
loc_55538:
lea rsi, aShaderComputeS; "SHADER: Compute shaders not enabled. De"...
push 4
jmp short loc_5554C
loc_55543:
lea rsi, aShaderIdIFragm; "SHADER: [ID %i] Fragment shader compile"...
loc_5554A:
push 3
loc_5554C:
pop rdi
mov edx, ebx
xor eax, eax
call TraceLog
jmp loc_555E0
loc_5555B:
lea rsi, aShaderIdIFaile_1; "SHADER: [ID %i] Failed to compile verte"...
jmp short loc_5556B
loc_55564:
lea rsi, aShaderComputeS; "SHADER: Compute shaders not enabled. De"...
loc_5556B:
push 4
pop rdi
mov edx, ebx
xor eax, eax
call TraceLog
loc_55577:
lea r14, [rsp+48h+var_38]
and dword ptr [r14], 0
mov edi, ebx
mov esi, 8B84h
mov rdx, r14
call cs:glad_glGetShaderiv
movsxd r14, dword ptr [r14]
test r14, r14
jle short loc_555DE
lea r15, [rsp+48h+var_3C]
and dword ptr [r15], 0
push 1
pop rsi
mov rdi, r14
call _calloc
mov r12, rax
mov edi, ebx
mov esi, r14d
mov rdx, r15
mov rcx, rax
call cs:glad_glGetShaderInfoLog
lea rsi, aShaderIdICompi; "SHADER: [ID %i] Compile error: %s"
push 4
pop rdi
mov edx, ebx
mov rcx, r12
xor eax, eax
call TraceLog
mov rdi, r12
call _free
loc_555DE:
xor ebx, ebx
loc_555E0:
mov eax, ebx
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long rlCompileShader(long long a1, unsigned int a2)
{
long long Shader; // rbx
int v3; // ecx
int v4; // r8d
int v5; // r9d
const char *v6; // rsi
const char *v7; // rsi
unsigned int v8; // r14d
long long v9; // r12
int v10; // r8d
int v11; // r9d
int v13; // [rsp+Ch] [rbp-3Ch] BYREF
unsigned int v14; // [rsp+10h] [rbp-38h] BYREF
int v15; // [rsp+14h] [rbp-34h] BYREF
_QWORD v16[6]; // [rsp+18h] [rbp-30h] BYREF
v16[0] = a1;
Shader = (unsigned int)glad_glCreateShader(a2);
glad_glShaderSource(Shader, 1LL, v16, 0LL);
v15 = 0;
glad_glCompileShader((unsigned int)Shader);
glad_glGetShaderiv((unsigned int)Shader, 35713LL, &v15);
if ( !v15 )
{
switch ( a2 )
{
case 0x91B9u:
v7 = "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43";
break;
case 0x8B31u:
v7 = "SHADER: [ID %i] Failed to compile vertex shader code";
break;
case 0x8B30u:
v7 = "SHADER: [ID %i] Failed to compile fragment shader code";
break;
default:
LABEL_17:
v14 = 0;
glad_glGetShaderiv((unsigned int)Shader, 35716LL, &v14);
v8 = v14;
if ( (int)v14 > 0LL )
{
v13 = 0;
v9 = calloc((int)v14, 1LL);
glad_glGetShaderInfoLog((unsigned int)Shader, v8, &v13, v9);
TraceLog(4, (unsigned int)"SHADER: [ID %i] Compile error: %s", Shader, v9, v10, v11);
free(v9);
}
LODWORD(Shader) = 0;
return (unsigned int)Shader;
}
TraceLog(4, (_DWORD)v7, Shader, v3, v4, v5);
goto LABEL_17;
}
switch ( a2 )
{
case 0x8B30u:
v6 = "SHADER: [ID %i] Fragment shader compiled successfully";
goto LABEL_12;
case 0x91B9u:
TraceLog(
4,
(unsigned int)"SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43",
Shader,
v3,
v4,
v5);
break;
case 0x8B31u:
v6 = "SHADER: [ID %i] Vertex shader compiled successfully";
LABEL_12:
TraceLog(3, (_DWORD)v6, Shader, v3, v4, v5);
break;
}
return (unsigned int)Shader;
}
| rlCompileShader:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV EBP,ESI
LEA R14,[RSP + 0x18]
MOV qword ptr [R14],RDI
MOV EDI,ESI
CALL qword ptr [0x00225608]
MOV EBX,EAX
PUSH 0x1
POP RSI
MOV EDI,EAX
MOV RDX,R14
XOR ECX,ECX
CALL qword ptr [0x002267d8]
LEA R14,[RSP + 0x14]
AND dword ptr [R14],0x0
MOV EDI,EBX
CALL qword ptr [0x002254d0]
MOV EDI,EBX
MOV ESI,0x8b81
MOV RDX,R14
CALL qword ptr [0x00225dc8]
CMP dword ptr [R14],0x0
JZ 0x00155517
CMP EBP,0x8b30
JZ 0x00155543
CMP EBP,0x91b9
JZ 0x00155538
CMP EBP,0x8b31
JNZ 0x001555e0
LEA RSI,[0x1c56b9]
JMP 0x0015554a
LAB_00155517:
CMP EBP,0x91b9
JZ 0x00155564
CMP EBP,0x8b31
JZ 0x0015555b
CMP EBP,0x8b30
JNZ 0x00155577
LEA RSI,[0x1c561d]
JMP 0x0015556b
LAB_00155538:
LEA RSI,[0x1c5654]
PUSH 0x4
JMP 0x0015554c
LAB_00155543:
LEA RSI,[0x1c56ed]
LAB_0015554a:
PUSH 0x3
LAB_0015554c:
POP RDI
MOV EDX,EBX
XOR EAX,EAX
CALL 0x001a128b
JMP 0x001555e0
LAB_0015555b:
LEA RSI,[0x1c55e8]
JMP 0x0015556b
LAB_00155564:
LEA RSI,[0x1c5654]
LAB_0015556b:
PUSH 0x4
POP RDI
MOV EDX,EBX
XOR EAX,EAX
CALL 0x001a128b
LAB_00155577:
LEA R14,[RSP + 0x10]
AND dword ptr [R14],0x0
MOV EDI,EBX
MOV ESI,0x8b84
MOV RDX,R14
CALL qword ptr [0x00225dc8]
MOVSXD R14,dword ptr [R14]
TEST R14,R14
JLE 0x001555de
LEA R15,[RSP + 0xc]
AND dword ptr [R15],0x0
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x00109320
MOV R12,RAX
MOV EDI,EBX
MOV ESI,R14D
MOV RDX,R15
MOV RCX,RAX
CALL qword ptr [0x00225da8]
LEA RSI,[0x1c5697]
PUSH 0x4
POP RDI
MOV EDX,EBX
MOV RCX,R12
XOR EAX,EAX
CALL 0x001a128b
MOV RDI,R12
CALL 0x00109640
LAB_001555de:
XOR EBX,EBX
LAB_001555e0:
MOV EAX,EBX
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int4 rlCompileShader(int8 param_1,int param_2)
{
int iVar1;
int4 uVar2;
void *__ptr;
char *pcVar3;
int8 uStack_50;
int4 local_3c;
int local_38;
int local_34;
int8 local_30;
local_30 = param_1;
uVar2 = (*glad_glCreateShader)(param_2);
(*glad_glShaderSource)(uVar2,1,&local_30,0);
local_34 = 0;
(*glad_glCompileShader)(uVar2);
(*glad_glGetShaderiv)(uVar2,0x8b81,&local_34);
if (local_34 == 0) {
if (param_2 == 0x91b9) {
pcVar3 = "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43";
}
else if (param_2 == 0x8b31) {
pcVar3 = "SHADER: [ID %i] Failed to compile vertex shader code";
}
else {
if (param_2 != 0x8b30) goto LAB_00155577;
pcVar3 = "SHADER: [ID %i] Failed to compile fragment shader code";
}
TraceLog(4,pcVar3,uVar2);
LAB_00155577:
local_38 = 0;
(*glad_glGetShaderiv)(uVar2,0x8b84,&local_38);
iVar1 = local_38;
if (0 < (long)local_38) {
local_3c = 0;
__ptr = calloc((long)local_38,1);
(*glad_glGetShaderInfoLog)(uVar2,iVar1,&local_3c,__ptr);
TraceLog(4,"SHADER: [ID %i] Compile error: %s",uVar2,__ptr);
free(__ptr);
}
return 0;
}
if (param_2 == 0x8b30) {
pcVar3 = "SHADER: [ID %i] Fragment shader compiled successfully";
}
else {
if (param_2 == 0x91b9) {
pcVar3 = "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43";
uStack_50 = 4;
goto LAB_0015554c;
}
if (param_2 != 0x8b31) {
return uVar2;
}
pcVar3 = "SHADER: [ID %i] Vertex shader compiled successfully";
}
uStack_50 = 3;
LAB_0015554c:
TraceLog(uStack_50,pcVar3,uVar2);
return uVar2;
}
| |
25,953 | mbedtls_asn1_get_bool | msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/asn1parse.c | int mbedtls_asn1_get_tag(unsigned char **p,
const unsigned char *end,
size_t *len, int tag)
{
if ((end - *p) < 1) {
return MBEDTLS_ERR_ASN1_OUT_OF_DATA;
}
if (**p != tag) {
return MBEDTLS_ERR_ASN1_UNEXPECTED_TAG;
}
(*p)++;
return mbedtls_asn1_get_len(p, end, len);
} | O3 | c | mbedtls_asn1_get_bool:
movq (%rdi), %rcx
movq %rsi, %rax
subq %rcx, %rax
testq %rax, %rax
jle 0x969ec
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffff9e, %eax # imm = 0xFFFFFF9E
cmpb $0x1, (%rcx)
jne 0x969e4
movq %rdx, %r14
movq %rdi, %rbx
incq %rcx
movq %rcx, (%rdi)
movq %rsp, %rdx
callq 0x9688c
testl %eax, %eax
jne 0x969e4
movl $0xffffff9c, %eax # imm = 0xFFFFFF9C
cmpq $0x1, (%rsp)
jne 0x969e4
movq (%rbx), %rax
xorl %ecx, %ecx
cmpb $0x0, (%rax)
setne %cl
movl %ecx, (%r14)
incq %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffa0, %eax # imm = 0xFFFFFFA0
retq
| mbedtls_asn1_get_bool:
mov rcx, [rdi]
mov rax, rsi
sub rax, rcx
test rax, rax
jle short loc_969EC
push r14
push rbx
push rax
mov eax, 0FFFFFF9Eh
cmp byte ptr [rcx], 1
jnz short loc_969E4
mov r14, rdx
mov rbx, rdi
inc rcx
mov [rdi], rcx
mov rdx, rsp
call mbedtls_asn1_get_len
test eax, eax
jnz short loc_969E4
mov eax, 0FFFFFF9Ch
cmp [rsp+18h+var_18], 1
jnz short loc_969E4
mov rax, [rbx]
xor ecx, ecx
cmp byte ptr [rax], 0
setnz cl
mov [r14], ecx
inc rax
mov [rbx], rax
xor eax, eax
loc_969E4:
add rsp, 8
pop rbx
pop r14
retn
loc_969EC:
mov eax, 0FFFFFFA0h
retn
| long long mbedtls_asn1_get_bool(unsigned __int8 **a1, long long a2, _DWORD *a3)
{
unsigned __int8 *v3; // rcx
long long result; // rax
unsigned __int8 *v6; // rax
unsigned long long v7[3]; // [rsp+0h] [rbp-18h] BYREF
v3 = *a1;
if ( a2 - (long long)*a1 <= 0 )
return 4294967200LL;
v7[0] = a2 - (_QWORD)*a1;
result = 4294967198LL;
if ( *v3 == 1 )
{
*a1 = v3 + 1;
result = mbedtls_asn1_get_len(a1, a2, v7);
if ( !(_DWORD)result )
{
result = 4294967196LL;
if ( v7[0] == 1 )
{
v6 = *a1;
*a3 = **a1 != 0;
*a1 = v6 + 1;
return 0LL;
}
}
}
return result;
}
| mbedtls_asn1_get_bool:
MOV RCX,qword ptr [RDI]
MOV RAX,RSI
SUB RAX,RCX
TEST RAX,RAX
JLE 0x001969ec
PUSH R14
PUSH RBX
PUSH RAX
MOV EAX,0xffffff9e
CMP byte ptr [RCX],0x1
JNZ 0x001969e4
MOV R14,RDX
MOV RBX,RDI
INC RCX
MOV qword ptr [RDI],RCX
MOV RDX,RSP
CALL 0x0019688c
TEST EAX,EAX
JNZ 0x001969e4
MOV EAX,0xffffff9c
CMP qword ptr [RSP],0x1
JNZ 0x001969e4
MOV RAX,qword ptr [RBX]
XOR ECX,ECX
CMP byte ptr [RAX],0x0
SETNZ CL
MOV dword ptr [R14],ECX
INC RAX
MOV qword ptr [RBX],RAX
XOR EAX,EAX
LAB_001969e4:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001969ec:
MOV EAX,0xffffffa0
RET
|
int8 mbedtls_asn1_get_bool(int8 *param_1,long param_2,uint *param_3)
{
char *pcVar1;
int8 uVar2;
long local_18;
pcVar1 = (char *)*param_1;
local_18 = param_2 - (long)pcVar1;
if (0 < local_18) {
uVar2 = 0xffffff9e;
if (*pcVar1 == '\x01') {
*param_1 = pcVar1 + 1;
uVar2 = mbedtls_asn1_get_len(param_1,param_2,&local_18);
if (((int)uVar2 == 0) && (uVar2 = 0xffffff9c, local_18 == 1)) {
pcVar1 = (char *)*param_1;
*param_3 = (uint)(*pcVar1 != '\0');
*param_1 = pcVar1 + 1;
uVar2 = 0;
}
}
return uVar2;
}
return 0xffffffa0;
}
| |
25,954 | ma_tls_read_async | eloqsql/libmariadb/libmariadb/secure/openssl.c | ssize_t ma_tls_read_async(MARIADB_PVIO *pvio,
const unsigned char *buffer,
size_t length)
{
int res;
struct mysql_async_context *b= pvio->mysql->options.extension->async_context;
MARIADB_TLS *ctls= pvio->ctls;
for (;;)
{
res= SSL_read((SSL *)ctls->ssl, (void *)buffer, (int)length);
if (ma_tls_async_check_result(res, b, (SSL *)ctls->ssl))
return res;
}
} | O0 | c | ma_tls_read_async:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl %eax, %edx
callq 0x14070
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x51b20
cmpb $0x0, %al
je 0x51b13
movslq -0x1c(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
jmp 0x51ad7
nopw %cs:(%rax,%rax)
| ma_tls_read_async:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
mov rax, [rax+38h]
mov [rbp+var_30], rax
loc_51AD7:
mov rax, [rbp+var_30]
mov rdi, [rax+10h]
mov rsi, [rbp+var_10]
mov rax, [rbp+var_18]
mov edx, eax
call _SSL_read
mov [rbp+var_1C], eax
mov edi, [rbp+var_1C]
mov rsi, [rbp+var_28]
mov rax, [rbp+var_30]
mov rdx, [rax+10h]
call ma_tls_async_check_result
cmp al, 0
jz short loc_51B13
movsxd rax, [rbp+var_1C]
add rsp, 30h
pop rbp
retn
loc_51B13:
jmp short loc_51AD7
| long long ma_tls_read_async(long long a1, long long a2, unsigned int a3)
{
long long v4; // [rsp+0h] [rbp-30h]
long long v5; // [rsp+8h] [rbp-28h]
unsigned int v6; // [rsp+14h] [rbp-1Ch]
v5 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL);
v4 = *(_QWORD *)(a1 + 56);
do
v6 = SSL_read(*(_QWORD *)(v4 + 16), a2, a3);
while ( !(unsigned __int8)ma_tls_async_check_result(v6, v5, *(_QWORD *)(v4 + 16)) );
return (int)v6;
}
| ma_tls_read_async:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
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 + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x30],RAX
LAB_00151ad7:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x10]
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,EAX
CALL 0x00114070
MOV dword ptr [RBP + -0x1c],EAX
MOV EDI,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RAX + 0x10]
CALL 0x00151b20
CMP AL,0x0
JZ 0x00151b13
MOVSXD RAX,dword ptr [RBP + -0x1c]
ADD RSP,0x30
POP RBP
RET
LAB_00151b13:
JMP 0x00151ad7
|
long ma_tls_read_async(long param_1,void *param_2,int param_3)
{
int8 uVar1;
long lVar2;
char cVar3;
int iVar4;
uVar1 = *(int8 *)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28);
lVar2 = *(long *)(param_1 + 0x38);
do {
iVar4 = SSL_read(*(SSL **)(lVar2 + 0x10),param_2,param_3);
cVar3 = ma_tls_async_check_result(iVar4,uVar1,*(int8 *)(lVar2 + 0x10));
} while (cVar3 == '\0');
return (long)iVar4;
}
| |
25,955 | my_well_formed_char_length_ucs2 | eloqsql/strings/ctype-ucs2.c | static size_t
my_well_formed_char_length_ucs2(CHARSET_INFO *cs __attribute__((unused)),
const char *b, const char *e,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length= e - b;
if (nchars * 2 <= length)
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= b + (nchars * 2);
return nchars;
}
if (length % 2)
{
status->m_well_formed_error_pos= status->m_source_end_pos= e - 1;
}
else
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= e;
}
return length / 2;
} | O0 | c | my_well_formed_char_length_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
cmpq -0x38(%rbp), %rax
ja 0xaf94f
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
shlq %rax
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaf998
movq -0x38(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xaf976
movq -0x20(%rbp), %rcx
addq $-0x1, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xaf98d
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| my_well_formed_char_length_ucs2:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
shl rax, 1
cmp rax, [rbp+var_38]
ja short loc_AF94F
mov rax, [rbp+var_30]
mov qword ptr [rax+8], 0
mov rcx, [rbp+var_18]
mov rax, [rbp+var_28]
shl rax, 1
add rcx, rax
mov rax, [rbp+var_30]
mov [rax], rcx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_AF998
loc_AF94F:
mov rax, [rbp+var_38]
and rax, 1
cmp rax, 0
jz short loc_AF976
mov rcx, [rbp+var_20]
add rcx, 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_30]
mov [rax], rcx
mov rax, [rbp+var_30]
mov [rax+8], rcx
jmp short loc_AF98D
loc_AF976:
mov rax, [rbp+var_30]
mov qword ptr [rax+8], 0
mov rcx, [rbp+var_20]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_AF98D:
mov rax, [rbp+var_38]
shr rax, 1
mov [rbp+var_8], rax
loc_AF998:
mov rax, [rbp+var_8]
pop rbp
retn
| unsigned long long my_well_formed_char_length_ucs2(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
unsigned long long v6; // [rsp+0h] [rbp-38h]
v6 = a3 - a2;
if ( 2 * a4 > (unsigned long long)(a3 - a2) )
{
if ( (v6 & 1) != 0 )
{
*a5 = a3 - 1;
a5[1] = a3 - 1;
}
else
{
a5[1] = 0LL;
*a5 = a3;
}
return v6 >> 1;
}
else
{
a5[1] = 0LL;
*a5 = 2 * a4 + a2;
return a4;
}
}
| my_well_formed_char_length_ucs2:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x1
CMP RAX,qword ptr [RBP + -0x38]
JA 0x001af94f
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],0x0
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x1
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001af998
LAB_001af94f:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x1
CMP RAX,0x0
JZ 0x001af976
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,-0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001af98d
LAB_001af976:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],0x0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_001af98d:
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
LAB_001af998:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong my_well_formed_char_length_ucs2
(int8 param_1,long param_2,long param_3,ulong param_4,long *param_5)
{
ulong local_10;
local_10 = param_3 - param_2;
if (param_4 * 2 < local_10 || param_4 * 2 - local_10 == 0) {
param_5[1] = 0;
*param_5 = param_2 + param_4 * 2;
local_10 = param_4;
}
else {
if ((local_10 & 1) == 0) {
param_5[1] = 0;
*param_5 = param_3;
}
else {
*param_5 = param_3 + -1;
param_5[1] = param_3 + -1;
}
local_10 = local_10 >> 1;
}
return local_10;
}
| |
25,956 | my_well_formed_char_length_ucs2 | eloqsql/strings/ctype-ucs2.c | static size_t
my_well_formed_char_length_ucs2(CHARSET_INFO *cs __attribute__((unused)),
const char *b, const char *e,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length= e - b;
if (nchars * 2 <= length)
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= b + (nchars * 2);
return nchars;
}
if (length % 2)
{
status->m_well_formed_error_pos= status->m_source_end_pos= e - 1;
}
else
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= e;
}
return length / 2;
} | O3 | c | my_well_formed_char_length_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rcx, %rax
movq %rdx, %rcx
subq %rsi, %rcx
leaq (%rax,%rax), %rdi
cmpq %rcx, %rdi
jbe 0x80b1b
movl %ecx, %eax
andl $0x1, %eax
movq %rax, %rsi
negq %rsi
leaq -0x1(%rdx), %rdi
andq %rdi, %rsi
testq %rax, %rax
cmoveq %rdx, %rdi
movq %rsi, 0x8(%r8)
movq %rdi, (%r8)
shrq %rcx
movq %rcx, %rax
jmp 0x80b29
movq $0x0, 0x8(%r8)
addq %rdi, %rsi
movq %rsi, (%r8)
popq %rbp
retq
| my_well_formed_char_length_ucs2:
push rbp
mov rbp, rsp
mov rax, rcx
mov rcx, rdx
sub rcx, rsi
lea rdi, [rax+rax]
cmp rdi, rcx
jbe short loc_80B1B
mov eax, ecx
and eax, 1
mov rsi, rax
neg rsi
lea rdi, [rdx-1]
and rsi, rdi
test rax, rax
cmovz rdi, rdx
mov [r8+8], rsi
mov [r8], rdi
shr rcx, 1
mov rax, rcx
jmp short loc_80B29
loc_80B1B:
mov qword ptr [r8+8], 0
add rsi, rdi
mov [r8], rsi
loc_80B29:
pop rbp
retn
| unsigned long long my_well_formed_char_length_ucs2(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
_QWORD *a5)
{
unsigned long long result; // rax
unsigned long long v6; // rcx
long long v7; // rdi
result = a4;
v6 = a3 - a2;
if ( 2 * result <= a3 - a2 )
{
a5[1] = 0LL;
*a5 = 2 * result + a2;
}
else
{
v7 = a3 - 1;
if ( (v6 & 1) == 0 )
v7 = a3;
a5[1] = (a3 - 1) & -(long long)(v6 & 1);
*a5 = v7;
return v6 >> 1;
}
return result;
}
| my_well_formed_char_length_ucs2:
PUSH RBP
MOV RBP,RSP
MOV RAX,RCX
MOV RCX,RDX
SUB RCX,RSI
LEA RDI,[RAX + RAX*0x1]
CMP RDI,RCX
JBE 0x00180b1b
MOV EAX,ECX
AND EAX,0x1
MOV RSI,RAX
NEG RSI
LEA RDI,[RDX + -0x1]
AND RSI,RDI
TEST RAX,RAX
CMOVZ RDI,RDX
MOV qword ptr [R8 + 0x8],RSI
MOV qword ptr [R8],RDI
SHR RCX,0x1
MOV RAX,RCX
JMP 0x00180b29
LAB_00180b1b:
MOV qword ptr [R8 + 0x8],0x0
ADD RSI,RDI
MOV qword ptr [R8],RSI
LAB_00180b29:
POP RBP
RET
|
ulong my_well_formed_char_length_ucs2
(int8 param_1,long param_2,ulong param_3,ulong param_4,ulong *param_5)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
uVar2 = param_3 - param_2;
if (uVar2 < param_4 * 2) {
uVar1 = (ulong)((uint)uVar2 & 1);
uVar3 = param_3 - 1;
if (uVar1 == 0) {
uVar3 = param_3;
}
param_5[1] = -uVar1 & param_3 - 1;
*param_5 = uVar3;
param_4 = uVar2 >> 1;
}
else {
param_5[1] = 0;
*param_5 = param_2 + param_4 * 2;
}
return param_4;
}
| |
25,957 | ft_boolean_read_next | eloqsql/storage/myisam/ft_boolean_search.c | int ft_boolean_read_next(FT_INFO *ftb, char *record)
{
FTB_EXPR *ftbe;
FTB_WORD *ftbw;
MI_INFO *info=ftb->info;
my_off_t curdoc;
if (ftb->state != INDEX_SEARCH && ftb->state != INDEX_DONE)
return -1;
/* black magic ON */
if ((int) _mi_check_index(info, ftb->keynr) < 0)
return my_errno;
if (_mi_readinfo(info, F_RDLCK, 1))
return my_errno;
/* black magic OFF */
if (!ftb->queue.elements)
return my_errno=HA_ERR_END_OF_FILE;
/* Attention!!! Address of a local variable is used here! See err: label */
ftb->queue.first_cmp_arg=(void *)&curdoc;
while (ftb->state == INDEX_SEARCH &&
(curdoc=((FTB_WORD *)queue_top(& ftb->queue))->docid[0]) !=
HA_OFFSET_ERROR)
{
while (curdoc == (ftbw=(FTB_WORD *)queue_top(& ftb->queue))->docid[0])
{
if (unlikely(_ftb_climb_the_tree(ftb, ftbw, 0)))
{
my_errno= HA_ERR_OUT_OF_MEM;
goto err;
}
/* update queue */
_ft2_search(ftb, ftbw, 0);
queue_replace_top(&ftb->queue);
}
ftbe=ftb->root;
if (ftbe->docid[0]==curdoc && ftbe->cur_weight>0 &&
ftbe->yesses>=(ftbe->ythresh-ftbe->yweaks) && !ftbe->nos)
{
/* curdoc matched ! */
if (is_tree_inited(&ftb->no_dupes) &&
tree_insert(&ftb->no_dupes, &curdoc, 0,
ftb->no_dupes.custom_arg)->count >1)
/* but it managed already to get past this line once */
continue;
info->lastpos=curdoc;
/* Clear all states, except that the table was updated */
info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
if (!(*info->read_record)(info,curdoc, (uchar*) record))
{
info->update|= HA_STATE_AKTIV; /* Record is read */
if (ftb->with_scan &&
ft_boolean_find_relevance(ftb,(uchar*) record,0)==0)
continue; /* no match */
my_errno=0;
goto err;
}
goto err;
}
}
ftb->state=INDEX_DONE;
my_errno=HA_ERR_END_OF_FILE;
err:
ftb->queue.first_cmp_arg=(void *)0;
return my_errno;
} | O3 | c | ft_boolean_read_next:
movl 0x348(%rdi), %ecx
andl $-0x2, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
jne 0x737fc
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movl 0x340(%rdi), %esi
movq %r15, %rdi
callq 0x859b8
testl %eax, %eax
js 0x737e7
movq %r15, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x7e1b3
testl %eax, %eax
jne 0x737e7
cmpl $0x0, 0x80(%rbx)
je 0x737fd
leaq -0x30(%rbp), %rax
movq %rax, 0x78(%rbx)
cmpl $0x2, 0x348(%rbx)
jne 0x737c7
leaq 0x70(%rbx), %r12
leaq 0xa0(%rbx), %rax
movq %rax, -0x38(%rbp)
movq (%r12), %rax
movq 0x8(%rax), %r13
movq 0x10(%r13), %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
je 0x737c7
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x7381c
testl %eax, %eax
jne 0x7380f
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x73ad8
movq %r12, %rdi
movl $0x1, %esi
callq 0xa3a79
movq -0x30(%rbp), %rsi
movq 0x70(%rbx), %rax
movq 0x8(%rax), %r13
cmpq 0x10(%r13), %rsi
je 0x736c9
movq 0x18(%rbx), %rax
cmpq %rsi, 0x10(%rax)
jne 0x73733
movss 0x2c(%rax), %xmm0
ucomiss 0x668e8(%rip), %xmm0 # 0xda008
jbe 0x73733
movl 0x48(%rax), %ecx
subl 0x4c(%rax), %ecx
cmpl %ecx, 0x40(%rax)
jb 0x73733
cmpl $0x0, 0x44(%rax)
je 0x73745
cmpl $0x2, 0x348(%rbx)
je 0x736af
jmp 0x737c7
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0x73772
movq 0x2d0(%rbx), %rcx
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0xa5eca
testl $0x7ffffffe, 0x10(%rax) # imm = 0x7FFFFFFE
jne 0x73733
movq -0x30(%rbp), %rsi
movq %rsi, 0x170(%r15)
andl $0x401, 0x1d0(%r15) # imm = 0x401
movq %r15, %rdi
movq %r14, %rdx
callq *0x140(%r15)
testl %eax, %eax
jne 0x737df
orb $0x2, 0x1d0(%r15)
cmpb $0x0, 0x344(%rbx)
je 0x73817
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2d676
ucomiss 0x6684b(%rip), %xmm0 # 0xda008
jne 0x737d7
jnp 0x73733
jmp 0x737d7
movl $0x3, 0x348(%rbx)
movl $0x89, %r13d
callq 0xa319a
movl %r13d, (%rax)
movq $0x0, 0x78(%rbx)
callq 0xa319a
movl (%rax), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xa319a
movl $0x89, (%rax)
movl $0x89, %eax
jmp 0x737ee
movl $0x80, %r13d
jmp 0x737d7
xorl %r13d, %r13d
jmp 0x737d7
| ft_boolean_read_next:
mov ecx, [rdi+348h]
and ecx, 0FFFFFFFEh
mov eax, 0FFFFFFFFh
cmp ecx, 2
jnz locret_737FC
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
mov rbx, rdi
mov r15, [rdi+8]
mov esi, [rdi+340h]
mov rdi, r15
call _mi_check_index
test eax, eax
js loc_737E7
mov rdi, r15
xor esi, esi
mov edx, 1
call _mi_readinfo
test eax, eax
jnz loc_737E7
cmp dword ptr [rbx+80h], 0
jz loc_737FD
lea rax, [rbp-30h]
mov [rbx+78h], rax
cmp dword ptr [rbx+348h], 2
jnz loc_737C7
lea r12, [rbx+70h]
lea rax, [rbx+0A0h]
mov [rbp-38h], rax
loc_736AF:
mov rax, [r12]
mov r13, [rax+8]
mov rax, [r13+10h]
mov [rbp-30h], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_737C7
loc_736C9:
mov rdi, rbx
mov rsi, r13
xor edx, edx
call _ftb_climb_the_tree
test eax, eax
jnz loc_7380F
mov rdi, rbx
mov rsi, r13
xor edx, edx
call _ft2_search
mov rdi, r12
mov esi, 1
call _downheap
mov rsi, [rbp-30h]
mov rax, [rbx+70h]
mov r13, [rax+8]
cmp rsi, [r13+10h]
jz short loc_736C9
mov rax, [rbx+18h]
cmp [rax+10h], rsi
jnz short loc_73733
movss xmm0, dword ptr [rax+2Ch]
ucomiss xmm0, cs:dword_DA008
jbe short loc_73733
mov ecx, [rax+48h]
sub ecx, [rax+4Ch]
cmp [rax+40h], ecx
jb short loc_73733
cmp dword ptr [rax+44h], 0
jz short loc_73745
loc_73733:
cmp dword ptr [rbx+348h], 2
jz loc_736AF
jmp loc_737C7
loc_73745:
mov rax, [rbp-38h]
cmp qword ptr [rax], 0
jz short loc_73772
mov rcx, [rbx+2D0h]
mov rdi, [rbp-38h]
lea rsi, [rbp-30h]
xor edx, edx
call tree_insert
test dword ptr [rax+10h], 7FFFFFFEh
jnz short loc_73733
mov rsi, [rbp-30h]
loc_73772:
mov [r15+170h], rsi
and dword ptr [r15+1D0h], 401h
mov rdi, r15
mov rdx, r14
call qword ptr [r15+140h]
test eax, eax
jnz short loc_737DF
or byte ptr [r15+1D0h], 2
cmp byte ptr [rbx+344h], 0
jz short loc_73817
xor r13d, r13d
mov rdi, rbx
mov rsi, r14
xor edx, edx
call ft_boolean_find_relevance
ucomiss xmm0, cs:dword_DA008
jnz short loc_737D7
jnp loc_73733
jmp short loc_737D7
loc_737C7:
mov dword ptr [rbx+348h], 3
mov r13d, 89h
loc_737D7:
call _my_thread_var
mov [rax], r13d
loc_737DF:
mov qword ptr [rbx+78h], 0
loc_737E7:
call _my_thread_var
mov eax, [rax]
loc_737EE:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_737FC:
retn
loc_737FD:
call _my_thread_var
mov dword ptr [rax], 89h
mov eax, 89h
jmp short loc_737EE
loc_7380F:
mov r13d, 80h
jmp short loc_737D7
loc_73817:
xor r13d, r13d
jmp short loc_737D7
| long long ft_boolean_read_next(long long a1, long long a2)
{
long long result; // rax
long long v5; // r15
long long v6; // rsi
long long v7; // rdi
long long v8; // r13
long long v9; // rsi
long long v10; // rax
int v11; // r13d
double relevance; // xmm0_8
_QWORD *v13; // [rsp-40h] [rbp-40h]
_QWORD v14[7]; // [rsp-38h] [rbp-38h] BYREF
result = 0xFFFFFFFFLL;
if ( (*(_DWORD *)(a1 + 840) & 0xFFFFFFFE) == 2 )
{
v5 = *(_QWORD *)(a1 + 8);
v6 = *(unsigned int *)(a1 + 832);
v7 = v5;
if ( (int)mi_check_index(v5, v6) < 0 )
return *(unsigned int *)my_thread_var(v7);
v7 = v5;
if ( (unsigned int)mi_readinfo(v5, 0LL, 1LL) )
return *(unsigned int *)my_thread_var(v7);
if ( !*(_DWORD *)(a1 + 128) )
{
*(_DWORD *)my_thread_var(v5) = 137;
return 137LL;
}
*(_QWORD *)(a1 + 120) = v14;
if ( *(_DWORD *)(a1 + 840) != 2 )
goto LABEL_23;
v13 = (_QWORD *)(a1 + 160);
while ( 2 )
{
v8 = *(_QWORD *)(*(_QWORD *)(a1 + 112) + 8LL);
v14[0] = *(_QWORD *)(v8 + 16);
if ( v14[0] == -1LL )
goto LABEL_23;
do
{
v7 = a1;
if ( (unsigned int)ftb_climb_the_tree(a1, v8, 0LL) )
{
v11 = 128;
goto LABEL_24;
}
ft2_search(a1, v8, 0LL);
v7 = a1 + 112;
downheap(a1 + 112, 1LL);
v9 = v14[0];
v8 = *(_QWORD *)(*(_QWORD *)(a1 + 112) + 8LL);
}
while ( v14[0] == *(_QWORD *)(v8 + 16) );
v10 = *(_QWORD *)(a1 + 24);
if ( *(_QWORD *)(v10 + 16) != v14[0]
|| *(float *)(v10 + 44) <= 0.0
|| *(_DWORD *)(v10 + 64) < (unsigned int)(*(_DWORD *)(v10 + 72) - *(_DWORD *)(v10 + 76))
|| *(_DWORD *)(v10 + 68) )
{
LABEL_14:
if ( *(_DWORD *)(a1 + 840) == 2 )
continue;
LABEL_23:
*(_DWORD *)(a1 + 840) = 3;
v11 = 137;
goto LABEL_24;
}
break;
}
if ( *v13 )
{
v7 = a1 + 160;
if ( (*(_DWORD *)(tree_insert(v13, v14, 0LL, *(_QWORD *)(a1 + 720)) + 16) & 0x7FFFFFFE) != 0 )
goto LABEL_14;
v9 = v14[0];
}
*(_QWORD *)(v5 + 368) = v9;
*(_DWORD *)(v5 + 464) &= 0x401u;
v7 = v5;
if ( (*(unsigned int ( **)(long long, long long, long long))(v5 + 320))(v5, v9, a2) )
goto LABEL_25;
*(_BYTE *)(v5 + 464) |= 2u;
if ( !*(_BYTE *)(a1 + 836) )
{
v11 = 0;
LABEL_24:
*(_DWORD *)my_thread_var(v7) = v11;
LABEL_25:
*(_QWORD *)(a1 + 120) = 0LL;
return *(unsigned int *)my_thread_var(v7);
}
v11 = 0;
v7 = a1;
relevance = ft_boolean_find_relevance(a1, a2, 0);
if ( *(float *)&relevance != 0.0 )
goto LABEL_24;
goto LABEL_14;
}
return result;
}
| ft_boolean_read_next:
MOV ECX,dword ptr [RDI + 0x348]
AND ECX,0xfffffffe
MOV EAX,0xffffffff
CMP ECX,0x2
JNZ 0x001737fc
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV RBX,RDI
MOV R15,qword ptr [RDI + 0x8]
MOV ESI,dword ptr [RDI + 0x340]
MOV RDI,R15
CALL 0x001859b8
TEST EAX,EAX
JS 0x001737e7
MOV RDI,R15
XOR ESI,ESI
MOV EDX,0x1
CALL 0x0017e1b3
TEST EAX,EAX
JNZ 0x001737e7
CMP dword ptr [RBX + 0x80],0x0
JZ 0x001737fd
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBX + 0x78],RAX
CMP dword ptr [RBX + 0x348],0x2
JNZ 0x001737c7
LEA R12,[RBX + 0x70]
LEA RAX,[RBX + 0xa0]
MOV qword ptr [RBP + -0x38],RAX
LAB_001736af:
MOV RAX,qword ptr [R12]
MOV R13,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R13 + 0x10]
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,-0x1
JZ 0x001737c7
LAB_001736c9:
MOV RDI,RBX
MOV RSI,R13
XOR EDX,EDX
CALL 0x0017381c
TEST EAX,EAX
JNZ 0x0017380f
MOV RDI,RBX
MOV RSI,R13
XOR EDX,EDX
CALL 0x00173ad8
MOV RDI,R12
MOV ESI,0x1
CALL 0x001a3a79
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBX + 0x70]
MOV R13,qword ptr [RAX + 0x8]
CMP RSI,qword ptr [R13 + 0x10]
JZ 0x001736c9
MOV RAX,qword ptr [RBX + 0x18]
CMP qword ptr [RAX + 0x10],RSI
JNZ 0x00173733
MOVSS XMM0,dword ptr [RAX + 0x2c]
UCOMISS XMM0,dword ptr [0x001da008]
JBE 0x00173733
MOV ECX,dword ptr [RAX + 0x48]
SUB ECX,dword ptr [RAX + 0x4c]
CMP dword ptr [RAX + 0x40],ECX
JC 0x00173733
CMP dword ptr [RAX + 0x44],0x0
JZ 0x00173745
LAB_00173733:
CMP dword ptr [RBX + 0x348],0x2
JZ 0x001736af
JMP 0x001737c7
LAB_00173745:
MOV RAX,qword ptr [RBP + -0x38]
CMP qword ptr [RAX],0x0
JZ 0x00173772
MOV RCX,qword ptr [RBX + 0x2d0]
MOV RDI,qword ptr [RBP + -0x38]
LEA RSI,[RBP + -0x30]
XOR EDX,EDX
CALL 0x001a5eca
TEST dword ptr [RAX + 0x10],0x7ffffffe
JNZ 0x00173733
MOV RSI,qword ptr [RBP + -0x30]
LAB_00173772:
MOV qword ptr [R15 + 0x170],RSI
AND dword ptr [R15 + 0x1d0],0x401
MOV RDI,R15
MOV RDX,R14
CALL qword ptr [R15 + 0x140]
TEST EAX,EAX
JNZ 0x001737df
OR byte ptr [R15 + 0x1d0],0x2
CMP byte ptr [RBX + 0x344],0x0
JZ 0x00173817
XOR R13D,R13D
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x0012d676
UCOMISS XMM0,dword ptr [0x001da008]
JNZ 0x001737d7
JNP 0x00173733
JMP 0x001737d7
LAB_001737c7:
MOV dword ptr [RBX + 0x348],0x3
MOV R13D,0x89
LAB_001737d7:
CALL 0x001a319a
MOV dword ptr [RAX],R13D
LAB_001737df:
MOV qword ptr [RBX + 0x78],0x0
LAB_001737e7:
CALL 0x001a319a
MOV EAX,dword ptr [RAX]
LAB_001737ee:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_001737fc:
RET
LAB_001737fd:
CALL 0x001a319a
MOV dword ptr [RAX],0x89
MOV EAX,0x89
JMP 0x001737ee
LAB_0017380f:
MOV R13D,0x80
JMP 0x001737d7
LAB_00173817:
XOR R13D,R13D
JMP 0x001737d7
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 ft_boolean_read_next(long param_1,int8 param_2)
{
long lVar1;
int iVar2;
long lVar3;
int4 *puVar4;
int4 uVar5;
float fVar6;
long local_38;
uVar5 = 0xffffffff;
if ((*(uint *)(param_1 + 0x348) & 0xfffffffe) == 2) {
lVar1 = *(long *)(param_1 + 8);
iVar2 = _mi_check_index(lVar1,*(int4 *)(param_1 + 0x340));
if ((-1 < iVar2) && (iVar2 = _mi_readinfo(lVar1,0,1), iVar2 == 0)) {
if (*(int *)(param_1 + 0x80) == 0) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x89;
return 0x89;
}
*(long **)(param_1 + 0x78) = &local_38;
if (*(int *)(param_1 + 0x348) == 2) {
do {
lVar3 = *(long *)(*(long *)(param_1 + 0x70) + 8);
local_38 = *(long *)(lVar3 + 0x10);
if (local_38 == -1) break;
do {
iVar2 = _ftb_climb_the_tree(param_1,lVar3,0);
if (iVar2 != 0) {
uVar5 = 0x80;
goto LAB_001737d7;
}
_ft2_search(param_1,lVar3,0);
_downheap((long *)(param_1 + 0x70),1);
lVar3 = *(long *)(*(long *)(param_1 + 0x70) + 8);
} while (local_38 == *(long *)(lVar3 + 0x10));
lVar3 = *(long *)(param_1 + 0x18);
if (((((*(long *)(lVar3 + 0x10) == local_38) && (_DAT_001da008 < *(float *)(lVar3 + 0x2c))
) && ((uint)(*(int *)(lVar3 + 0x48) - *(int *)(lVar3 + 0x4c)) <=
*(uint *)(lVar3 + 0x40))) && (*(int *)(lVar3 + 0x44) == 0)) &&
((*(long *)(param_1 + 0xa0) == 0 ||
(lVar3 = tree_insert((long *)(param_1 + 0xa0),&local_38,0,
*(int8 *)(param_1 + 0x2d0)),
(*(uint *)(lVar3 + 0x10) & 0x7ffffffe) == 0)))) {
*(long *)(lVar1 + 0x170) = local_38;
*(uint *)(lVar1 + 0x1d0) = *(uint *)(lVar1 + 0x1d0) & 0x401;
iVar2 = (**(code **)(lVar1 + 0x140))(lVar1,local_38,param_2);
if (iVar2 != 0) goto LAB_001737df;
*(byte *)(lVar1 + 0x1d0) = *(byte *)(lVar1 + 0x1d0) | 2;
if (*(char *)(param_1 + 0x344) == '\0') {
uVar5 = 0;
goto LAB_001737d7;
}
fVar6 = (float)ft_boolean_find_relevance(param_1,param_2,0);
uVar5 = 0;
if ((fVar6 != _DAT_001da008) || (uVar5 = 0, NAN(fVar6) || NAN(_DAT_001da008)))
goto LAB_001737d7;
}
} while (*(int *)(param_1 + 0x348) == 2);
}
*(int4 *)(param_1 + 0x348) = 3;
uVar5 = 0x89;
LAB_001737d7:
puVar4 = (int4 *)_my_thread_var();
*puVar4 = uVar5;
LAB_001737df:
*(int8 *)(param_1 + 0x78) = 0;
}
puVar4 = (int4 *)_my_thread_var();
uVar5 = *puVar4;
}
return uVar5;
}
| |
25,958 | fs_create_directory_with_parents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | bool fs_create_directory_with_parents(const std::string & path) {
#ifdef _WIN32
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
std::wstring wpath = converter.from_bytes(path);
// if the path already exists, check whether it's a directory
const DWORD attributes = GetFileAttributesW(wpath.c_str());
if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
return true;
}
size_t pos_slash = 0;
// process path from front to back, procedurally creating directories
while ((pos_slash = path.find('\\', pos_slash)) != std::string::npos) {
const std::wstring subpath = wpath.substr(0, pos_slash);
const wchar_t * test = subpath.c_str();
const bool success = CreateDirectoryW(test, NULL);
if (!success) {
const DWORD error = GetLastError();
// if the path already exists, ensure that it's a directory
if (error == ERROR_ALREADY_EXISTS) {
const DWORD attributes = GetFileAttributesW(subpath.c_str());
if (attributes == INVALID_FILE_ATTRIBUTES || !(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
return false;
}
} else {
return false;
}
}
pos_slash += 1;
}
return true;
#else
// if the path already exists, check whether it's a directory
struct stat info;
if (stat(path.c_str(), &info) == 0) {
return S_ISDIR(info.st_mode);
}
size_t pos_slash = 1; // skip leading slashes for directory creation
// process path from front to back, procedurally creating directories
while ((pos_slash = path.find('/', pos_slash)) != std::string::npos) {
const std::string subpath = path.substr(0, pos_slash);
struct stat info;
// if the path already exists, ensure that it's a directory
if (stat(subpath.c_str(), &info) == 0) {
if (!S_ISDIR(info.st_mode)) {
return false;
}
} else {
// create parent directories
const int ret = mkdir(subpath.c_str(), 0755);
if (ret != 0) {
return false;
}
}
pos_slash += 1;
}
return true;
#endif // _WIN32
} | O3 | cpp | fs_create_directory_with_parents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x19640
testl %eax, %eax
je 0x53577
movl $0x1, %r14d
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %rbx, %rdi
movl $0x2f, %esi
movq %r14, %rdx
callq 0x198a0
cmpq $-0x1, %rax
sete %bpl
je 0x5358c
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x19720
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x19640
testl %eax, %eax
je 0x53538
movq 0x8(%rsp), %rdi
movl $0x1ed, %esi # imm = 0x1ED
callq 0x19350
testl %eax, %eax
je 0x5354a
xorl %r13d, %r13d
jmp 0x53550
movl 0x40(%rsp), %eax
movl $0xf000, %ecx # imm = 0xF000
andl %ecx, %eax
cmpl $0x4000, %eax # imm = 0x4000
jne 0x53533
incq %r14
movb $0x1, %r13b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5356c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196d0
testb %r13b, %r13b
jne 0x534de
jmp 0x5358c
movl $0xf000, %eax # imm = 0xF000
andl 0xd0(%rsp), %eax
cmpl $0x4000, %eax # imm = 0x4000
sete %bpl
movl %ebp, %eax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _Z32fs_create_directory_with_parentsRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 148h
mov rbx, rdi
mov rdi, [rdi]
lea rsi, [rsp+178h+var_C0]
call _stat
test eax, eax
jz loc_53577
mov r14d, 1
lea r15, [rsp+178h+var_170]
lea r12, [rsp+178h+var_150]
loc_534DE:
mov rdi, rbx
mov esi, 2Fh ; '/'
mov rdx, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
setz bpl
jz loc_5358C
mov r14, rax
mov rdi, r15
mov rsi, rbx
xor edx, edx
mov rcx, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, [rsp+178h+var_170]
mov rsi, r12
call _stat
test eax, eax
jz short loc_53538
mov rdi, [rsp+178h+var_170]
mov esi, 1EDh
call _mkdir
test eax, eax
jz short loc_5354A
loc_53533:
xor r13d, r13d
jmp short loc_53550
loc_53538:
mov eax, [rsp+178h+var_138]
mov ecx, 0F000h
and eax, ecx
cmp eax, 4000h
jnz short loc_53533
loc_5354A:
inc r14
mov r13b, 1
loc_53550:
mov rdi, [rsp+178h+var_170]; void *
lea rax, [rsp+178h+var_160]
cmp rdi, rax
jz short loc_5356C
mov rsi, [rsp+178h+var_160]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5356C:
test r13b, r13b
jnz loc_534DE
jmp short loc_5358C
loc_53577:
mov eax, 0F000h
and eax, [rsp+178h+var_A8]
cmp eax, 4000h
setz bpl
loc_5358C:
mov eax, ebp
add rsp, 148h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long fs_create_directory_with_parents(_QWORD *a1)
{
unsigned int v1; // ebp
long long v2; // r14
long long v3; // rax
char v4; // r13
void *v6; // [rsp+8h] [rbp-170h] BYREF
long long v7; // [rsp+18h] [rbp-160h] BYREF
_BYTE v8[24]; // [rsp+28h] [rbp-150h] BYREF
int v9; // [rsp+40h] [rbp-138h]
_BYTE v10[24]; // [rsp+B8h] [rbp-C0h] BYREF
int v11; // [rsp+D0h] [rbp-A8h]
if ( (unsigned int)stat(*a1, v10) )
{
v2 = 1LL;
while ( 1 )
{
v3 = std::string::find(a1, 47LL, v2);
LOBYTE(v1) = v3 == -1;
if ( v3 == -1 )
return v1;
v2 = v3;
std::string::substr(&v6, a1, 0LL, v3);
if ( (unsigned int)stat(v6, v8) )
{
if ( !(unsigned int)mkdir(v6, 493LL) )
goto LABEL_8;
}
else if ( (v9 & 0xF000) == 0x4000 )
{
LABEL_8:
++v2;
v4 = 1;
goto LABEL_9;
}
v4 = 0;
LABEL_9:
if ( v6 != &v7 )
operator delete(v6, v7 + 1);
if ( !v4 )
return v1;
}
}
LOBYTE(v1) = (v11 & 0xF000) == 0x4000;
return v1;
}
| fs_create_directory_with_parents:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x148
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
LEA RSI,[RSP + 0xb8]
CALL 0x00119640
TEST EAX,EAX
JZ 0x00153577
MOV R14D,0x1
LEA R15,[RSP + 0x8]
LEA R12,[RSP + 0x28]
LAB_001534de:
MOV RDI,RBX
MOV ESI,0x2f
MOV RDX,R14
CALL 0x001198a0
CMP RAX,-0x1
SETZ BPL
JZ 0x0015358c
MOV R14,RAX
MOV RDI,R15
MOV RSI,RBX
XOR EDX,EDX
MOV RCX,RAX
CALL 0x00119720
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R12
CALL 0x00119640
TEST EAX,EAX
JZ 0x00153538
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x1ed
CALL 0x00119350
TEST EAX,EAX
JZ 0x0015354a
LAB_00153533:
XOR R13D,R13D
JMP 0x00153550
LAB_00153538:
MOV EAX,dword ptr [RSP + 0x40]
MOV ECX,0xf000
AND EAX,ECX
CMP EAX,0x4000
JNZ 0x00153533
LAB_0015354a:
INC R14
MOV R13B,0x1
LAB_00153550:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0015356c
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001196d0
LAB_0015356c:
TEST R13B,R13B
JNZ 0x001534de
JMP 0x0015358c
LAB_00153577:
MOV EAX,0xf000
AND EAX,dword ptr [RSP + 0xd0]
CMP EAX,0x4000
SETZ BPL
LAB_0015358c:
MOV EAX,EBP
ADD RSP,0x148
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* fs_create_directory_with_parents(std::__cxx11::string const&) */
ulong fs_create_directory_with_parents(string *param_1)
{
bool bVar1;
int iVar2;
long lVar3;
ulong unaff_RBP;
long *local_170 [2];
long local_160 [2];
stat local_150;
stat local_c0;
iVar2 = stat(*(char **)param_1,&local_c0);
if (iVar2 == 0) {
unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),(local_c0.st_mode & 0xf000) == 0x4000);
}
else {
do {
lVar3 = std::__cxx11::string::find((char)param_1,0x2f);
unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),lVar3 == -1);
if (lVar3 == -1) break;
std::__cxx11::string::substr((ulong)local_170,(ulong)param_1);
iVar2 = stat((char *)local_170[0],&local_150);
if (iVar2 == 0) {
if ((local_150.st_mode & 0xf000) != 0x4000) goto LAB_00153533;
LAB_0015354a:
bVar1 = true;
}
else {
iVar2 = mkdir((char *)local_170[0],0x1ed);
if (iVar2 == 0) goto LAB_0015354a;
LAB_00153533:
bVar1 = false;
}
if (local_170[0] != local_160) {
operator_delete(local_170[0],local_160[0] + 1);
}
} while (bVar1);
}
return unaff_RBP & 0xffffffff;
}
| |
25,959 | js_std_file_tell | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_tell(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int is_bigint)
{
FILE *f = js_std_file_get(ctx, this_val);
int64_t pos;
if (!f)
return JS_EXCEPTION;
#if defined(__linux__)
pos = ftello(f);
#else
pos = ftell(f);
#endif
if (is_bigint)
return JS_NewBigInt64(ctx, pos);
else
return JS_NewInt64(ctx, pos);
} | O1 | c | js_std_file_tell:
pushq %rbp
pushq %r14
pushq %rbx
movl %r9d, %ebp
movq %rdi, %rbx
callq 0x16588
testq %rax, %rax
je 0x160ae
movabsq $-0x100000000, %r14 # imm = 0xFFFFFFFF00000000
movq %rax, %rdi
callq 0xe110
testl %ebp, %ebp
je 0x160ba
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28376
jmp 0x160db
movl $0x6, %edx
xorl %eax, %eax
xorl %r14d, %r14d
jmp 0x160de
movslq %eax, %rcx
xorl %esi, %esi
cmpq %rax, %rcx
cvtsi2sd %rax, %xmm0
movl %ecx, %ecx
movq %xmm0, %rax
cmoveq %rcx, %rax
movl $0x7, %edx
cmoveq %rsi, %rdx
andq %rax, %r14
movl %eax, %eax
orq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
| js_std_file_tell:
push rbp
push r14
push rbx
mov ebp, r9d
mov rbx, rdi
call js_std_file_get
test rax, rax
jz short loc_160AE
mov r14, 0FFFFFFFF00000000h
mov rdi, rax
call _ftello
test ebp, ebp
jz short loc_160BA
mov rdi, rbx
mov rsi, rax
call JS_NewBigInt64
jmp short loc_160DB
loc_160AE:
mov edx, 6
xor eax, eax
xor r14d, r14d
jmp short loc_160DE
loc_160BA:
movsxd rcx, eax
xor esi, esi
cmp rcx, rax
cvtsi2sd xmm0, rax
mov ecx, ecx
movq rax, xmm0
cmovz rax, rcx
mov edx, 7
cmovz rdx, rsi
loc_160DB:
and r14, rax
loc_160DE:
mov eax, eax
or rax, r14
pop rbx
pop r14
pop rbp
retn
| unsigned long long js_std_file_tell(long long a1, long long a2, long long a3, long long a4, long long a5, int a6)
{
long long v7; // rax
long long v8; // rax
double v9; // rax
unsigned long long v10; // r14
bool v11; // zf
double v12; // rcx
v7 = js_std_file_get(a1);
if ( v7 )
{
v8 = ftello(v7);
if ( a6 )
{
v9 = COERCE_DOUBLE(JS_NewBigInt64(a1, v8));
}
else
{
v11 = (int)v8 == v8;
*(_QWORD *)&v12 = (unsigned int)v8;
v9 = (double)(int)v8;
if ( v11 )
v9 = v12;
}
v10 = *(_QWORD *)&v9 & 0xFFFFFFFF00000000LL;
}
else
{
LODWORD(v9) = 0;
v10 = 0LL;
}
return v10 | LODWORD(v9);
}
| |||
25,960 | js_std_file_tell | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_tell(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int is_bigint)
{
FILE *f = js_std_file_get(ctx, this_val);
int64_t pos;
if (!f)
return JS_EXCEPTION;
#if defined(__linux__)
pos = ftello(f);
#else
pos = ftell(f);
#endif
if (is_bigint)
return JS_NewBigInt64(ctx, pos);
else
return JS_NewInt64(ctx, pos);
} | O2 | c | js_std_file_tell:
pushq %rbp
pushq %r14
pushq %rbx
movl %r9d, %ebp
movq %rdi, %rbx
callq 0x113c6
testq %rax, %rax
je 0x10f2e
movabsq $-0x100000000, %r14 # imm = 0xFFFFFFFF00000000
movq %rax, %rdi
callq 0xe120
testl %ebp, %ebp
je 0x10f38
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21d56
jmp 0x10f57
pushq $0x6
popq %rdx
xorl %eax, %eax
xorl %r14d, %r14d
jmp 0x10f5a
movslq %eax, %rcx
xorl %esi, %esi
cmpq %rax, %rcx
cvtsi2sd %rax, %xmm0
movl %ecx, %ecx
movq %xmm0, %rax
cmoveq %rcx, %rax
pushq $0x7
popq %rdx
cmoveq %rsi, %rdx
andq %rax, %r14
movl %eax, %eax
orq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
| js_std_file_tell:
push rbp
push r14
push rbx
mov ebp, r9d
mov rbx, rdi
call js_std_file_get
test rax, rax
jz short loc_10F2E
mov r14, 0FFFFFFFF00000000h
mov rdi, rax
call _ftello
test ebp, ebp
jz short loc_10F38
mov rdi, rbx
mov rsi, rax
call JS_NewBigInt64
jmp short loc_10F57
loc_10F2E:
push 6
pop rdx
xor eax, eax
xor r14d, r14d
jmp short loc_10F5A
loc_10F38:
movsxd rcx, eax
xor esi, esi
cmp rcx, rax
cvtsi2sd xmm0, rax
mov ecx, ecx
movq rax, xmm0
cmovz rax, rcx
push 7
pop rdx
cmovz rdx, rsi
loc_10F57:
and r14, rax
loc_10F5A:
mov eax, eax
or rax, r14
pop rbx
pop r14
pop rbp
retn
| unsigned long long js_std_file_tell(long long a1, long long a2, long long a3, long long a4, long long a5, int a6)
{
long long v7; // rax
long long v8; // rax
double v9; // rax
unsigned long long v10; // r14
bool v11; // zf
double v12; // rcx
v7 = js_std_file_get(a1);
if ( v7 )
{
v8 = ftello(v7);
if ( a6 )
{
v9 = COERCE_DOUBLE(JS_NewBigInt64(a1, v8));
}
else
{
v11 = (int)v8 == v8;
*(_QWORD *)&v12 = (unsigned int)v8;
v9 = (double)(int)v8;
if ( v11 )
v9 = v12;
}
v10 = *(_QWORD *)&v9 & 0xFFFFFFFF00000000LL;
}
else
{
LODWORD(v9) = 0;
v10 = 0LL;
}
return v10 | LODWORD(v9);
}
| js_std_file_tell:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,R9D
MOV RBX,RDI
CALL 0x001113c6
TEST RAX,RAX
JZ 0x00110f2e
MOV R14,-0x100000000
MOV RDI,RAX
CALL 0x0010e120
TEST EBP,EBP
JZ 0x00110f38
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00121d56
JMP 0x00110f57
LAB_00110f2e:
PUSH 0x6
POP RDX
XOR EAX,EAX
XOR R14D,R14D
JMP 0x00110f5a
LAB_00110f38:
MOVSXD RCX,EAX
XOR ESI,ESI
CMP RCX,RAX
CVTSI2SD XMM0,RAX
MOV ECX,ECX
MOVQ RAX,XMM0
CMOVZ RAX,RCX
PUSH 0x7
POP RDX
CMOVZ RDX,RSI
LAB_00110f57:
AND R14,RAX
LAB_00110f5a:
MOV EAX,EAX
OR RAX,R14
POP RBX
POP R14
POP RBP
RET
|
ulong js_std_file_tell(int8 param_1)
{
FILE *__stream;
ulong uVar1;
double dVar2;
int in_R9D;
__stream = (FILE *)js_std_file_get();
if (__stream == (FILE *)0x0) {
dVar2 = 0.0;
uVar1 = 0;
}
else {
uVar1 = ftello(__stream);
if (in_R9D == 0) {
dVar2 = (double)(long)uVar1;
if ((long)(int)uVar1 == uVar1) {
dVar2 = (double)(uVar1 & 0xffffffff);
}
}
else {
dVar2 = (double)JS_NewBigInt64(param_1,uVar1);
}
uVar1 = (ulong)dVar2 & 0xffffffff00000000;
}
return (ulong)dVar2 & 0xffffffff | uVar1;
}
| |
25,961 | common_model_params_to_llama(common_params&) | monkey531[P]llama/common/common.cpp | struct llama_model_params common_model_params_to_llama(common_params & params) {
auto mparams = llama_model_default_params();
if (!params.devices.empty()) {
mparams.devices = params.devices.data();
}
if (params.n_gpu_layers != -1) {
mparams.n_gpu_layers = params.n_gpu_layers;
}
mparams.main_gpu = params.main_gpu;
mparams.split_mode = params.split_mode;
mparams.tensor_split = params.tensor_split;
mparams.use_mmap = params.use_mmap;
mparams.use_mlock = params.use_mlock;
mparams.check_tensors = params.check_tensors;
if (params.kv_overrides.empty()) {
mparams.kv_overrides = NULL;
} else {
GGML_ASSERT(params.kv_overrides.back().key[0] == 0 && "KV overrides not terminated with empty key");
mparams.kv_overrides = params.kv_overrides.data();
}
return mparams;
} | O3 | cpp | common_model_params_to_llama(common_params&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x19d20
movq 0x50(%r14), %rax
cmpq 0x58(%r14), %rax
je 0x50904
movq %rax, (%rbx)
movl 0x68(%r14), %eax
cmpl $-0x1, %eax
je 0x50910
movl %eax, 0x8(%rbx)
movl 0x6c(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x270(%r14), %eax
movl %eax, 0xc(%rbx)
leaq 0x70(%r14), %rax
movq %rax, 0x18(%rbx)
movb 0xfe9(%r14), %al
movb %al, 0x39(%rbx)
movb 0xfea(%r14), %al
movb %al, 0x3a(%rbx)
movb 0xff0(%r14), %al
movb %al, 0x3b(%rbx)
movq 0xf48(%r14), %rax
movq 0xf50(%r14), %rcx
cmpq %rcx, %rax
je 0x50984
cmpb $0x0, -0x104(%rcx)
je 0x50986
leaq 0x6329b(%rip), %rdi # 0xb3c05
leaq 0x60787(%rip), %rdx # 0xb10f8
leaq 0x63795(%rip), %rcx # 0xb410d
movl $0x44b, %esi # imm = 0x44B
xorl %eax, %eax
callq 0x19d30
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _Z28common_model_params_to_llamaR13common_params:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
call _llama_model_default_params
mov rax, [r14+50h]
cmp rax, [r14+58h]
jz short loc_50904
mov [rbx], rax
loc_50904:
mov eax, [r14+68h]
cmp eax, 0FFFFFFFFh
jz short loc_50910
mov [rbx+8], eax
loc_50910:
mov eax, [r14+6Ch]
mov [rbx+10h], eax
mov eax, [r14+270h]
mov [rbx+0Ch], eax
lea rax, [r14+70h]
mov [rbx+18h], rax
mov al, [r14+0FE9h]
mov [rbx+39h], al
mov al, [r14+0FEAh]
mov [rbx+3Ah], al
mov al, [r14+0FF0h]
mov [rbx+3Bh], al
mov rax, [r14+0F48h]
mov rcx, [r14+0F50h]
cmp rax, rcx
jz short loc_50984
cmp byte ptr [rcx-104h], 0
jz short loc_50986
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aParamsKvOverri; "params.kv_overrides.back().key[0] == 0 "...
mov esi, 44Bh
xor eax, eax
call _ggml_abort
loc_50984:
xor eax, eax
loc_50986:
mov [rbx+30h], rax
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| long long common_model_params_to_llama(long long a1, long long a2)
{
long long v2; // rax
int v3; // eax
long long v4; // rax
long long v5; // rcx
llama_model_default_params(a1);
v2 = *(_QWORD *)(a2 + 80);
if ( v2 != *(_QWORD *)(a2 + 88) )
*(_QWORD *)a1 = v2;
v3 = *(_DWORD *)(a2 + 104);
if ( v3 != -1 )
*(_DWORD *)(a1 + 8) = v3;
*(_DWORD *)(a1 + 16) = *(_DWORD *)(a2 + 108);
*(_DWORD *)(a1 + 12) = *(_DWORD *)(a2 + 624);
*(_QWORD *)(a1 + 24) = a2 + 112;
*(_BYTE *)(a1 + 57) = *(_BYTE *)(a2 + 4073);
*(_BYTE *)(a1 + 58) = *(_BYTE *)(a2 + 4074);
*(_BYTE *)(a1 + 59) = *(_BYTE *)(a2 + 4080);
v4 = *(_QWORD *)(a2 + 3912);
v5 = *(_QWORD *)(a2 + 3920);
if ( v4 == v5 )
goto LABEL_8;
if ( *(_BYTE *)(v5 - 260) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
1099LL,
"GGML_ASSERT(%s) failed",
"params.kv_overrides.back().key[0] == 0 && \"KV overrides not terminated with empty key\"");
LABEL_8:
v4 = 0LL;
}
*(_QWORD *)(a1 + 48) = v4;
return a1;
}
| common_model_params_to_llama:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CALL 0x00119d20
MOV RAX,qword ptr [R14 + 0x50]
CMP RAX,qword ptr [R14 + 0x58]
JZ 0x00150904
MOV qword ptr [RBX],RAX
LAB_00150904:
MOV EAX,dword ptr [R14 + 0x68]
CMP EAX,-0x1
JZ 0x00150910
MOV dword ptr [RBX + 0x8],EAX
LAB_00150910:
MOV EAX,dword ptr [R14 + 0x6c]
MOV dword ptr [RBX + 0x10],EAX
MOV EAX,dword ptr [R14 + 0x270]
MOV dword ptr [RBX + 0xc],EAX
LEA RAX,[R14 + 0x70]
MOV qword ptr [RBX + 0x18],RAX
MOV AL,byte ptr [R14 + 0xfe9]
MOV byte ptr [RBX + 0x39],AL
MOV AL,byte ptr [R14 + 0xfea]
MOV byte ptr [RBX + 0x3a],AL
MOV AL,byte ptr [R14 + 0xff0]
MOV byte ptr [RBX + 0x3b],AL
MOV RAX,qword ptr [R14 + 0xf48]
MOV RCX,qword ptr [R14 + 0xf50]
CMP RAX,RCX
JZ 0x00150984
CMP byte ptr [RCX + -0x104],0x0
JZ 0x00150986
LEA RDI,[0x1b3c05]
LEA RDX,[0x1b10f8]
LEA RCX,[0x1b410d]
MOV ESI,0x44b
XOR EAX,EAX
CALL 0x00119d30
LAB_00150984:
XOR EAX,EAX
LAB_00150986:
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* common_model_params_to_llama(common_params&) */
common_params * common_model_params_to_llama(common_params *param_1)
{
long lVar1;
long in_RSI;
llama_model_default_params();
if (*(long *)(in_RSI + 0x50) != *(long *)(in_RSI + 0x58)) {
*(long *)param_1 = *(long *)(in_RSI + 0x50);
}
if (*(int *)(in_RSI + 0x68) != -1) {
*(int *)(param_1 + 8) = *(int *)(in_RSI + 0x68);
}
*(int4 *)(param_1 + 0x10) = *(int4 *)(in_RSI + 0x6c);
*(int4 *)(param_1 + 0xc) = *(int4 *)(in_RSI + 0x270);
*(long *)(param_1 + 0x18) = in_RSI + 0x70;
param_1[0x39] = *(common_params *)(in_RSI + 0xfe9);
param_1[0x3a] = *(common_params *)(in_RSI + 0xfea);
param_1[0x3b] = *(common_params *)(in_RSI + 0xff0);
lVar1 = *(long *)(in_RSI + 0xf48);
if (lVar1 == *(long *)(in_RSI + 0xf50)) {
lVar1 = 0;
}
else if (*(char *)(*(long *)(in_RSI + 0xf50) + -0x104) != '\0') {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",1099,
"GGML_ASSERT(%s) failed",
"params.kv_overrides.back().key[0] == 0 && \"KV overrides not terminated with empty key\""
);
}
*(long *)(param_1 + 0x30) = lVar1;
return param_1;
}
| |
25,962 | ggml_get_max_tensor_size | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | size_t ggml_get_max_tensor_size(const struct ggml_context * ctx) {
size_t max_size = 0;
for (struct ggml_tensor * tensor = ggml_get_first_tensor(ctx); tensor != NULL; tensor = ggml_get_next_tensor(ctx, tensor)) {
size_t bytes = ggml_nbytes(tensor);
max_size = MAX(max_size, bytes);
}
return max_size;
} | O0 | c | ggml_get_max_tensor_size:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43530
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4becc
movq -0x18(%rbp), %rdi
callq 0x42650
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x4bea9
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4beb1
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45e90
movq %rax, -0x18(%rbp)
jmp 0x4be81
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ggml_get_max_tensor_size:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], 0
mov rdi, [rbp+var_8]
call _ggml_get_first_tensor
mov [rbp+var_18], rax
loc_4BE81:
cmp [rbp+var_18], 0
jz short loc_4BECC
mov rdi, [rbp+var_18]
call _ggml_nbytes
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
cmp rax, [rbp+var_20]
jbe short loc_4BEA9
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
jmp short loc_4BEB1
loc_4BEA9:
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_4BEB1:
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call _ggml_get_next_tensor
mov [rbp+var_18], rax
jmp short loc_4BE81
loc_4BECC:
mov rax, [rbp+var_10]
add rsp, 30h
pop rbp
retn
| unsigned long long ggml_get_max_tensor_size(long long a1)
{
unsigned long long v2; // [rsp+8h] [rbp-28h]
unsigned long long v3; // [rsp+10h] [rbp-20h]
unsigned int *i; // [rsp+18h] [rbp-18h]
unsigned long long v5; // [rsp+20h] [rbp-10h]
v5 = 0LL;
for ( i = (unsigned int *)ggml_get_first_tensor(a1); i; i = (unsigned int *)ggml_get_next_tensor(a1, i) )
{
v3 = ggml_nbytes(i);
if ( v5 <= v3 )
v2 = v3;
else
v2 = v5;
v5 = v2;
}
return v5;
}
| ggml_get_max_tensor_size:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],0x0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00143530
MOV qword ptr [RBP + -0x18],RAX
LAB_0014be81:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0014becc
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00142650
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0014bea9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0014beb1
LAB_0014bea9:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_0014beb1:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00145e90
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0014be81
LAB_0014becc:
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x30
POP RBP
RET
|
ulong ggml_get_max_tensor_size(int8 param_1)
{
ulong local_30;
long local_20;
ulong local_18;
local_18 = 0;
for (local_20 = ggml_get_first_tensor(param_1); local_20 != 0;
local_20 = ggml_get_next_tensor(param_1,local_20)) {
local_30 = ggml_nbytes(local_20);
if (local_30 < local_18) {
local_30 = local_18;
}
local_18 = local_30;
}
return local_18;
}
| |
25,963 | my_getcputime | eloqsql/mysys/my_getsystime.c | ulonglong my_getcputime()
{
#ifdef CLOCK_THREAD_CPUTIME_ID
struct timespec tp;
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tp))
return 0;
return (ulonglong)tp.tv_sec*10000000+(ulonglong)tp.tv_nsec/100;
#elif defined(__NR_clock_gettime)
struct timespec tp;
if (syscall(__NR_clock_gettime, CLOCK_THREAD_CPUTIME_ID, &tp))
return 0;
return (ulonglong)tp.tv_sec*10000000+(ulonglong)tp.tv_nsec/100;
#endif /* CLOCK_THREAD_CPUTIME_ID */
return 0;
} | O0 | c | my_getcputime:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x3, %edi
leaq -0x18(%rbp), %rsi
callq 0x252c0
cmpl $0x0, %eax
je 0x43dc5
movq $0x0, -0x8(%rbp)
jmp 0x43ded
imulq $0x989680, -0x18(%rbp), %rax # imm = 0x989680
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_getcputime:
push rbp
mov rbp, rsp
sub rsp, 20h
mov edi, 3
lea rsi, [rbp+var_18]
call _clock_gettime
cmp eax, 0
jz short loc_43DC5
mov [rbp+var_8], 0
jmp short loc_43DED
loc_43DC5:
imul rax, [rbp+var_18], 989680h
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov ecx, 64h ; 'd'
xor edx, edx
div rcx
mov rcx, rax
mov rax, [rbp+var_20]
add rax, rcx
mov [rbp+var_8], rax
loc_43DED:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| unsigned long long my_getcputime()
{
long long v1; // [rsp+8h] [rbp-18h] BYREF
unsigned long long v2; // [rsp+10h] [rbp-10h]
if ( (unsigned int)clock_gettime(3LL, &v1) )
return 0LL;
else
return v2 / 0x64 + 10000000 * v1;
}
| my_getcputime:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV EDI,0x3
LEA RSI,[RBP + -0x18]
CALL 0x001252c0
CMP EAX,0x0
JZ 0x00143dc5
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00143ded
LAB_00143dc5:
IMUL RAX,qword ptr [RBP + -0x18],0x989680
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x64
XOR EDX,EDX
DIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_00143ded:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
long my_getcputime(void)
{
int iVar1;
timespec local_20;
long local_10;
iVar1 = clock_gettime(3,&local_20);
if (iVar1 == 0) {
local_10 = local_20.tv_sec * 10000000 + (ulong)local_20.tv_nsec / 100;
}
else {
local_10 = 0;
}
return local_10;
}
| |
25,964 | get_charset_name | eloqsql/mysys/charset.c | const char *get_charset_name(uint charset_number)
{
my_pthread_once(&charsets_initialized, init_available_charsets);
if (charset_number < array_elements(all_charsets))
{
CHARSET_INFO *cs= all_charsets[charset_number];
if (cs && (cs->number == charset_number) && cs->coll_name.str)
return cs->coll_name.str;
}
return "?"; /* this mimics find_type() */
} | O0 | c | get_charset_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
leaq 0x3646d2(%rip), %rdi # 0x38e6e4
leaq -0x479(%rip), %rsi # 0x29ba0
callq 0x242a0
cmpl $0x800, -0xc(%rbp) # imm = 0x800
jae 0x2a068
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x35c63d(%rip), %rax # 0x386670
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2a066
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x2a066
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2a066
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a073
jmp 0x2a068
leaq 0x4f84f(%rip), %rax # 0x798be
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| get_charset_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_C], edi
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
cmp [rbp+var_C], 800h
jnb short loc_2A068
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, all_charsets
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_2A066
mov rax, [rbp+var_18]
mov eax, [rax]
cmp eax, [rbp+var_C]
jnz short loc_2A066
mov rax, [rbp+var_18]
cmp qword ptr [rax+20h], 0
jz short loc_2A066
mov rax, [rbp+var_18]
mov rax, [rax+20h]
mov [rbp+var_8], rax
jmp short loc_2A073
loc_2A066:
jmp short $+2
loc_2A068:
lea rax, asc_798BE; "?"
mov [rbp+var_8], rax
loc_2A073:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| const char * get_charset_name(unsigned int a1)
{
long long v2; // [rsp+8h] [rbp-18h]
pthread_once(&charsets_initialized, init_available_charsets);
if ( a1 < 0x800 && (v2 = all_charsets[a1]) != 0 && *(_DWORD *)v2 == a1 && *(_QWORD *)(v2 + 32) )
return *(const char **)(v2 + 32);
else
return "?";
}
| get_charset_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0xc],EDI
LEA RDI,[0x48e6e4]
LEA RSI,[0x129ba0]
CALL 0x001242a0
CMP dword ptr [RBP + -0xc],0x800
JNC 0x0012a068
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0x486670]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0012a066
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RBP + -0xc]
JNZ 0x0012a066
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x0012a066
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012a073
LAB_0012a066:
JMP 0x0012a068
LAB_0012a068:
LEA RAX,[0x1798be]
MOV qword ptr [RBP + -0x8],RAX
LAB_0012a073:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int * get_charset_name(uint param_1)
{
uint *puVar1;
int *local_10;
pthread_once(&charsets_initialized,init_available_charsets);
if ((((param_1 < 0x800) && (puVar1 = (uint *)(&all_charsets)[param_1], puVar1 != (uint *)0x0)) &&
(*puVar1 == param_1)) && (*(long *)(puVar1 + 8) != 0)) {
local_10 = *(int **)(puVar1 + 8);
}
else {
local_10 = &DAT_001798be;
}
return local_10;
}
| |
25,965 | diff | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static Bigint *diff(Bigint *a, Bigint *b, Stack_alloc *alloc)
{
Bigint *c;
int i, wa, wb;
ULong *xa, *xae, *xb, *xbe, *xc;
ULLong borrow, y;
i= cmp(a,b);
if (!i)
{
c= Balloc(0, alloc);
c->wds= 1;
c->p.x[0]= 0;
return c;
}
if (i < 0)
{
c= a;
a= b;
b= c;
i= 1;
}
else
i= 0;
c= Balloc(a->k, alloc);
c->sign= i;
wa= a->wds;
xa= a->p.x;
xae= xa + wa;
wb= b->wds;
xb= b->p.x;
xbe= xb + wb;
xc= c->p.x;
borrow= 0;
do
{
y= (ULLong)*xa++ - *xb++ - borrow;
borrow= y >> 32 & (ULong)1;
*xc++= (ULong) (y & FFFFFFFF);
}
while (xb < xbe);
while (xa < xae)
{
y= *xa++ - borrow;
borrow= y >> 32 & (ULong)1;
*xc++= (ULong) (y & FFFFFFFF);
}
while (!*--xc)
wa--;
c->wds= wa;
return c;
} | O0 | c | diff:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a890
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x3aede
movq -0x20(%rbp), %rsi
xorl %edi, %edi
callq 0x3aaa0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b08a
cmpl $0x0, -0x2c(%rbp)
jge 0x3af05
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x3af0c
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rsi
callq 0x3aaa0
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
addq $0x4, %rdx
movq %rdx, -0x50(%rbp)
movl (%rcx), %ecx
subq %rcx, %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x68(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x70(%rbp), %rax
movl %eax, %ecx
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x60(%rbp)
movl %ecx, (%rax)
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
jb 0x3af8d
jmp 0x3aff7
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x3b04d
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x68(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x70(%rbp), %rax
movl %eax, %ecx
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x60(%rbp)
movl %ecx, (%rax)
jmp 0x3aff7
jmp 0x3b04f
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x60(%rbp)
cmpl $0x0, -0x4(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3b06d
jmp 0x3b078
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3b04f
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| diff:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call cmp
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 0
jnz short loc_3AEDE
mov rsi, [rbp+var_20]
xor edi, edi
call Balloc
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov dword ptr [rax+14h], 1
mov rax, [rbp+var_28]
mov rax, [rax]
mov dword ptr [rax], 0
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp loc_3B08A
loc_3AEDE:
cmp [rbp+var_2C], 0
jge short loc_3AF05
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_10], rax
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov [rbp+var_2C], 1
jmp short loc_3AF0C
loc_3AF05:
mov [rbp+var_2C], 0
loc_3AF0C:
mov rax, [rbp+var_10]
mov edi, [rax+8]
mov rsi, [rbp+var_20]
call Balloc
mov [rbp+var_28], rax
mov ecx, [rbp+var_2C]
mov rax, [rbp+var_28]
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov eax, [rax+14h]
mov [rbp+var_30], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
movsxd rcx, [rbp+var_30]
shl rcx, 2
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov eax, [rax+14h]
mov [rbp+var_34], eax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
movsxd rcx, [rbp+var_34]
shl rcx, 2
add rax, rcx
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_60], rax
mov [rbp+var_68], 0
loc_3AF8D:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov eax, [rax]
mov rcx, [rbp+var_50]
mov rdx, rcx
add rdx, 4
mov [rbp+var_50], rdx
mov ecx, [rcx]
sub rax, rcx
sub rax, [rbp+var_68]
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
shr rax, 20h
and rax, 1
mov [rbp+var_68], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_70]
mov ecx, eax
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 4
mov [rbp+var_60], rdx
mov [rax], ecx
mov rax, [rbp+var_50]
cmp rax, [rbp+var_58]
jb short loc_3AF8D
jmp short $+2
loc_3AFF7:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_48]
jnb short loc_3B04D
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov eax, [rax]
sub rax, [rbp+var_68]
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
shr rax, 20h
and rax, 1
mov [rbp+var_68], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_70]
mov ecx, eax
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 4
mov [rbp+var_60], rdx
mov [rax], ecx
jmp short loc_3AFF7
loc_3B04D:
jmp short $+2
loc_3B04F:
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_60], rcx
cmp dword ptr [rax-4], 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_3B06D
jmp short loc_3B078
loc_3B06D:
mov eax, [rbp+var_30]
add eax, 0FFFFFFFFh
mov [rbp+var_30], eax
jmp short loc_3B04F
loc_3B078:
mov ecx, [rbp+var_30]
mov rax, [rbp+var_28]
mov [rax+14h], ecx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_3B08A:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
| long long diff(long long a1, long long a2, long long a3)
{
unsigned int *v3; // rax
unsigned int *v4; // rcx
_DWORD *v5; // rax
unsigned int *v6; // rax
_DWORD *v7; // rax
_DWORD *v8; // rax
unsigned long long v10; // [rsp+0h] [rbp-70h]
unsigned long long v11; // [rsp+0h] [rbp-70h]
long long v12; // [rsp+8h] [rbp-68h]
_DWORD *v13; // [rsp+10h] [rbp-60h]
unsigned long long v14; // [rsp+18h] [rbp-58h]
unsigned int *v15; // [rsp+20h] [rbp-50h]
unsigned long long v16; // [rsp+28h] [rbp-48h]
unsigned int *v17; // [rsp+30h] [rbp-40h]
int v18; // [rsp+40h] [rbp-30h]
int v19; // [rsp+44h] [rbp-2Ch]
int v20; // [rsp+44h] [rbp-2Ch]
long long v21; // [rsp+48h] [rbp-28h]
long long v22; // [rsp+48h] [rbp-28h]
long long v24; // [rsp+58h] [rbp-18h]
long long v25; // [rsp+60h] [rbp-10h]
v25 = a1;
v24 = a2;
v19 = cmp(a1, a2);
if ( v19 )
{
if ( v19 >= 0 )
{
v20 = 0;
}
else
{
v25 = a2;
v24 = a1;
v20 = 1;
}
v22 = Balloc(*(_DWORD *)(v25 + 8), a3);
*(_DWORD *)(v22 + 16) = v20;
v18 = *(_DWORD *)(v25 + 20);
v17 = *(unsigned int **)v25;
v16 = 4LL * v18 + *(_QWORD *)v25;
v15 = *(unsigned int **)v24;
v14 = 4LL * *(int *)(v24 + 20) + *(_QWORD *)v24;
v13 = *(_DWORD **)v22;
v12 = 0LL;
do
{
v3 = v17++;
v4 = v15++;
v10 = *v3 - (unsigned long long)*v4 - v12;
v12 = HIDWORD(v10) & 1;
v5 = v13++;
*v5 = v10;
}
while ( (unsigned long long)v15 < v14 );
while ( (unsigned long long)v17 < v16 )
{
v6 = v17++;
v11 = *v6 - v12;
v12 = HIDWORD(v11) & 1;
v7 = v13++;
*v7 = v11;
}
while ( 1 )
{
v8 = v13--;
if ( *(v8 - 1) )
break;
--v18;
}
*(_DWORD *)(v22 + 20) = v18;
return v22;
}
else
{
v21 = Balloc(0, a3);
*(_DWORD *)(v21 + 20) = 1;
**(_DWORD **)v21 = 0;
return v21;
}
}
| diff:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0013a890
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x0013aede
MOV RSI,qword ptr [RBP + -0x20]
XOR EDI,EDI
CALL 0x0013aaa0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x14],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0013b08a
LAB_0013aede:
CMP dword ptr [RBP + -0x2c],0x0
JGE 0x0013af05
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x2c],0x1
JMP 0x0013af0c
LAB_0013af05:
MOV dword ptr [RBP + -0x2c],0x0
LAB_0013af0c:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0013aaa0
MOV qword ptr [RBP + -0x28],RAX
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x30],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOVSXD RCX,dword ptr [RBP + -0x30]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOVSXD RCX,dword ptr [RBP + -0x34]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBP + -0x68],0x0
LAB_0013af8d:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x50]
MOV RDX,RCX
ADD RDX,0x4
MOV qword ptr [RBP + -0x50],RDX
MOV ECX,dword ptr [RCX]
SUB RAX,RCX
SUB RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
SHR RAX,0x20
AND RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x70]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x60],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x58]
JC 0x0013af8d
JMP 0x0013aff7
LAB_0013aff7:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x48]
JNC 0x0013b04d
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RAX]
SUB RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
SHR RAX,0x20
AND RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x70]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x60],RDX
MOV dword ptr [RAX],ECX
JMP 0x0013aff7
LAB_0013b04d:
JMP 0x0013b04f
LAB_0013b04f:
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x60],RCX
CMP dword ptr [RAX + -0x4],0x0
SETNZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x0013b06d
JMP 0x0013b078
LAB_0013b06d:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0013b04f
LAB_0013b078:
MOV ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x14],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_0013b08a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x70
POP RBP
RET
|
int8 * diff(int8 *param_1,int8 *param_2,int8 param_3)
{
uint *puVar1;
uint *puVar2;
int iVar3;
ulong uVar4;
uint *puVar5;
uint *puVar6;
int4 *puVar7;
ulong local_70;
int4 *local_68;
uint *local_58;
uint *local_48;
int local_38;
uint local_34;
int8 *local_20;
int8 *local_18;
int8 *local_10;
iVar3 = cmp(param_1,param_2);
if (iVar3 == 0) {
local_10 = (int8 *)Balloc(0,param_3);
*(int4 *)((long)local_10 + 0x14) = 1;
*(int4 *)*local_10 = 0;
}
else {
local_20 = param_2;
local_18 = param_1;
if (iVar3 < 0) {
local_20 = param_1;
local_18 = param_2;
}
local_34 = (uint)(iVar3 < 0);
local_10 = (int8 *)Balloc(*(int4 *)(local_18 + 1),param_3);
*(uint *)(local_10 + 2) = local_34;
local_38 = *(int *)((long)local_18 + 0x14);
puVar1 = (uint *)*local_18;
iVar3 = *(int *)((long)local_20 + 0x14);
puVar2 = (uint *)*local_20;
local_70 = 0;
local_68 = (int4 *)*local_10;
local_58 = puVar2;
local_48 = puVar1;
do {
puVar5 = local_48 + 1;
puVar6 = local_58 + 1;
uVar4 = ((ulong)*local_48 - (ulong)*local_58) - local_70;
local_70 = uVar4 >> 0x20 & 1;
puVar7 = local_68 + 1;
*local_68 = (int)uVar4;
local_68 = puVar7;
local_58 = puVar6;
local_48 = puVar5;
} while (puVar6 < puVar2 + iVar3);
while (local_48 < puVar1 + local_38) {
uVar4 = *local_48 - local_70;
local_70 = uVar4 >> 0x20 & 1;
*local_68 = (int)uVar4;
local_68 = local_68 + 1;
local_48 = local_48 + 1;
}
while (local_68[-1] == 0) {
local_38 = local_38 + -1;
local_68 = local_68 + -1;
}
*(int *)((long)local_10 + 0x14) = local_38;
}
return local_10;
}
| |
25,966 | my_setwd | eloqsql/mysys/my_getwd.c | int my_setwd(const char *dir, myf MyFlags)
{
int res;
size_t length;
char *start, *pos;
DBUG_ENTER("my_setwd");
DBUG_PRINT("my",("dir: '%s' MyFlags %lu", dir, MyFlags));
start=(char *) dir;
if (! dir[0] || (dir[0] == FN_LIBCHAR && dir[1] == 0))
dir=FN_ROOTDIR;
if ((res=chdir((char*) dir)) != 0)
{
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_SETWD,MYF(ME_BELL),start,errno);
}
else
{
if (test_if_hard_path(start))
{ /* Hard pathname */
pos= strmake(&curr_dir[0],start,(size_t) FN_REFLEN-1);
if (pos[-1] != FN_LIBCHAR)
{
length=(uint) (pos-(char*) curr_dir);
curr_dir[length]=FN_LIBCHAR; /* must end with '/' */
curr_dir[length+1]='\0';
}
}
else
curr_dir[0]='\0'; /* Don't save name */
}
DBUG_RETURN(res);
} | O3 | c | my_setwd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0x2c0bf
movq %r14, %rdi
cmpl $0x2f, %eax
jne 0x2c0c6
cmpb $0x0, 0x1(%r14)
movq %r14, %rdi
jne 0x2c0c6
leaq 0x3950b(%rip), %rdi # 0x655d1
callq 0x24560
movl %eax, %ebx
testl %eax, %eax
je 0x2c104
callq 0x24050
movq %rax, %r12
movl (%rax), %r13d
callq 0x2df82
movl %r13d, (%rax)
testb $0x10, %r15b
je 0x2c161
movl (%r12), %ecx
movl $0x4, %esi
movl $0x11, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x295ff
jmp 0x2c161
leaq 0x34506d(%rip), %rax # 0x371178
movq (%rax), %rax
movq %r14, %rcx
movzbl (%rcx), %edx
cmpl $0x7e, %edx
jne 0x2c129
cmpb $0x2f, 0x1(%rcx)
jne 0x2c157
movq %rax, %rcx
testq %rax, %rax
jne 0x2c111
jmp 0x2c157
cmpl $0x2f, %edx
jne 0x2c157
leaq 0x34505b(%rip), %r15 # 0x371190
movl $0x1ff, %edx # imm = 0x1FF
movq %r15, %rdi
movq %r14, %rsi
callq 0x61c20
cmpb $0x2f, -0x1(%rax)
je 0x2c161
subl %r15d, %eax
movw $0x2f, (%r15,%rax)
jmp 0x2c161
leaq 0x345032(%rip), %rax # 0x371190
movb $0x0, (%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_setwd:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_2C0BF
mov rdi, r14
cmp eax, 2Fh ; '/'
jnz short loc_2C0C6
cmp byte ptr [r14+1], 0
mov rdi, r14
jnz short loc_2C0C6
loc_2C0BF:
lea rdi, unk_655D1
loc_2C0C6:
call _chdir
mov ebx, eax
test eax, eax
jz short loc_2C104
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
test r15b, 10h
jz short loc_2C161
mov ecx, [r12]
mov esi, 4
mov edi, 11h
mov rdx, r14
xor eax, eax
call my_error
jmp short loc_2C161
loc_2C104:
lea rax, home_dir
mov rax, [rax]
mov rcx, r14
loc_2C111:
movzx edx, byte ptr [rcx]
cmp edx, 7Eh ; '~'
jnz short loc_2C129
cmp byte ptr [rcx+1], 2Fh ; '/'
jnz short loc_2C157
mov rcx, rax
test rax, rax
jnz short loc_2C111
jmp short loc_2C157
loc_2C129:
cmp edx, 2Fh ; '/'
jnz short loc_2C157
lea r15, curr_dir
mov edx, 1FFh
mov rdi, r15
mov rsi, r14
call strmake
cmp byte ptr [rax-1], 2Fh ; '/'
jz short loc_2C161
sub eax, r15d
mov word ptr [r15+rax], 2Fh ; '/'
jmp short loc_2C161
loc_2C157:
lea rax, curr_dir
mov byte ptr [rax], 0
loc_2C161:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_setwd(unsigned __int8 *a1, char a2)
{
unsigned __int8 *v2; // r14
unsigned int v3; // ebx
unsigned int *v4; // r12
unsigned int v5; // r13d
unsigned __int8 *v6; // rcx
int v7; // edx
long long v8; // rax
v2 = a1;
if ( !*a1 || *a1 == 47 && !a1[1] )
a1 = (unsigned __int8 *)&unk_655D1;
v3 = chdir(a1);
if ( v3 )
{
v4 = (unsigned int *)__errno_location(a1);
v5 = *v4;
*(_DWORD *)my_thread_var(a1) = v5;
if ( (a2 & 0x10) != 0 )
my_error(0x11u, 4LL, v2, *v4);
}
else
{
v6 = v2;
while ( 1 )
{
v7 = *v6;
if ( v7 != 126 )
break;
if ( v6[1] == 47 )
{
v6 = (unsigned __int8 *)home_dir;
if ( home_dir )
continue;
}
goto LABEL_16;
}
if ( v7 != 47 )
{
LABEL_16:
curr_dir[0] = 0;
return v3;
}
v8 = strmake(curr_dir, v2, 511LL);
if ( *(_BYTE *)(v8 - 1) != 47 )
*(_WORD *)&curr_dir[(unsigned int)v8 - (unsigned int)curr_dir] = 47;
}
return v3;
}
| my_setwd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x0012c0bf
MOV RDI,R14
CMP EAX,0x2f
JNZ 0x0012c0c6
CMP byte ptr [R14 + 0x1],0x0
MOV RDI,R14
JNZ 0x0012c0c6
LAB_0012c0bf:
LEA RDI,[0x1655d1]
LAB_0012c0c6:
CALL 0x00124560
MOV EBX,EAX
TEST EAX,EAX
JZ 0x0012c104
CALL 0x00124050
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x0012df82
MOV dword ptr [RAX],R13D
TEST R15B,0x10
JZ 0x0012c161
MOV ECX,dword ptr [R12]
MOV ESI,0x4
MOV EDI,0x11
MOV RDX,R14
XOR EAX,EAX
CALL 0x001295ff
JMP 0x0012c161
LAB_0012c104:
LEA RAX,[0x471178]
MOV RAX,qword ptr [RAX]
MOV RCX,R14
LAB_0012c111:
MOVZX EDX,byte ptr [RCX]
CMP EDX,0x7e
JNZ 0x0012c129
CMP byte ptr [RCX + 0x1],0x2f
JNZ 0x0012c157
MOV RCX,RAX
TEST RAX,RAX
JNZ 0x0012c111
JMP 0x0012c157
LAB_0012c129:
CMP EDX,0x2f
JNZ 0x0012c157
LEA R15,[0x471190]
MOV EDX,0x1ff
MOV RDI,R15
MOV RSI,R14
CALL 0x00161c20
CMP byte ptr [RAX + -0x1],0x2f
JZ 0x0012c161
SUB EAX,R15D
MOV word ptr [R15 + RAX*0x1],0x2f
JMP 0x0012c161
LAB_0012c157:
LEA RAX,[0x471190]
MOV byte ptr [RAX],0x0
LAB_0012c161:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_setwd(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
long lVar5;
char *pcVar6;
if ((*param_1 == '\0') || ((pcVar6 = param_1, *param_1 == '/' && (param_1[1] == '\0')))) {
pcVar6 = "/";
}
iVar2 = chdir(pcVar6);
pcVar6 = param_1;
if (iVar2 == 0) {
while (*pcVar6 == '~') {
if ((pcVar6[1] != '/') || (pcVar6 = home_dir, home_dir == (char *)0x0)) goto LAB_0012c157;
}
if (*pcVar6 == '/') {
lVar5 = strmake(&curr_dir,param_1,0x1ff);
if (*(char *)(lVar5 + -1) == '/') {
return 0;
}
*(int2 *)(&curr_dir + ((int)lVar5 - 0x471190)) = 0x2f;
return 0;
}
LAB_0012c157:
curr_dir = 0;
}
else {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if ((param_2 & 0x10) != 0) {
my_error(0x11,4,param_1,*piVar3);
}
}
return iVar2;
}
| |
25,967 | google::protobuf::internal::ReflectionSchema::GetFieldOffset(google::protobuf::FieldDescriptor const*) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/generated_message_reflection.h | uint32_t GetFieldOffset(const FieldDescriptor* field) const {
if (InRealOneof(field)) {
size_t offset =
static_cast<size_t>(field->containing_type()->field_count()) +
field->containing_oneof()->index();
return OffsetValue(offsets_[offset], field->type());
} else {
return GetFieldOffsetNonOneof(field);
}
} | O3 | c | google::protobuf::internal::ReflectionSchema::GetFieldOffset(google::protobuf::FieldDescriptor const*) const:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
testb $0x10, 0x1(%rsi)
sete %al
movq 0x28(%rsi), %rcx
testq %rcx, %rcx
sete %dl
orb %al, %dl
je 0x97fa4
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x98024
cmpl $0x1, 0x4(%rcx)
jne 0x97fb4
movq 0x20(%rcx), %rax
testb $0x2, 0x1(%rax)
jne 0x97f96
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
movslq 0x4(%rdx), %rdx
movq 0x10(%rcx), %rsi
subq 0x30(%rsi), %rcx
shrq $0x3, %rcx
shlq $0x2, %rdx
addq 0x8(%rdi), %rdx
imull $0xcccccccd, %ecx, %ecx # imm = 0xCCCCCCCD
movslq %ecx, %rcx
movl (%rdx,%rcx,4), %ebp
testq %rax, %rax
je 0x98004
leaq 0x45168(%rip), %rcx # 0xdd154
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
movq %rax, %rdi
callq 0x97dfb
movzbl 0x2(%rbx), %eax
cmpl $0xc, %eax
ja 0x9801a
movl $0x1a00, %ecx # imm = 0x1A00
btl %eax, %ecx
jae 0x9801a
andl $-0x2, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
| _ZNK6google8protobuf8internal16ReflectionSchema14GetFieldOffsetEPKNS0_15FieldDescriptorE:
push rbp
push rbx
sub rsp, 18h
mov rbx, rsi
test byte ptr [rsi+1], 10h
setz al
mov rcx, [rsi+28h]
test rcx, rcx
setz dl
or dl, al
jz short loc_97FA4
loc_97F96:
mov rsi, rbx; google::protobuf::FieldDescriptor *
add rsp, 18h
pop rbx
pop rbp
jmp _ZNK6google8protobuf8internal16ReflectionSchema22GetFieldOffsetNonOneofEPKNS0_15FieldDescriptorE; google::protobuf::internal::ReflectionSchema::GetFieldOffsetNonOneof(google::protobuf::FieldDescriptor const*)
loc_97FA4:
cmp dword ptr [rcx+4], 1
jnz short loc_97FB4
mov rax, [rcx+20h]
test byte ptr [rax+1], 2
jnz short loc_97F96
loc_97FB4:
mov rax, [rbx+18h]
mov rdx, [rbx+20h]
movsxd rdx, dword ptr [rdx+4]
mov rsi, [rcx+10h]
sub rcx, [rsi+30h]
shr rcx, 3
shl rdx, 2
add rdx, [rdi+8]
imul ecx, 0CCCCCCCDh
movsxd rcx, ecx
mov ebp, [rdx+rcx*4]
test rax, rax
jz short loc_98004
lea rcx, _ZN6google8protobuf15FieldDescriptor12TypeOnceInitEPKS1_; google::protobuf::FieldDescriptor::TypeOnceInit(google::protobuf::FieldDescriptor const*)
lea rsi, [rsp+28h+var_18]
mov [rsi], rcx
lea rdx, [rsp+28h+var_20]
mov [rdx], rbx
mov rdi, rax
call _ZSt9call_onceIPFvPKN6google8protobuf15FieldDescriptorEEJS4_EEvRSt9once_flagOT_DpOT0_; std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(std::once_flag &,void (*)(google::protobuf::FieldDescriptor const*) &&,google::protobuf::FieldDescriptor const* &&)
loc_98004:
movzx eax, byte ptr [rbx+2]
cmp eax, 0Ch
ja short loc_9801A
mov ecx, 1A00h
bt ecx, eax
jnb short loc_9801A
and ebp, 0FFFFFFFEh
loc_9801A:
mov eax, ebp
add rsp, 18h
pop rbx
pop rbp
retn
| long long google::protobuf::internal::ReflectionSchema::GetFieldOffset(
google::protobuf::internal::ReflectionSchema *this,
const google::protobuf::FieldDescriptor *a2)
{
long long v2; // rcx
long long v4; // rax
unsigned int v5; // ebp
unsigned int v6; // eax
int v7; // ecx
const google::protobuf::FieldDescriptor *v8; // [rsp+8h] [rbp-20h] BYREF
long long ( *v9[3])(google::protobuf::FieldDescriptor *__hidden); // [rsp+10h] [rbp-18h] BYREF
v2 = *((_QWORD *)a2 + 5);
if ( (*((_BYTE *)a2 + 1) & 0x10) == 0
|| v2 == 0
|| *(_DWORD *)(v2 + 4) == 1 && (*(_BYTE *)(*(_QWORD *)(v2 + 32) + 1LL) & 2) != 0 )
{
return google::protobuf::internal::ReflectionSchema::GetFieldOffsetNonOneof(this, a2);
}
v4 = *((_QWORD *)a2 + 3);
v5 = *(_DWORD *)(*((_QWORD *)this + 1)
+ 4LL * *(int *)(*((_QWORD *)a2 + 4) + 4LL)
+ 4LL * (int)(-858993459 * ((unsigned long long)(v2 - *(_QWORD *)(*(_QWORD *)(v2 + 16) + 48LL)) >> 3)));
if ( v4 )
{
v9[0] = google::protobuf::FieldDescriptor::TypeOnceInit;
v8 = a2;
std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(
v4,
(long long)v9,
(long long)&v8);
}
v6 = *((unsigned __int8 *)a2 + 2);
if ( v6 <= 0xC )
{
v7 = 6656;
if ( _bittest(&v7, v6) )
v5 &= ~1u;
}
return v5;
}
| GetFieldOffset:
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
TEST byte ptr [RSI + 0x1],0x10
SETZ AL
MOV RCX,qword ptr [RSI + 0x28]
TEST RCX,RCX
SETZ DL
OR DL,AL
JZ 0x00197fa4
LAB_00197f96:
MOV RSI,RBX
ADD RSP,0x18
POP RBX
POP RBP
JMP 0x00198024
LAB_00197fa4:
CMP dword ptr [RCX + 0x4],0x1
JNZ 0x00197fb4
MOV RAX,qword ptr [RCX + 0x20]
TEST byte ptr [RAX + 0x1],0x2
JNZ 0x00197f96
LAB_00197fb4:
MOV RAX,qword ptr [RBX + 0x18]
MOV RDX,qword ptr [RBX + 0x20]
MOVSXD RDX,dword ptr [RDX + 0x4]
MOV RSI,qword ptr [RCX + 0x10]
SUB RCX,qword ptr [RSI + 0x30]
SHR RCX,0x3
SHL RDX,0x2
ADD RDX,qword ptr [RDI + 0x8]
IMUL ECX,ECX,-0x33333333
MOVSXD RCX,ECX
MOV EBP,dword ptr [RDX + RCX*0x4]
TEST RAX,RAX
JZ 0x00198004
LEA RCX,[0x1dd154]
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RCX
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RBX
MOV RDI,RAX
CALL 0x00197dfb
LAB_00198004:
MOVZX EAX,byte ptr [RBX + 0x2]
CMP EAX,0xc
JA 0x0019801a
MOV ECX,0x1a00
BT ECX,EAX
JNC 0x0019801a
AND EBP,0xfffffffe
LAB_0019801a:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP RBP
RET
|
/* google::protobuf::internal::ReflectionSchema::GetFieldOffset(google::protobuf::FieldDescriptor
const*) const */
ulong __thiscall
google::protobuf::internal::ReflectionSchema::GetFieldOffset
(ReflectionSchema *this,FieldDescriptor *param_1)
{
long lVar1;
ulong uVar2;
uint uVar3;
FieldDescriptor *local_20;
code *local_18;
lVar1 = *(long *)(param_1 + 0x28);
if ((lVar1 != 0 && ((byte)param_1[1] & 0x10) != 0) &&
((*(int *)(lVar1 + 4) != 1 || ((*(byte *)(*(long *)(lVar1 + 0x20) + 1) & 2) == 0)))) {
uVar3 = *(uint *)((long)*(int *)(*(long *)(param_1 + 0x20) + 4) * 4 + *(long *)(this + 8) +
(long)((int)((ulong)(lVar1 - *(long *)(*(long *)(lVar1 + 0x10) + 0x30)) >> 3) *
-0x33333333) * 4);
if (*(once_flag **)(param_1 + 0x18) != (once_flag *)0x0) {
local_18 = FieldDescriptor::TypeOnceInit;
local_20 = param_1;
std::
call_once<void(*)(google::protobuf::FieldDescriptor_const*),google::protobuf::FieldDescriptor_const*>
(*(once_flag **)(param_1 + 0x18),(_func_void_FieldDescriptor_ptr *)&local_18,
&local_20);
}
if (((byte)param_1[2] < 0xd) && ((0x1a00U >> ((byte)param_1[2] & 0x1f) & 1) != 0)) {
uVar3 = uVar3 & 0xfffffffe;
}
return (ulong)uVar3;
}
uVar2 = GetFieldOffsetNonOneof(this,param_1);
return uVar2;
}
| |
25,968 | Bfree | eloqsql/strings/dtoa.c | static void Bfree(Bigint *v, Stack_alloc *alloc)
{
char *gptr= (char*) v; /* generic pointer */
if (gptr < alloc->begin || gptr >= alloc->end)
free(gptr);
else if (v->k <= Kmax)
{
/*
Maintain free lists only for stack objects: this way we don't
have to bother with freeing lists in the end of dtoa;
heap should not be used normally anyway.
*/
v->p.next= alloc->freelist[v->k];
alloc->freelist[v->k]= v;
}
} | O0 | c | Bfree:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x75443
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x7544e
movq -0x18(%rbp), %rdi
callq 0x243e0
jmp 0x75487
movq -0x8(%rbp), %rax
cmpl $0xf, 0x8(%rax)
jg 0x75485
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq 0x18(%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
jmp 0x75487
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| Bfree:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
jb short loc_75443
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
jb short loc_7544E
loc_75443:
mov rdi, [rbp+var_18]
call _free
jmp short loc_75487
loc_7544E:
mov rax, [rbp+var_8]
cmp dword ptr [rax+8], 0Fh
jg short loc_75485
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+8]
mov rcx, [rax+rcx*8+18h]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rdx, [rbp+var_8]
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+8]
mov [rax+rcx*8+18h], rdx
loc_75485:
jmp short $+2
loc_75487:
add rsp, 20h
pop rbp
retn
| long long Bfree(unsigned long long a1, unsigned long long *a2)
{
long long result; // rax
if ( a1 < *a2 || a1 >= a2[2] )
return free(a1);
result = a1;
if ( *(int *)(a1 + 8) <= 15 )
{
*(_QWORD *)a1 = a2[*(int *)(a1 + 8) + 3];
result = (long long)a2;
a2[*(int *)(a1 + 8) + 3] = a1;
}
return result;
}
| Bfree:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX]
JC 0x00175443
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JC 0x0017544e
LAB_00175443:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001243e0
JMP 0x00175487
LAB_0017544e:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x8],0xf
JG 0x00175485
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x8]
MOV RCX,qword ptr [RAX + RCX*0x8 + 0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x8]
MOV qword ptr [RAX + RCX*0x8 + 0x18],RDX
LAB_00175485:
JMP 0x00175487
LAB_00175487:
ADD RSP,0x20
POP RBP
RET
|
void Bfree(ulong *param_1,ulong *param_2)
{
if ((param_1 < (ulong *)*param_2) || ((ulong *)param_2[2] <= param_1)) {
free(param_1);
}
else if ((int)param_1[1] < 0x10) {
*param_1 = param_2[(long)(int)param_1[1] + 3];
param_2[(long)(int)param_1[1] + 3] = (ulong)param_1;
}
return;
}
| |
25,969 | minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) | llama.cpp/common/minja/minja.hpp | json parseNumber(CharIterator& it, const CharIterator& end) {
auto before = it;
consumeSpaces();
auto start = it;
bool hasDecimal = false;
bool hasExponent = false;
if (it != end && (*it == '-' || *it == '+')) ++it;
while (it != end) {
if (std::isdigit(*it)) {
++it;
} else if (*it == '.') {
if (hasDecimal) throw std::runtime_error("Multiple decimal points");
hasDecimal = true;
++it;
} else if (it != start && (*it == 'e' || *it == 'E')) {
if (hasExponent) throw std::runtime_error("Multiple exponents");
hasExponent = true;
++it;
} else {
break;
}
}
if (start == it) {
it = before;
return json(); // No valid characters found
}
std::string str(start, it);
try {
return json::parse(str);
} catch (json::parse_error& e) {
throw std::runtime_error("Failed to parse number: '" + str + "' (" + std::string(e.what()) + ")");
return json();
}
} | O3 | cpp | minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %r9
movq 0x18(%rsi), %rbp
movq 0x20(%rsi), %r13
movq %r9, %rsi
cmpq %rbp, %r13
je 0x9fde8
movq %rbx, 0x8(%rsp)
movq %r9, %rbx
movsbl (%r13), %edi
callq 0x1da80
testl %eax, %eax
je 0x9fddd
incq %r13
movq %r13, 0x20(%r12)
cmpq %rbp, %r13
jne 0x9fdc2
movq (%r14), %rsi
movq %rbx, %r9
movq 0x8(%rsp), %rbx
movq (%r15), %rax
cmpq %rsi, %rax
je 0x9fed1
movzbl (%rsi), %ecx
cmpl $0x2d, %ecx
je 0x9fe04
movq %rsi, %rdx
cmpl $0x2b, %ecx
jne 0x9fe0e
leaq 0x1(%rsi), %rdx
movq %rdx, (%r14)
movq (%r15), %rax
cmpq %rax, %rdx
je 0x9fe5b
xorl %eax, %eax
xorl %ecx, %ecx
movsbl (%rdx), %edi
leal -0x30(%rdi), %r8d
cmpl $0xa, %r8d
jb 0x9fe50
movzbl %dil, %edi
cmpl $0x2e, %edi
jne 0x9fe38
testb $0x1, %al
movb $0x1, %al
je 0x9fe50
jmp 0x9ff0e
cmpq %rsi, %rdx
je 0x9fe5b
orl $0x20, %edi
cmpl $0x65, %edi
jne 0x9fe5b
testb $0x1, %cl
movb $0x1, %cl
jne 0x9ff2c
incq %rdx
movq %rdx, (%r14)
cmpq (%r15), %rdx
jne 0x9fe17
cmpq %rsi, %rdx
je 0x9fed1
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
leaq 0x10(%rsp), %rdi
callq 0x7aa6e
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x89038
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x9feb8
leaq 0x50(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x9fef9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0x9fef9
movq %r9, (%r14)
movb $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x60b38
movq %rbx, %rdi
movl $0x1, %esi
callq 0x60b38
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1d520
movq %rax, %rbx
leaq 0x3545a(%rip), %rsi # 0xd537c
movq %rax, %rdi
callq 0x1d330
jmp 0x9ff48
movl $0x10, %edi
callq 0x1d520
movq %rax, %rbx
leaq 0x35454(%rip), %rsi # 0xd5394
movq %rax, %rdi
callq 0x1d330
movq 0x6b069(%rip), %rsi # 0x10afb8
movq 0x6b01a(%rip), %rdx # 0x10af70
movq %rbx, %rdi
callq 0x1d890
jmp 0xa015a
movq %rdx, %rbx
movq %rax, %r14
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x9ff82
leaq 0x50(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x1, %ebx
jne 0xa013f
movq %r14, %rdi
callq 0x1d090
movq %rax, %r14
movl $0x10, %edi
callq 0x1d520
movq %rax, %rbx
leaq 0x353fd(%rip), %rsi # 0xd53a7
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x26a4e
leaq 0x35401(%rip), %rdx # 0xd53c1
leaq 0x98(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5487d
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x78(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x23696
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x55589
leaq 0x39f4d(%rip), %rdx # 0xd9f5b
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x5487d
movb $0x1, %bpl
leaq 0xd8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d380
xorl %ebp, %ebp
movq 0x6af79(%rip), %rsi # 0x10afb8
movq 0x6af2a(%rip), %rdx # 0x10af70
movq %rbx, %rdi
callq 0x1d890
movq %rax, %r14
leaq 0xe8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa007a
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa007a
movq %rax, %r14
movb $0x1, %bpl
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa00a3
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa00a3
movq %rax, %r14
movb $0x1, %bpl
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa00cc
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa00cc
movq %rax, %r14
movb $0x1, %bpl
leaq 0xa8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa00ed
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x1d160
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0108
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d160
testb %bpl, %bpl
jne 0xa0132
jmp 0xa013a
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0132
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa0132
movq %rax, %r14
movq %rbx, %rdi
callq 0x1dc90
callq 0x1dae0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xa0174
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa0174
jmp 0xa015a
movq %rax, %rdi
callq 0x232f3
movq %rax, %r14
jmp 0xa0174
jmp 0xa0169
movq %rax, %r14
movq %rbx, %rdi
callq 0x1dc90
movq %r14, %rdi
callq 0x1d8e0
| _ZN5minja6Parser11parseNumberERN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKSB_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r15, rcx
mov r14, rdx
mov r12, rsi
mov rbx, rdi
mov r9, [rdx]
mov rbp, [rsi+18h]
mov r13, [rsi+20h]
mov rsi, r9
cmp r13, rbp
jz short loc_9FDE8
mov [rsp+128h+var_120], rbx
mov rbx, r9
loc_9FDC2:
movsx edi, byte ptr [r13+0]
call _isspace
test eax, eax
jz short loc_9FDDD
inc r13
mov [r12+20h], r13
cmp r13, rbp
jnz short loc_9FDC2
loc_9FDDD:
mov rsi, [r14]
mov r9, rbx
mov rbx, [rsp+128h+var_120]
loc_9FDE8:
mov rax, [r15]
cmp rax, rsi
jz loc_9FED1
movzx ecx, byte ptr [rsi]
cmp ecx, 2Dh ; '-'
jz short loc_9FE04
mov rdx, rsi
cmp ecx, 2Bh ; '+'
jnz short loc_9FE0E
loc_9FE04:
lea rdx, [rsi+1]
mov [r14], rdx
mov rax, [r15]
loc_9FE0E:
cmp rdx, rax
jz short loc_9FE5B
xor eax, eax
xor ecx, ecx
loc_9FE17:
movsx edi, byte ptr [rdx]
lea r8d, [rdi-30h]
cmp r8d, 0Ah
jb short loc_9FE50
movzx edi, dil
cmp edi, 2Eh ; '.'
jnz short loc_9FE38
test al, 1
mov al, 1
jz short loc_9FE50
jmp loc_9FF0E
loc_9FE38:
cmp rdx, rsi
jz short loc_9FE5B
or edi, 20h
cmp edi, 65h ; 'e'
jnz short loc_9FE5B
test cl, 1
mov cl, 1
jnz loc_9FF2C
loc_9FE50:
inc rdx
mov [r14], rdx
cmp rdx, [r15]
jnz short loc_9FE17
loc_9FE5B:
cmp rdx, rsi
jz short loc_9FED1
lea r15, [rsp+128h+var_108]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
lea rdi, [rsp+128h+var_118]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
xorps xmm0, xmm0
lea rdx, [rsp+128h+var_D8]
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
lea rsi, [rsp+128h+var_118]
mov rdi, rbx
mov ecx, 1
xor r8d, r8d
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parse<std::string&>(std::string&,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)>,bool,bool)
mov rax, [rsp+128h+var_C8]
test rax, rax
jz short loc_9FEB8
lea rdi, [rsp+128h+var_D8]
mov rsi, rdi
mov edx, 3
call rax
loc_9FEB8:
mov rdi, [rsp+128h+var_118]; void *
cmp rdi, r15
jz short loc_9FEF9
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9FEF9
loc_9FED1:
mov [r14], r9
mov byte ptr [rbx], 0
mov qword ptr [rbx+8], 0
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)
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)
loc_9FEF9:
mov rax, rbx
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9FF0E:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMultipleDecima; "Multiple decimal points"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_9FF48
loc_9FF2C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMultipleExpone; "Multiple exponents"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_9FF48:
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp loc_A015A
mov rbx, rdx
mov r14, rax
mov rax, [rsp+128h+var_C8]
test rax, rax
jz short loc_9FF82
lea rdi, [rsp+128h+var_D8]
mov rsi, rdi
mov edx, 3
call rax
loc_9FF82:
cmp ebx, 1
jnz loc_A013F
mov rdi, r14; void *
call ___cxa_begin_catch
mov r14, rax
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aFailedToParseN; "Failed to parse number: '"
lea rdi, [rsp+128h+var_F8]
lea rdx, [rsp+128h+var_118]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, asc_D53C1; "' ("
lea rdi, [rsp+128h+var_90]
lea rsi, [rsp+128h+var_F8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+10h]
lea rdi, [rsp+128h+var_B0]
lea rdx, [rsp+128h+var_121]
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+128h+var_70]
lea rsi, [rsp+128h+var_90]
lea rdx, [rsp+128h+var_B0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdx, a09401910201912+51h; ")"
lea rdi, [rsp+128h+var_50]
lea rsi, [rsp+128h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov bpl, 1
lea rsi, [rsp+128h+var_50]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+128h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A007A
mov rsi, [rsp+128h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A007A
mov r14, rax
mov bpl, 1
loc_A007A:
lea rax, [rsp+128h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A00A3
mov rsi, [rsp+128h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A00A3
mov r14, rax
mov bpl, 1
loc_A00A3:
lea rax, [rsp+128h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A00CC
mov rsi, [rsp+128h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A00CC
mov r14, rax
mov bpl, 1
loc_A00CC:
lea rax, [rsp+128h+var_80]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A00ED
mov rsi, [rsp+128h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A00ED:
lea rax, [rsp+128h+var_E8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0108
mov rsi, [rsp+128h+var_E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A0108:
test bpl, bpl
jnz short loc_A0132
jmp short loc_A013A
mov r14, rax
lea rax, [rsp+128h+var_E8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0132
mov rsi, [rsp+128h+var_E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A0132
mov r14, rax
loc_A0132:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A013A:
call ___cxa_end_catch
loc_A013F:
mov rdi, [rsp+128h+var_118]; void *
cmp rdi, r15
jz short loc_A0174
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A0174
jmp short $+2
loc_A015A:
mov rdi, rax
call __clang_call_terminate
mov r14, rax
jmp short loc_A0174
jmp short $+2
loc_A0169:
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A0174:
mov rdi, r14
call __Unwind_Resume
| long long minja::Parser::parseNumber(long long a1, long long a2, char **a3, char **a4)
{
long long v7; // rbx
char *v8; // r9
char *v9; // rbp
char *v10; // r13
char *v11; // rsi
char *v12; // rbx
char *v13; // rax
int v14; // ecx
char *v15; // rdx
char v16; // al
char v17; // cl
int v18; // edi
bool v19; // zf
std::runtime_error *exception; // rbx
void *v22[2]; // [rsp+10h] [rbp-118h] BYREF
_QWORD v23[2]; // [rsp+20h] [rbp-108h] BYREF
__int128 v24; // [rsp+50h] [rbp-D8h] BYREF
__int128 v25; // [rsp+60h] [rbp-C8h]
v7 = a1;
v8 = *a3;
v9 = *(char **)(a2 + 24);
v10 = *(char **)(a2 + 32);
v11 = *a3;
if ( v10 != v9 )
{
v12 = *a3;
do
{
if ( !(unsigned int)isspace((unsigned int)*v10) )
break;
*(_QWORD *)(a2 + 32) = ++v10;
}
while ( v10 != v9 );
v11 = *a3;
v8 = v12;
v7 = a1;
}
v13 = *a4;
if ( *a4 == v11 )
goto LABEL_25;
v14 = (unsigned __int8)*v11;
if ( v14 == 45 || (v15 = v11, v14 == 43) )
{
v15 = v11 + 1;
*a3 = v11 + 1;
v13 = *a4;
}
if ( v15 != v13 )
{
v16 = 0;
v17 = 0;
do
{
v18 = *v15;
if ( (unsigned int)(v18 - 48) >= 0xA )
{
if ( (unsigned __int8)v18 == 46 )
{
v19 = (v16 & 1) == 0;
v16 = 1;
if ( !v19 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Multiple decimal points");
goto LABEL_28;
}
}
else
{
if ( v15 == v11 || ((unsigned __int8)v18 | 0x20) != 0x65 )
break;
v19 = (v17 & 1) == 0;
v17 = 1;
if ( !v19 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Multiple exponents");
LABEL_28:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
}
*a3 = ++v15;
}
while ( v15 != *a4 );
}
if ( v15 == v11 )
{
LABEL_25:
*a3 = v8;
*(_BYTE *)v7 = 0;
*(_QWORD *)(v7 + 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v7);
}
else
{
v22[0] = v23;
v22[1] = 0LL;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>((long long)v22, v11, (long long)v15);
v25 = 0LL;
v24 = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::string&>(
v7,
(long long *)v22,
(long long)&v24,
1u,
0);
if ( (_QWORD)v25 )
((void ( *)(__int128 *, __int128 *, long long))v25)(&v24, &v24, 3LL);
if ( v22[0] != v23 )
operator delete(v22[0], v23[0] + 1LL);
}
return v7;
}
| parseNumber:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R15,RCX
MOV R14,RDX
MOV R12,RSI
MOV RBX,RDI
MOV R9,qword ptr [RDX]
MOV RBP,qword ptr [RSI + 0x18]
MOV R13,qword ptr [RSI + 0x20]
MOV RSI,R9
CMP R13,RBP
JZ 0x0019fde8
MOV qword ptr [RSP + 0x8],RBX
MOV RBX,R9
LAB_0019fdc2:
MOVSX EDI,byte ptr [R13]
CALL 0x0011da80
TEST EAX,EAX
JZ 0x0019fddd
INC R13
MOV qword ptr [R12 + 0x20],R13
CMP R13,RBP
JNZ 0x0019fdc2
LAB_0019fddd:
MOV RSI,qword ptr [R14]
MOV R9,RBX
MOV RBX,qword ptr [RSP + 0x8]
LAB_0019fde8:
MOV RAX,qword ptr [R15]
CMP RAX,RSI
JZ 0x0019fed1
MOVZX ECX,byte ptr [RSI]
CMP ECX,0x2d
JZ 0x0019fe04
MOV RDX,RSI
CMP ECX,0x2b
JNZ 0x0019fe0e
LAB_0019fe04:
LEA RDX,[RSI + 0x1]
MOV qword ptr [R14],RDX
MOV RAX,qword ptr [R15]
LAB_0019fe0e:
CMP RDX,RAX
JZ 0x0019fe5b
XOR EAX,EAX
XOR ECX,ECX
LAB_0019fe17:
MOVSX EDI,byte ptr [RDX]
LEA R8D,[RDI + -0x30]
CMP R8D,0xa
JC 0x0019fe50
MOVZX EDI,DIL
CMP EDI,0x2e
JNZ 0x0019fe38
TEST AL,0x1
MOV AL,0x1
JZ 0x0019fe50
JMP 0x0019ff0e
LAB_0019fe38:
CMP RDX,RSI
JZ 0x0019fe5b
OR EDI,0x20
CMP EDI,0x65
JNZ 0x0019fe5b
TEST CL,0x1
MOV CL,0x1
JNZ 0x0019ff2c
LAB_0019fe50:
INC RDX
MOV qword ptr [R14],RDX
CMP RDX,qword ptr [R15]
JNZ 0x0019fe17
LAB_0019fe5b:
CMP RDX,RSI
JZ 0x0019fed1
LEA R15,[RSP + 0x20]
MOV qword ptr [R15 + -0x10],R15
MOV qword ptr [R15 + -0x8],0x0
LAB_0019fe71:
LEA RDI,[RSP + 0x10]
CALL 0x0017aa6e
XORPS XMM0,XMM0
LEA RDX,[RSP + 0x50]
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
LAB_0019fe8a:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
MOV ECX,0x1
XOR R8D,R8D
CALL 0x00189038
MOV RAX,qword ptr [RSP + 0x60]
TEST RAX,RAX
JZ 0x0019feb8
LAB_0019fea9:
LEA RDI,[RSP + 0x50]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0019feb8:
MOV RDI,qword ptr [RSP + 0x10]
CMP RDI,R15
JZ 0x0019fef9
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0011d160
JMP 0x0019fef9
LAB_0019fed1:
MOV qword ptr [R14],R9
MOV byte ptr [RBX],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00160b38
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00160b38
LAB_0019fef9:
MOV RAX,RBX
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019ff0e:
MOV EDI,0x10
CALL 0x0011d520
MOV RBX,RAX
LAB_0019ff1b:
LEA RSI,[0x1d537c]
MOV RDI,RAX
CALL 0x0011d330
LAB_0019ff2a:
JMP 0x0019ff48
LAB_0019ff2c:
MOV EDI,0x10
CALL 0x0011d520
MOV RBX,RAX
LAB_0019ff39:
LEA RSI,[0x1d5394]
MOV RDI,RAX
CALL 0x0011d330
LAB_0019ff48:
MOV RSI,qword ptr [0x0020afb8]
MOV RDX,qword ptr [0x0020af70]
MOV RDI,RBX
CALL 0x0011d890
|
/* minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::string >&,
__gnu_cxx::__normal_iterator<char const*, std::__cxx11::string > const&) */
__normal_iterator *
minja::Parser::parseNumber(__normal_iterator *param_1,__normal_iterator *param_2)
{
byte bVar1;
byte *pbVar2;
char *pcVar3;
bool bVar4;
bool bVar5;
bool bVar6;
int iVar7;
byte *pbVar8;
runtime_error *this;
bool bVar9;
int8 *in_RCX;
long *in_RDX;
byte *pbVar10;
byte *pbVar11;
char *pcVar12;
long *local_118;
int8 local_110;
long local_108 [6];
int8 local_d8;
int8 uStack_d0;
code *local_c8;
int8 uStack_c0;
pbVar2 = (byte *)*in_RDX;
pcVar3 = *(char **)(param_2 + 0x18);
pcVar12 = *(char **)(param_2 + 0x20);
pbVar11 = pbVar2;
if (pcVar12 != pcVar3) {
do {
iVar7 = isspace((int)*pcVar12);
if (iVar7 == 0) break;
pcVar12 = pcVar12 + 1;
*(char **)(param_2 + 0x20) = pcVar12;
} while (pcVar12 != pcVar3);
pbVar11 = (byte *)*in_RDX;
}
pbVar8 = (byte *)*in_RCX;
if (pbVar8 != pbVar11) {
if ((*pbVar11 == 0x2d) || (pbVar10 = pbVar11, *pbVar11 == 0x2b)) {
pbVar10 = pbVar11 + 1;
*in_RDX = (long)pbVar10;
pbVar8 = (byte *)*in_RCX;
}
if (pbVar10 != pbVar8) {
bVar6 = false;
bVar9 = false;
do {
bVar1 = *pbVar10;
bVar4 = bVar6;
bVar5 = bVar9;
if (9 < (int)(char)bVar1 - 0x30U) {
if (bVar1 == 0x2e) {
bVar4 = true;
if (bVar6) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019ff1b to 0019ff29 has its CatchHandler @ 001a0169 */
std::runtime_error::runtime_error(this,"Multiple decimal points");
LAB_0019ff48:
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0020afb8,PTR__runtime_error_0020af70);
}
}
else {
if ((pbVar10 == pbVar11) || ((bVar1 | 0x20) != 0x65)) break;
bVar5 = true;
if (bVar9) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019ff39 to 0019ff47 has its CatchHandler @ 001a0167 */
std::runtime_error::runtime_error(this,"Multiple exponents");
goto LAB_0019ff48;
}
}
}
bVar9 = bVar5;
bVar6 = bVar4;
pbVar10 = pbVar10 + 1;
*in_RDX = (long)pbVar10;
} while (pbVar10 != (byte *)*in_RCX);
}
if (pbVar10 != pbVar11) {
local_110 = 0;
/* try { // try from 0019fe71 to 0019fe7a has its CatchHandler @ 001a0162 */
local_118 = local_108;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>(&local_118);
local_c8 = (code *)0x0;
uStack_c0 = 0;
local_d8 = 0;
uStack_d0 = 0;
/* try { // try from 0019fe8a to 0019fe9e has its CatchHandler @ 0019ff63 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::parse<std::__cxx11::string&>
((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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,&local_118,&local_d8,1,0);
if (local_c8 != (code *)0x0) {
/* try { // try from 0019fea9 to 0019feb7 has its CatchHandler @ 0019ff5e */
(*local_c8)(&local_d8,&local_d8,3);
}
if (local_118 == local_108) {
return param_1;
}
operator_delete(local_118,local_108[0] + 1);
return param_1;
}
}
*in_RDX = (long)pbVar2;
*param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
return param_1;
}
| |
25,970 | mysys_namespace::crc32c::crc32c_sse42(unsigned int, char const*, unsigned long) | eloqsql/mysys/crc32/crc32c.cc | USE_SSE42
static uint32_t crc32c_sse42(uint32_t crc, const char* buf, size_t size)
{
const uint8_t *p = reinterpret_cast<const uint8_t *>(buf);
const uint8_t *e = p + size;
uint64_t l = crc ^ 0xffffffffu;
// Point x at first 16-byte aligned byte in string. This might be
// just past the end of the string.
const uintptr_t pval = reinterpret_cast<uintptr_t>(p);
const uint8_t* x = reinterpret_cast<const uint8_t*>(ALIGN(pval, 4));
if (x <= e)
// Process bytes until finished or p is 16-byte aligned
while (p != x)
STEP1;
// Process bytes 16 at a time
while ((e-p) >= 16)
{
Fast_CRC32(&l, &p);
Fast_CRC32(&l, &p);
}
// Process bytes 8 at a time
while ((e-p) >= 8)
Fast_CRC32(&l, &p);
// Process the last few bytes
while (p != e)
STEP1;
return static_cast<uint32_t>(l ^ 0xffffffffu);
} | O3 | cpp | mysys_namespace::crc32c::crc32c_sse42(unsigned int, char const*, unsigned long):
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
addq %rsi, %rdx
notl %eax
leaq 0xf(%rsi), %rcx
andq $-0x10, %rcx
cmpq %rcx, %rdx
setb %r8b
movq %rcx, %rdi
subq %rsi, %rdi
sete %r9b
orb %r8b, %r9b
je 0xb0089
movq %rsi, %rcx
jmp 0xb00b4
leaq 0x3a380(%rip), %r8 # 0xea410
movq %rsi, %r9
movzbl %al, %r10d
movzbl (%r9), %r11d
incq %r9
xorl %r10d, %r11d
movl (%r8,%r11,4), %r10d
shrq $0x8, %rax
xorq %r10, %rax
cmpq %rcx, %r9
jne 0xb0093
addq %rdi, %rsi
movq %rdx, %rdi
subq %rcx, %rdi
cmpq $0x10, %rdi
jl 0xb00e1
movq %rdx, %rdi
subq %rsi, %rdi
crc32q (%rsi), %rax
crc32q 0x8(%rsi), %rax
addq $0x10, %rsi
addq $-0x10, %rdi
cmpq $0xf, %rdi
jg 0xb00c6
cmpq $0x8, %rdi
jl 0xb0101
movq %rdx, %rcx
subq %rsi, %rcx
crc32q (%rsi), %rax
addq $0x8, %rsi
addq $-0x8, %rcx
cmpq $0x7, %rcx
jg 0xb00ed
cmpq %rdx, %rsi
je 0xb012a
leaq 0x3a303(%rip), %rcx # 0xea410
movzbl %al, %edi
movzbl (%rsi), %r8d
incq %rsi
xorl %edi, %r8d
movl (%rcx,%r8,4), %edi
shrq $0x8, %rax
xorq %rdi, %rax
cmpq %rdx, %rsi
jne 0xb010d
notl %eax
popq %rbp
retq
| _ZN15mysys_namespace6crc32cL12crc32c_sse42EjPKcm:
push rbp
mov rbp, rsp
mov eax, edi
add rdx, rsi
not eax
lea rcx, [rsi+0Fh]
and rcx, 0FFFFFFFFFFFFFFF0h
cmp rdx, rcx
setb r8b
mov rdi, rcx
sub rdi, rsi
setz r9b
or r9b, r8b
jz short loc_B0089
mov rcx, rsi
jmp short loc_B00B4
loc_B0089:
lea r8, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
mov r9, rsi
loc_B0093:
movzx r10d, al
movzx r11d, byte ptr [r9]
inc r9
xor r11d, r10d
mov r10d, [r8+r11*4]
shr rax, 8
xor rax, r10
cmp r9, rcx
jnz short loc_B0093
add rsi, rdi
loc_B00B4:
mov rdi, rdx
sub rdi, rcx
cmp rdi, 10h
jl short loc_B00E1
mov rdi, rdx
sub rdi, rsi
loc_B00C6:
crc32 rax, qword ptr [rsi]
crc32 rax, qword ptr [rsi+8]
add rsi, 10h
add rdi, 0FFFFFFFFFFFFFFF0h
cmp rdi, 0Fh
jg short loc_B00C6
loc_B00E1:
cmp rdi, 8
jl short loc_B0101
mov rcx, rdx
sub rcx, rsi
loc_B00ED:
crc32 rax, qword ptr [rsi]
add rsi, 8
add rcx, 0FFFFFFFFFFFFFFF8h
cmp rcx, 7
jg short loc_B00ED
loc_B0101:
cmp rsi, rdx
jz short loc_B012A
lea rcx, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
loc_B010D:
movzx edi, al
movzx r8d, byte ptr [rsi]
inc rsi
xor r8d, edi
mov edi, [rcx+r8*4]
shr rax, 8
xor rax, rdi
cmp rsi, rdx
jnz short loc_B010D
loc_B012A:
not eax
pop rbp
retn
| long long mysys_namespace::crc32c::crc32c_sse42(
mysys_namespace::crc32c *this,
unsigned long long a2,
const char *a3)
{
const char *v3; // rdx
unsigned long long v4; // rax
unsigned long long v5; // rcx
unsigned __int8 *v6; // r9
int v7; // r11d
long long v8; // rdi
long long v9; // rcx
int v10; // r8d
v3 = &a3[a2];
v4 = (unsigned int)~(_DWORD)this;
v5 = (a2 + 15) & 0xFFFFFFFFFFFFFFF0LL;
if ( (unsigned long long)v3 < v5 || v5 == a2 )
{
v5 = a2;
}
else
{
v6 = (unsigned __int8 *)a2;
do
{
v7 = *v6++;
v4 = mysys_namespace::crc32c::table0_[(unsigned __int8)v4 ^ v7] ^ (v4 >> 8);
}
while ( v6 != (unsigned __int8 *)v5 );
a2 = (a2 + 15) & 0xFFFFFFFFFFFFFFF0LL;
}
v8 = (long long)&v3[-v5];
if ( (long long)&v3[-v5] >= 16 )
{
v8 = (long long)&v3[-a2];
do
{
v4 = _mm_crc32_u64(_mm_crc32_u64(v4, *(_QWORD *)a2), *(_QWORD *)(a2 + 8));
a2 += 16LL;
v8 -= 16LL;
}
while ( v8 > 15 );
}
if ( v8 >= 8 )
{
v9 = (long long)&v3[-a2];
do
{
v4 = _mm_crc32_u64(v4, *(_QWORD *)a2);
a2 += 8LL;
v9 -= 8LL;
}
while ( v9 > 7 );
}
for ( ; (const char *)a2 != v3; v4 = mysys_namespace::crc32c::table0_[(unsigned __int8)v4 ^ v10] ^ (v4 >> 8) )
v10 = *(unsigned __int8 *)a2++;
return (unsigned int)~(_DWORD)v4;
}
| crc32c_sse42:
PUSH RBP
MOV RBP,RSP
MOV EAX,EDI
ADD RDX,RSI
NOT EAX
LEA RCX,[RSI + 0xf]
AND RCX,-0x10
CMP RDX,RCX
SETC R8B
MOV RDI,RCX
SUB RDI,RSI
SETZ R9B
OR R9B,R8B
JZ 0x001b0089
MOV RCX,RSI
JMP 0x001b00b4
LAB_001b0089:
LEA R8,[0x1ea410]
MOV R9,RSI
LAB_001b0093:
MOVZX R10D,AL
MOVZX R11D,byte ptr [R9]
INC R9
XOR R11D,R10D
MOV R10D,dword ptr [R8 + R11*0x4]
SHR RAX,0x8
XOR RAX,R10
CMP R9,RCX
JNZ 0x001b0093
ADD RSI,RDI
LAB_001b00b4:
MOV RDI,RDX
SUB RDI,RCX
CMP RDI,0x10
JL 0x001b00e1
MOV RDI,RDX
SUB RDI,RSI
LAB_001b00c6:
CRC32 RAX,qword ptr [RSI]
CRC32 RAX,qword ptr [RSI + 0x8]
ADD RSI,0x10
ADD RDI,-0x10
CMP RDI,0xf
JG 0x001b00c6
LAB_001b00e1:
CMP RDI,0x8
JL 0x001b0101
MOV RCX,RDX
SUB RCX,RSI
LAB_001b00ed:
CRC32 RAX,qword ptr [RSI]
ADD RSI,0x8
ADD RCX,-0x8
CMP RCX,0x7
JG 0x001b00ed
LAB_001b0101:
CMP RSI,RDX
JZ 0x001b012a
LEA RCX,[0x1ea410]
LAB_001b010d:
MOVZX EDI,AL
MOVZX R8D,byte ptr [RSI]
INC RSI
XOR R8D,EDI
MOV EDI,dword ptr [RCX + R8*0x4]
SHR RAX,0x8
XOR RAX,RDI
CMP RSI,RDX
JNZ 0x001b010d
LAB_001b012a:
NOT EAX
POP RBP
RET
|
/* mysys_namespace::crc32c::crc32c_sse42(unsigned int, char const*, unsigned long) */
uint __thiscall
mysys_namespace::crc32c::crc32c_sse42(crc32c *this,uint param_1,char *param_2,ulong param_3)
{
int8 uVar1;
ulong uVar2;
byte *pbVar3;
byte *pbVar4;
byte *pbVar5;
int4 in_register_00000034;
byte *pbVar6;
long lVar7;
byte *pbVar8;
pbVar4 = (byte *)CONCAT44(in_register_00000034,param_1);
pbVar5 = (byte *)(param_2 + (long)pbVar4);
uVar2 = (ulong)~(uint)this;
pbVar3 = (byte *)((ulong)(pbVar4 + 0xf) & 0xfffffffffffffff0);
pbVar6 = pbVar4;
if ((long)pbVar3 - (long)pbVar4 != 0 && pbVar3 <= pbVar5) {
do {
pbVar8 = pbVar6 + 1;
uVar2 = uVar2 >> 8 ^
(ulong)*(uint *)(table0_ + (ulong)((uint)*pbVar6 ^ (uint)uVar2 & 0xff) * 4);
pbVar6 = pbVar8;
} while (pbVar8 != pbVar3);
pbVar6 = pbVar4 + ((long)pbVar3 - (long)pbVar4);
pbVar4 = pbVar3;
}
lVar7 = (long)pbVar5 - (long)pbVar4;
if (0xf < lVar7) {
lVar7 = (long)pbVar5 - (long)pbVar6;
do {
uVar1 = crc32(uVar2,*(int8 *)pbVar6);
uVar2 = crc32(uVar1,*(int8 *)(pbVar6 + 8));
pbVar6 = pbVar6 + 0x10;
lVar7 = lVar7 + -0x10;
} while (0xf < lVar7);
}
if (7 < lVar7) {
lVar7 = (long)pbVar5 - (long)pbVar6;
do {
uVar2 = crc32(uVar2,*(int8 *)pbVar6);
pbVar6 = pbVar6 + 8;
lVar7 = lVar7 + -8;
} while (7 < lVar7);
}
for (; pbVar6 != pbVar5; pbVar6 = pbVar6 + 1) {
uVar2 = uVar2 >> 8 ^ (ulong)*(uint *)(table0_ + (ulong)((uint)*pbVar6 ^ (uint)uVar2 & 0xff) * 4)
;
}
return ~(uint)uVar2;
}
| |
25,971 | MemoryManager::setByteNoCache(unsigned int, unsigned char) | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp | bool MemoryManager::setByteNoCache(uint32_t addr, uint8_t val) {
if (!this->isAddrExist(addr)) {
dbgprintf("Byte write to invalid addr 0x%x!\n", addr);
return false;
}
uint32_t i = this->getFirstEntryId(addr);
uint32_t j = this->getSecondEntryId(addr);
uint32_t k = this->getPageOffset(addr);
this->memory[i][j][k] = val;
return true;
} | O0 | cpp | MemoryManager::setByteNoCache(unsigned int, unsigned char):
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movb %al, 0x23(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x24(%rsp), %esi
callq 0x3440
testb $0x1, %al
jne 0x36c3
movl 0x24(%rsp), %esi
leaq 0x4aa6(%rip), %rdi # 0x815b
movb $0x0, %al
callq 0x4180
movb $0x0, 0x37(%rsp)
jmp 0x3720
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x33d0
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
movl 0x24(%rsp), %esi
callq 0x33f0
movq 0x8(%rsp), %rdi
movl %eax, 0x18(%rsp)
movl 0x24(%rsp), %esi
callq 0x3660
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rsp)
movb 0x23(%rsp), %dl
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x18(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x14(%rsp), %ecx
movb %dl, (%rax,%rcx)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| _ZN13MemoryManager14setByteNoCacheEjh:
sub rsp, 38h
mov al, dl
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_14], esi
mov [rsp+38h+var_15], al
mov rdi, [rsp+38h+var_10]; this
mov [rsp+38h+var_30], rdi
mov esi, [rsp+38h+var_14]; unsigned int
call _ZN13MemoryManager11isAddrExistEj; MemoryManager::isAddrExist(uint)
test al, 1
jnz short loc_36C3
mov esi, [rsp+38h+var_14]
lea rdi, aByteWriteToInv; "Byte write to invalid addr 0x%x!\n"
mov al, 0
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
mov [rsp+38h+var_1], 0
jmp short loc_3720
loc_36C3:
mov rdi, [rsp+38h+var_30]; this
mov esi, [rsp+38h+var_14]; unsigned int
call _ZN13MemoryManager15getFirstEntryIdEj; MemoryManager::getFirstEntryId(uint)
mov rdi, [rsp+38h+var_30]; this
mov [rsp+38h+var_1C], eax
mov esi, [rsp+38h+var_14]; unsigned int
call _ZN13MemoryManager16getSecondEntryIdEj; MemoryManager::getSecondEntryId(uint)
mov rdi, [rsp+38h+var_30]; this
mov [rsp+38h+var_20], eax
mov esi, [rsp+38h+var_14]; unsigned int
call _ZN13MemoryManager13getPageOffsetEj; MemoryManager::getPageOffset(uint)
mov ecx, eax
mov rax, [rsp+38h+var_30]
mov [rsp+38h+var_24], ecx
mov dl, [rsp+38h+var_15]
mov ecx, [rsp+38h+var_1C]
mov rax, [rax+rcx*8]
mov ecx, [rsp+38h+var_20]
mov rax, [rax+rcx*8]
mov ecx, [rsp+38h+var_24]
mov [rax+rcx], dl
mov [rsp+38h+var_1], 1
loc_3720:
mov al, [rsp+38h+var_1]
and al, 1
add rsp, 38h
retn
| char MemoryManager::setByteNoCache(MemoryManager *this, unsigned int a2, char a3)
{
unsigned int SecondEntryId; // [rsp+18h] [rbp-20h]
unsigned int FirstEntryId; // [rsp+1Ch] [rbp-1Ch]
if ( MemoryManager::isAddrExist(this, a2) )
{
FirstEntryId = MemoryManager::getFirstEntryId(this, a2);
SecondEntryId = MemoryManager::getSecondEntryId(this, a2);
*(_BYTE *)(*(_QWORD *)(*((_QWORD *)this + FirstEntryId) + 8LL * SecondEntryId)
+ (unsigned int)MemoryManager::getPageOffset(this, a2)) = a3;
return 1;
}
else
{
dbgprintf("Byte write to invalid addr 0x%x!\n", a2);
return 0;
}
}
| setByteNoCache:
SUB RSP,0x38
MOV AL,DL
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x24],ESI
MOV byte ptr [RSP + 0x23],AL
MOV RDI,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RDI
MOV ESI,dword ptr [RSP + 0x24]
CALL 0x00103440
TEST AL,0x1
JNZ 0x001036c3
MOV ESI,dword ptr [RSP + 0x24]
LEA RDI,[0x10815b]
MOV AL,0x0
CALL 0x00104180
MOV byte ptr [RSP + 0x37],0x0
JMP 0x00103720
LAB_001036c3:
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSP + 0x24]
CALL 0x001033d0
MOV RDI,qword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x1c],EAX
MOV ESI,dword ptr [RSP + 0x24]
CALL 0x001033f0
MOV RDI,qword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x18],EAX
MOV ESI,dword ptr [RSP + 0x24]
CALL 0x00103660
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x14],ECX
MOV DL,byte ptr [RSP + 0x23]
MOV ECX,dword ptr [RSP + 0x1c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV ECX,dword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV ECX,dword ptr [RSP + 0x14]
MOV byte ptr [RAX + RCX*0x1],DL
MOV byte ptr [RSP + 0x37],0x1
LAB_00103720:
MOV AL,byte ptr [RSP + 0x37]
AND AL,0x1
ADD RSP,0x38
RET
|
/* MemoryManager::setByteNoCache(unsigned int, unsigned char) */
bool __thiscall MemoryManager::setByteNoCache(MemoryManager *this,uint param_1,uchar param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
ulong uVar4;
bool bVar5;
uVar4 = isAddrExist(this,param_1);
bVar5 = (uVar4 & 1) != 0;
if (bVar5) {
uVar1 = getFirstEntryId(this,param_1);
uVar2 = getSecondEntryId(this,param_1);
uVar3 = getPageOffset(this,param_1);
*(uchar *)(*(long *)(*(long *)(this + (ulong)uVar1 * 8) + (ulong)uVar2 * 8) + (ulong)uVar3) =
param_2;
}
else {
dbgprintf("Byte write to invalid addr 0x%x!\n",(ulong)param_1);
}
return bVar5;
}
| |
25,972 | MemoryManager::setByteNoCache(unsigned int, unsigned char) | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp | bool MemoryManager::setByteNoCache(uint32_t addr, uint8_t val) {
if (!this->isAddrExist(addr)) {
dbgprintf("Byte write to invalid addr 0x%x!\n", addr);
return false;
}
uint32_t i = this->getFirstEntryId(addr);
uint32_t j = this->getSecondEntryId(addr);
uint32_t k = this->getPageOffset(addr);
this->memory[i][j][k] = val;
return true;
} | O1 | cpp | MemoryManager::setByteNoCache(unsigned int, unsigned char):
pushq %rbx
movl %esi, %eax
shrl $0x16, %eax
movq (%rdi,%rax,8), %rax
testq %rax, %rax
je 0x2fc3
movl %esi, %ecx
shrl $0x9, %ecx
andl $0x1ff8, %ecx # imm = 0x1FF8
movb $0x1, %bl
cmpq $0x0, (%rax,%rcx)
jne 0x2fc5
xorl %ebx, %ebx
testb %bl, %bl
je 0x2fe5
movl %esi, %ecx
andl $0xfff, %ecx # imm = 0xFFF
shrl $0x9, %esi
andl $0x1ff8, %esi # imm = 0x1FF8
movq (%rax,%rsi), %rax
movb %dl, (%rax,%rcx)
movl %ebx, %eax
popq %rbx
retq
leaq 0x21a9(%rip), %rdi # 0x5195
xorl %eax, %eax
callq 0x2330
jmp 0x2fe1
nop
| _ZN13MemoryManager14setByteNoCacheEjh:
push rbx
mov eax, esi
shr eax, 16h
mov rax, [rdi+rax*8]
test rax, rax
jz short loc_2FC3
mov ecx, esi
shr ecx, 9
and ecx, 1FF8h
mov bl, 1
cmp qword ptr [rax+rcx], 0
jnz short loc_2FC5
loc_2FC3:
xor ebx, ebx
loc_2FC5:
test bl, bl
jz short loc_2FE5
mov ecx, esi
and ecx, 0FFFh
shr esi, 9
and esi, 1FF8h
mov rax, [rax+rsi]
mov [rax+rcx], dl
loc_2FE1:
mov eax, ebx
pop rbx
retn
loc_2FE5:
lea rdi, aByteWriteToInv; "Byte write to invalid addr 0x%x!\n"
xor eax, eax
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
jmp short loc_2FE1
| long long MemoryManager::setByteNoCache(
MemoryManager *this,
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)
{
unsigned int v14; // ebx
long long v15; // rax
char v17; // [rsp+0h] [rbp-8h]
v15 = *((_QWORD *)this + ((unsigned int)a2 >> 22));
if ( !v15 || (a4 = ((unsigned int)a2 >> 9) & 0x1FF8, LOBYTE(v14) = 1, !*(_QWORD *)(v15 + a4)) )
v14 = 0;
if ( (_BYTE)v14 )
*(_BYTE *)(*(_QWORD *)(v15 + (((unsigned int)a2 >> 9) & 0x1FF8)) + (a2 & 0xFFF)) = a3;
else
dbgprintf("Byte write to invalid addr 0x%x!\n", a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v17);
return v14;
}
| setByteNoCache:
PUSH RBX
MOV EAX,ESI
SHR EAX,0x16
MOV RAX,qword ptr [RDI + RAX*0x8]
TEST RAX,RAX
JZ 0x00102fc3
MOV ECX,ESI
SHR ECX,0x9
AND ECX,0x1ff8
MOV BL,0x1
CMP qword ptr [RAX + RCX*0x1],0x0
JNZ 0x00102fc5
LAB_00102fc3:
XOR EBX,EBX
LAB_00102fc5:
TEST BL,BL
JZ 0x00102fe5
MOV ECX,ESI
AND ECX,0xfff
SHR ESI,0x9
AND ESI,0x1ff8
MOV RAX,qword ptr [RAX + RSI*0x1]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_00102fe1:
MOV EAX,EBX
POP RBX
RET
LAB_00102fe5:
LEA RDI,[0x105195]
XOR EAX,EAX
CALL 0x00102330
JMP 0x00102fe1
|
/* MemoryManager::setByteNoCache(unsigned int, unsigned char) */
int4 __thiscall MemoryManager::setByteNoCache(MemoryManager *this,uint param_1,uchar param_2)
{
long lVar1;
int4 uVar2;
int8 unaff_RBX;
lVar1 = *(long *)(this + (ulong)(param_1 >> 0x16) * 8);
if ((lVar1 == 0) ||
(uVar2 = (int4)CONCAT71((int7)((ulong)unaff_RBX >> 8),1),
*(long *)(lVar1 + (ulong)(param_1 >> 9 & 0x1ff8)) == 0)) {
uVar2 = 0;
}
if ((char)uVar2 == '\0') {
dbgprintf("Byte write to invalid addr 0x%x!\n");
}
else {
*(uchar *)(*(long *)(lVar1 + (ulong)(param_1 >> 9 & 0x1ff8)) + (ulong)(param_1 & 0xfff)) =
param_2;
}
return uVar2;
}
| |
25,973 | MemoryManager::setByteNoCache(unsigned int, unsigned char) | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp | bool MemoryManager::setByteNoCache(uint32_t addr, uint8_t val) {
if (!this->isAddrExist(addr)) {
dbgprintf("Byte write to invalid addr 0x%x!\n", addr);
return false;
}
uint32_t i = this->getFirstEntryId(addr);
uint32_t j = this->getSecondEntryId(addr);
uint32_t k = this->getPageOffset(addr);
this->memory[i][j][k] = val;
return true;
} | O3 | cpp | MemoryManager::setByteNoCache(unsigned int, unsigned char):
pushq %rbx
movl %esi, %eax
shrl $0x16, %eax
movq (%rdi,%rax,8), %rax
testq %rax, %rax
je 0x2fce
movl %esi, %ecx
shrl $0x9, %ecx
andl $0x1ff8, %ecx # imm = 0x1FF8
movq (%rax,%rcx), %rax
testq %rax, %rax
je 0x2fce
andl $0xfff, %esi # imm = 0xFFF
movb %dl, (%rax,%rsi)
movb $0x1, %bl
movl %ebx, %eax
popq %rbx
retq
leaq 0x21c0(%rip), %rdi # 0x5195
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2330
jmp 0x2fca
| _ZN13MemoryManager14setByteNoCacheEjh:
push rbx
mov eax, esi
shr eax, 16h
mov rax, [rdi+rax*8]
test rax, rax
jz short loc_2FCE
mov ecx, esi
shr ecx, 9
and ecx, 1FF8h
mov rax, [rax+rcx]
test rax, rax
jz short loc_2FCE
and esi, 0FFFh
mov [rax+rsi], dl
mov bl, 1
loc_2FCA:
mov eax, ebx
pop rbx
retn
loc_2FCE:
lea rdi, aByteWriteToInv; "Byte write to invalid addr 0x%x!\n"
xor ebx, ebx
xor eax, eax
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
jmp short loc_2FCA
| long long MemoryManager::setByteNoCache(
MemoryManager *this,
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)
{
unsigned int v14; // ebx
long long v15; // rax
long long v16; // rax
char v18; // [rsp+0h] [rbp-8h]
v15 = *((_QWORD *)this + ((unsigned int)a2 >> 22));
if ( v15 && (a4 = ((unsigned int)a2 >> 9) & 0x1FF8, (v16 = *(_QWORD *)(v15 + a4)) != 0) )
{
*(_BYTE *)(v16 + (a2 & 0xFFF)) = a3;
LOBYTE(v14) = 1;
}
else
{
v14 = 0;
dbgprintf("Byte write to invalid addr 0x%x!\n", a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v18);
}
return v14;
}
| setByteNoCache:
PUSH RBX
MOV EAX,ESI
SHR EAX,0x16
MOV RAX,qword ptr [RDI + RAX*0x8]
TEST RAX,RAX
JZ 0x00102fce
MOV ECX,ESI
SHR ECX,0x9
AND ECX,0x1ff8
MOV RAX,qword ptr [RAX + RCX*0x1]
TEST RAX,RAX
JZ 0x00102fce
AND ESI,0xfff
MOV byte ptr [RAX + RSI*0x1],DL
MOV BL,0x1
LAB_00102fca:
MOV EAX,EBX
POP RBX
RET
LAB_00102fce:
LEA RDI,[0x105195]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00102330
JMP 0x00102fca
|
/* MemoryManager::setByteNoCache(unsigned int, unsigned char) */
ulong __thiscall MemoryManager::setByteNoCache(MemoryManager *this,uint param_1,uchar param_2)
{
long lVar1;
int8 unaff_RBX;
ulong uVar2;
if ((*(long *)(this + (ulong)(param_1 >> 0x16) * 8) == 0) ||
(lVar1 = *(long *)(*(long *)(this + (ulong)(param_1 >> 0x16) * 8) +
(ulong)(param_1 >> 9 & 0x1ff8)), lVar1 == 0)) {
uVar2 = 0;
dbgprintf("Byte write to invalid addr 0x%x!\n");
}
else {
*(uchar *)(lVar1 + (ulong)(param_1 & 0xfff)) = param_2;
uVar2 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
}
return uVar2 & 0xffffffff;
}
| |
25,974 | mthd_my_read_rows | eloqsql/libmariadb/libmariadb/mariadb_lib.c | MYSQL_DATA *mthd_my_read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
uint fields)
{
uint field;
ulong pkt_len;
ulong len;
uchar *cp;
char *to, *end_to;
MYSQL_DATA *result;
MYSQL_ROWS **prev_ptr,*cur;
NET *net = &mysql->net;
if ((pkt_len= ma_net_safe_read(mysql)) == packet_error)
return(0);
if (!(result=(MYSQL_DATA*) calloc(1, sizeof(MYSQL_DATA))))
{
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(0);
}
ma_init_alloc_root(&result->alloc,8192,0); /* Assume rowlength < 8192 */
result->alloc.min_malloc=sizeof(MYSQL_ROWS);
prev_ptr= &result->data;
result->rows=0;
result->fields=fields;
while (*(cp=net->read_pos) != 254 || pkt_len >= 8)
{
result->rows++;
if (!(cur= (MYSQL_ROWS*) ma_alloc_root(&result->alloc,
sizeof(MYSQL_ROWS))) ||
!(cur->data= ((MYSQL_ROW)
ma_alloc_root(&result->alloc,
(fields+1)*sizeof(char *)+fields+pkt_len))))
{
free_rows(result);
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(0);
}
*prev_ptr=cur;
prev_ptr= &cur->next;
to= (char*) (cur->data+fields+1);
end_to=to+fields+pkt_len-1;
for (field=0 ; field < fields ; field++)
{
if ((len=(ulong) net_field_length(&cp)) == NULL_LENGTH)
{ /* null field */
cur->data[field] = 0;
}
else
{
cur->data[field] = to;
if (len > (ulong)(end_to - to) || to > end_to)
{
free_rows(result);
SET_CLIENT_ERROR(mysql, CR_UNKNOWN_ERROR, SQLSTATE_UNKNOWN, 0);
return(0);
}
memcpy(to,(char*) cp,len); to[len]=0;
to+=len+1;
cp+=len;
if (mysql_fields)
{
if (mysql_fields[field].max_length < len)
mysql_fields[field].max_length=len;
}
}
}
cur->data[field]=to; /* End of last field */
if ((pkt_len=ma_net_safe_read(mysql)) == packet_error)
{
free_rows(result);
return(0);
}
}
*prev_ptr=0; /* last pointer is null */
/* save status */
if (pkt_len > 1)
{
cp++;
mysql->warning_count= uint2korr(cp);
cp+= 2;
mysql->server_status= uint2korr(cp);
}
return(result);
} | O3 | c | mthd_my_read_rows:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movq %rsi, -0x60(%rbp)
movq %rdi, %r15
callq 0x26beb
movq %rax, %r14
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x296a6
movl $0x1, %edi
movl $0x60, %esi
callq 0x142f0
testq %rax, %rax
je 0x296ba
movq %rax, %r12
movq %rax, %rdi
addq $0x10, %rdi
movl $0x2000, %esi # imm = 0x2000
movq %rdi, -0x30(%rbp)
xorl %edx, %edx
callq 0x2f3b4
movq %r12, %rdx
movq $0x18, 0x28(%r12)
movq $0x0, 0x48(%r12)
movl %ebx, 0x50(%r12)
leal 0x1(%rbx), %eax
movq %rbx, -0x70(%rbp)
movl %ebx, %ecx
leaq (%rcx,%rax,8), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x68(%rbp)
movq %r12, %rbx
movq %r15, -0x58(%rbp)
movq %r12, -0x40(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x20(%r15), %r13
cmpq $0x7, %r14
ja 0x29487
cmpb $-0x2, (%r13)
je 0x2977f
movq %r15, %r12
incq 0x48(%rdx)
movl $0x18, %esi
movq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x2f423
testq %rax, %rax
je 0x29710
movq %rax, %rcx
movq -0x78(%rbp), %rax
leaq (%rax,%r14), %rsi
movq %r15, %rdi
movq %rcx, -0x38(%rbp)
callq 0x2f423
movq -0x38(%rbp), %rdx
movq %rax, 0x8(%rdx)
testq %rax, %rax
je 0x29710
movq %rdx, (%rbx)
movq 0x8(%rdx), %rax
movq -0x50(%rbp), %rcx
leaq (%rax,%rcx,8), %rbx
addq $0x8, %rbx
cmpl $0x0, -0x70(%rbp)
je 0x295f3
leaq (%rax,%rcx,8), %rax
addq %rcx, %rax
addq $0x8, %rax
leaq (%r14,%rax), %r8
decq %r8
movq -0x68(%rbp), %r15
xorl %r12d, %r12d
movq -0x30(%rbp), %rdi
movq %r8, -0x48(%rbp)
movzbl (%r13), %r14d
cmpq $0xfa, %r14
ja 0x29573
incq %r13
movq 0x8(%rdx), %rax
movq %rbx, (%rax,%r12,8)
movq %r8, %rax
subq %rbx, %rax
cmpq %rax, %r14
ja 0x29641
cmpq %r8, %rbx
ja 0x29641
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x143a0
addq %r14, %r13
addq %r14, %rbx
incq %rbx
movb $0x0, -0x1(%rbx)
cmpq $0x0, -0x60(%rbp)
je 0x29599
cmpq %r14, (%r15)
movq -0x50(%rbp), %rcx
jae 0x2956d
movq %r14, (%r15)
movq -0x30(%rbp), %rdi
jmp 0x295a1
cmpq $0xfb, %r14
je 0x295d5
cmpl $0xfd, %r14d
je 0x295bb
cmpl $0xfc, %r14d
jne 0x295e6
movzwl 0x1(%r13), %r14d
addq $0x3, %r13
jmp 0x2951f
movq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %r8
incq %r12
subq $-0x80, %r15
cmpq %r12, %rcx
jne 0x2950e
jmp 0x295fa
movzwl 0x1(%r13), %eax
movzbl 0x3(%r13), %r14d
addq $0x4, %r13
shll $0x10, %r14d
orq %rax, %r14
jmp 0x2951f
incq %r13
movq 0x8(%rdx), %rax
movq $0x0, (%rax,%r12,8)
jmp 0x295a9
movl 0x1(%r13), %r14d
addq $0x9, %r13
jmp 0x2951f
xorl %ecx, %ecx
movq %r12, %r15
jmp 0x29602
movq 0x8(%rdx), %rax
movq -0x58(%rbp), %r15
movq %rdx, %r12
movq %rbx, (%rax,%rcx,8)
movq %r15, %rdi
callq 0x26beb
movq %rax, %r14
movq %r12, %rbx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r14
movq -0x40(%rbp), %rdx
jne 0x29472
movq %rdx, %rbx
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x2f53b
movq %rbx, %rdi
callq 0x14590
jmp 0x296a6
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x2f53b
movq -0x40(%rbp), %rdi
callq 0x14590
movq -0x58(%rbp), %r14
movl $0x7d0, 0x90(%r14) # imm = 0x7D0
leaq 0x297(%r14), %rdi
leaq 0x39380(%rip), %rax # 0x629f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14230
movb %bl, 0x29c(%r14)
leaq 0x97(%r14), %rdi
leaq 0x3936e(%rip), %rax # 0x62a00
movq (%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14230
movb %bl, 0x296(%r14)
xorl %edx, %edx
movq %rdx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x7d8, 0x90(%r15) # imm = 0x7D8
leaq 0x297(%r15), %rdi
leaq 0x3931d(%rip), %rax # 0x629f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14230
xorl %eax, %eax
movb %al, 0x29c(%r15)
leaq 0x97(%r15), %rdi
leaq 0x39309(%rip), %rax # 0x62a00
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14230
xorl %edx, %edx
movb %dl, 0x296(%r15)
jmp 0x296a8
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
callq 0x2f53b
movq -0x40(%rbp), %rdi
callq 0x14590
movl $0x7d8, 0x90(%r12) # imm = 0x7D8
leaq 0x297(%r12), %rdi
leaq 0x392b0(%rip), %rax # 0x629f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14230
movb %bl, 0x29c(%r12)
leaq 0x97(%r12), %rdi
leaq 0x3929c(%rip), %rax # 0x62a00
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14230
movb %bl, 0x296(%r12)
jmp 0x296a6
movq $0x0, (%rbx)
cmpq $0x2, %r14
jb 0x296a8
movzwl 0x1(%r13), %eax
movl %eax, 0x388(%r15)
movzwl 0x3(%r13), %eax
movl %eax, 0x380(%r15)
jmp 0x296a8
| mthd_my_read_rows:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov ebx, edx
mov [rbp+var_60], rsi
mov r15, rdi
call ma_net_safe_read
mov r14, rax
mov eax, 0FFFFFFFFh
cmp r14, rax
jz loc_296A6
mov edi, 1
mov esi, 60h ; '`'
call _calloc
test rax, rax
jz loc_296BA
mov r12, rax
mov rdi, rax
add rdi, 10h
mov esi, 2000h
mov [rbp+var_30], rdi
xor edx, edx
call ma_init_alloc_root
mov rdx, r12
mov qword ptr [r12+28h], 18h
mov qword ptr [r12+48h], 0
mov [r12+50h], ebx
lea eax, [rbx+1]
mov [rbp+var_70], rbx
mov ecx, ebx
lea rax, [rcx+rax*8]
mov [rbp+var_78], rax
mov rax, [rbp+var_60]
add rax, 40h ; '@'
mov [rbp+var_68], rax
mov rbx, r12
mov [rbp+var_58], r15
mov [rbp+var_40], r12
mov [rbp+var_50], rcx
loc_29472:
mov r13, [r15+20h]
cmp r14, 7
ja short loc_29487
cmp byte ptr [r13+0], 0FEh
jz loc_2977F
loc_29487:
mov r12, r15
inc qword ptr [rdx+48h]
mov esi, 18h
mov r15, [rbp+var_30]
mov rdi, r15
call ma_alloc_root
test rax, rax
jz loc_29710
mov rcx, rax
mov rax, [rbp+var_78]
lea rsi, [rax+r14]
mov rdi, r15
mov [rbp+var_38], rcx
call ma_alloc_root
mov rdx, [rbp+var_38]
mov [rdx+8], rax
test rax, rax
jz loc_29710
mov [rbx], rdx
mov rax, [rdx+8]
mov rcx, [rbp+var_50]
lea rbx, [rax+rcx*8]
add rbx, 8
cmp dword ptr [rbp+var_70], 0
jz loc_295F3
lea rax, [rax+rcx*8]
add rax, rcx
add rax, 8
lea r8, [r14+rax]
dec r8
mov r15, [rbp+var_68]
xor r12d, r12d
mov rdi, [rbp+var_30]
mov [rbp+var_48], r8
loc_2950E:
movzx r14d, byte ptr [r13+0]
cmp r14, 0FAh
ja short loc_29573
inc r13
loc_2951F:
mov rax, [rdx+8]
mov [rax+r12*8], rbx
mov rax, r8
sub rax, rbx
cmp r14, rax
ja loc_29641
cmp rbx, r8
ja loc_29641
mov rdi, rbx
mov rsi, r13
mov rdx, r14
call _memcpy
add r13, r14
add rbx, r14
inc rbx
mov byte ptr [rbx-1], 0
cmp [rbp+var_60], 0
jz short loc_29599
cmp [r15], r14
mov rcx, [rbp+var_50]
jnb short loc_2956D
mov [r15], r14
loc_2956D:
mov rdi, [rbp+var_30]
jmp short loc_295A1
loc_29573:
cmp r14, 0FBh
jz short loc_295D5
cmp r14d, 0FDh
jz short loc_295BB
cmp r14d, 0FCh
jnz short loc_295E6
movzx r14d, word ptr [r13+1]
add r13, 3
jmp short loc_2951F
loc_29599:
mov rdi, [rbp+var_30]
mov rcx, [rbp+var_50]
loc_295A1:
mov rdx, [rbp+var_38]
mov r8, [rbp+var_48]
loc_295A9:
inc r12
sub r15, 0FFFFFFFFFFFFFF80h
cmp rcx, r12
jnz loc_2950E
jmp short loc_295FA
loc_295BB:
movzx eax, word ptr [r13+1]
movzx r14d, byte ptr [r13+3]
add r13, 4
shl r14d, 10h
or r14, rax
jmp loc_2951F
loc_295D5:
inc r13
mov rax, [rdx+8]
mov qword ptr [rax+r12*8], 0
jmp short loc_295A9
loc_295E6:
mov r14d, [r13+1]
add r13, 9
jmp loc_2951F
loc_295F3:
xor ecx, ecx
mov r15, r12
jmp short loc_29602
loc_295FA:
mov rax, [rdx+8]
mov r15, [rbp+var_58]
loc_29602:
mov r12, rdx
mov [rax+rcx*8], rbx
mov rdi, r15
call ma_net_safe_read
mov r14, rax
mov rbx, r12
mov eax, 0FFFFFFFFh
cmp r14, rax
mov rdx, [rbp+var_40]
jnz loc_29472
mov rbx, rdx
mov rdi, [rbp+var_30]
xor esi, esi
call ma_free_root
mov rdi, rbx
call _free
jmp short loc_296A6
loc_29641:
xor ebx, ebx
xor esi, esi
call ma_free_root
mov rdi, [rbp+var_40]
call _free
mov r14, [rbp+var_58]
mov dword ptr [r14+90h], 7D0h
lea rdi, [r14+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov [r14+29Ch], bl
lea rdi, [r14+97h]
lea rax, client_errors
mov rsi, [rax]
mov edx, 1FFh
call _strncpy
mov [r14+296h], bl
loc_296A6:
xor edx, edx
loc_296A8:
mov rax, rdx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_296BA:
mov dword ptr [r15+90h], 7D8h
lea rdi, [r15+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor eax, eax
mov [r15+29Ch], al
lea rdi, [r15+97h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
xor edx, edx
mov [r15+296h], dl
jmp short loc_296A8
loc_29710:
xor ebx, ebx
mov rdi, r15
xor esi, esi
call ma_free_root
mov rdi, [rbp+var_40]
call _free
mov dword ptr [r12+90h], 7D8h
lea rdi, [r12+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov [r12+29Ch], bl
lea rdi, [r12+97h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov [r12+296h], bl
jmp loc_296A6
loc_2977F:
mov qword ptr [rbx], 0
cmp r14, 2
jb loc_296A8
movzx eax, word ptr [r13+1]
mov [r15+388h], eax
movzx eax, word ptr [r13+3]
mov [r15+380h], eax
jmp loc_296A8
| long long mthd_my_read_rows(long long a1, long long a2, long long a3, long long a4, unsigned long long a5, int a6)
{
unsigned int v6; // ebx
long long v7; // r15
unsigned long long v8; // r14
long long v9; // rax
long long v10; // r12
long long v11; // rdx
long long v12; // rcx
_QWORD *v13; // rbx
unsigned __int8 *v14; // r13
long long v15; // rax
long long v16; // rsi
long long v17; // rax
unsigned long long v18; // r8
int v19; // r9d
long long v20; // rdx
long long v21; // rax
long long v22; // rcx
unsigned long long v23; // rbx
unsigned long long *v24; // r15
long long v25; // r12
long long v26; // rdi
unsigned long long v27; // r14
unsigned __int8 *v28; // r13
long long v29; // rax
int v30; // r14d
_QWORD *v31; // r12
long long v33; // [rsp+8h] [rbp-78h]
unsigned int v34; // [rsp+10h] [rbp-70h]
unsigned long long *v35; // [rsp+18h] [rbp-68h]
long long v38; // [rsp+30h] [rbp-50h]
unsigned long long v39; // [rsp+38h] [rbp-48h]
long long v40; // [rsp+40h] [rbp-40h]
long long v41; // [rsp+48h] [rbp-38h]
long long v42; // [rsp+50h] [rbp-30h]
v6 = a3;
v7 = a1;
v8 = ma_net_safe_read(a1, a2, a3, a4, a5, a6);
if ( v8 == 0xFFFFFFFF )
return 0LL;
v9 = calloc(1LL, 96LL);
if ( v9 )
{
v10 = v9;
v42 = v9 + 16;
ma_init_alloc_root(v9 + 16, 0x2000LL, 0LL);
v11 = v10;
*(_QWORD *)(v10 + 40) = 24LL;
*(_QWORD *)(v10 + 72) = 0LL;
*(_DWORD *)(v10 + 80) = v6;
v34 = v6;
v12 = v6;
v33 = v6 + 8LL * (v6 + 1);
v35 = (unsigned long long *)(a2 + 64);
v13 = (_QWORD *)v10;
v40 = v10;
v38 = v12;
while ( 1 )
{
v14 = *(unsigned __int8 **)(v7 + 32);
if ( v8 <= 7 && *v14 == 0xFE )
break;
++*(_QWORD *)(v11 + 72);
v15 = ma_alloc_root(v42, 24LL);
if ( !v15
|| (v16 = v33 + v8, v41 = v15,
v17 = ma_alloc_root(v42, v33 + v8),
v20 = v41,
(*(_QWORD *)(v41 + 8) = v17) == 0LL) )
{
ma_free_root(v42, 0LL);
free(v40);
*(_DWORD *)(v7 + 144) = 2008;
strncpy(v7 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v7 + 668) = 0;
strncpy(v7 + 151, client_errors[8], 511LL);
*(_BYTE *)(v7 + 662) = 0;
return 0LL;
}
*v13 = v41;
v21 = *(_QWORD *)(v41 + 8);
v22 = v38;
v23 = v21 + 8 * v38 + 8;
if ( v34 )
{
v18 = v8 + v38 + v21 + 8 * v38 + 8 - 1;
v24 = v35;
v25 = 0LL;
v26 = v42;
v39 = v18;
while ( 1 )
{
v27 = *v14;
if ( v27 > 0xFA )
{
if ( v27 == 251 )
{
++v14;
*(_QWORD *)(*(_QWORD *)(v20 + 8) + 8 * v25) = 0LL;
goto LABEL_24;
}
if ( (_DWORD)v27 == 253 )
{
v29 = *(unsigned __int16 *)(v14 + 1);
v30 = v14[3];
v28 = v14 + 4;
v27 = v29 | (unsigned int)(v30 << 16);
}
else if ( (_DWORD)v27 == 252 )
{
v27 = *(unsigned __int16 *)(v14 + 1);
v28 = v14 + 3;
}
else
{
v27 = *(unsigned int *)(v14 + 1);
v28 = v14 + 9;
}
}
else
{
v28 = v14 + 1;
}
*(_QWORD *)(*(_QWORD *)(v20 + 8) + 8 * v25) = v23;
if ( v27 > v18 - v23 || v23 > v18 )
{
ma_free_root(v26, 0LL);
free(v40);
*(_DWORD *)(a1 + 144) = 2000;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[0], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return 0LL;
}
v16 = (long long)v28;
memcpy(v23, v28, v27);
v14 = &v28[v27];
v23 += v27 + 1;
*(_BYTE *)(v23 - 1) = 0;
if ( a2 )
{
v22 = v38;
if ( *v24 < v27 )
*v24 = v27;
v26 = v42;
}
else
{
v26 = v42;
v22 = v38;
}
v20 = v41;
v18 = v39;
LABEL_24:
++v25;
v24 += 16;
if ( v22 == v25 )
{
v21 = *(_QWORD *)(v20 + 8);
v7 = a1;
goto LABEL_30;
}
}
}
v22 = 0LL;
LABEL_30:
v31 = (_QWORD *)v20;
*(_QWORD *)(v21 + 8 * v22) = v23;
v8 = ma_net_safe_read(v7, v16, v20, v22, v18, v19);
v13 = v31;
v11 = v40;
if ( v8 == 0xFFFFFFFF )
{
ma_free_root(v42, 0LL);
free(v40);
return 0LL;
}
}
*v13 = 0LL;
if ( v8 >= 2 )
{
*(_DWORD *)(v7 + 904) = *(unsigned __int16 *)(v14 + 1);
*(_DWORD *)(v7 + 896) = *(unsigned __int16 *)(v14 + 3);
}
}
else
{
*(_DWORD *)(a1 + 144) = 2008;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[8], 511LL);
v11 = 0LL;
*(_BYTE *)(a1 + 662) = 0;
}
return v11;
}
| mthd_my_read_rows:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV EBX,EDX
MOV qword ptr [RBP + -0x60],RSI
MOV R15,RDI
CALL 0x00126beb
MOV R14,RAX
MOV EAX,0xffffffff
CMP R14,RAX
JZ 0x001296a6
MOV EDI,0x1
MOV ESI,0x60
CALL 0x001142f0
TEST RAX,RAX
JZ 0x001296ba
MOV R12,RAX
MOV RDI,RAX
ADD RDI,0x10
MOV ESI,0x2000
MOV qword ptr [RBP + -0x30],RDI
XOR EDX,EDX
CALL 0x0012f3b4
MOV RDX,R12
MOV qword ptr [R12 + 0x28],0x18
MOV qword ptr [R12 + 0x48],0x0
MOV dword ptr [R12 + 0x50],EBX
LEA EAX,[RBX + 0x1]
MOV qword ptr [RBP + -0x70],RBX
MOV ECX,EBX
LEA RAX,[RCX + RAX*0x8]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x40
MOV qword ptr [RBP + -0x68],RAX
MOV RBX,R12
MOV qword ptr [RBP + -0x58],R15
MOV qword ptr [RBP + -0x40],R12
MOV qword ptr [RBP + -0x50],RCX
LAB_00129472:
MOV R13,qword ptr [R15 + 0x20]
CMP R14,0x7
JA 0x00129487
CMP byte ptr [R13],0xfe
JZ 0x0012977f
LAB_00129487:
MOV R12,R15
INC qword ptr [RDX + 0x48]
MOV ESI,0x18
MOV R15,qword ptr [RBP + -0x30]
MOV RDI,R15
CALL 0x0012f423
TEST RAX,RAX
JZ 0x00129710
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x78]
LEA RSI,[RAX + R14*0x1]
MOV RDI,R15
MOV qword ptr [RBP + -0x38],RCX
CALL 0x0012f423
MOV RDX,qword ptr [RBP + -0x38]
MOV qword ptr [RDX + 0x8],RAX
TEST RAX,RAX
JZ 0x00129710
MOV qword ptr [RBX],RDX
MOV RAX,qword ptr [RDX + 0x8]
MOV RCX,qword ptr [RBP + -0x50]
LEA RBX,[RAX + RCX*0x8]
ADD RBX,0x8
CMP dword ptr [RBP + -0x70],0x0
JZ 0x001295f3
LEA RAX,[RAX + RCX*0x8]
ADD RAX,RCX
ADD RAX,0x8
LEA R8,[R14 + RAX*0x1]
DEC R8
MOV R15,qword ptr [RBP + -0x68]
XOR R12D,R12D
MOV RDI,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],R8
LAB_0012950e:
MOVZX R14D,byte ptr [R13]
CMP R14,0xfa
JA 0x00129573
INC R13
LAB_0012951f:
MOV RAX,qword ptr [RDX + 0x8]
MOV qword ptr [RAX + R12*0x8],RBX
MOV RAX,R8
SUB RAX,RBX
CMP R14,RAX
JA 0x00129641
CMP RBX,R8
JA 0x00129641
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R14
CALL 0x001143a0
ADD R13,R14
ADD RBX,R14
INC RBX
MOV byte ptr [RBX + -0x1],0x0
CMP qword ptr [RBP + -0x60],0x0
JZ 0x00129599
CMP qword ptr [R15],R14
MOV RCX,qword ptr [RBP + -0x50]
JNC 0x0012956d
MOV qword ptr [R15],R14
LAB_0012956d:
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x001295a1
LAB_00129573:
CMP R14,0xfb
JZ 0x001295d5
CMP R14D,0xfd
JZ 0x001295bb
CMP R14D,0xfc
JNZ 0x001295e6
MOVZX R14D,word ptr [R13 + 0x1]
ADD R13,0x3
JMP 0x0012951f
LAB_00129599:
MOV RDI,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x50]
LAB_001295a1:
MOV RDX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x48]
LAB_001295a9:
INC R12
SUB R15,-0x80
CMP RCX,R12
JNZ 0x0012950e
JMP 0x001295fa
LAB_001295bb:
MOVZX EAX,word ptr [R13 + 0x1]
MOVZX R14D,byte ptr [R13 + 0x3]
ADD R13,0x4
SHL R14D,0x10
OR R14,RAX
JMP 0x0012951f
LAB_001295d5:
INC R13
MOV RAX,qword ptr [RDX + 0x8]
MOV qword ptr [RAX + R12*0x8],0x0
JMP 0x001295a9
LAB_001295e6:
MOV R14D,dword ptr [R13 + 0x1]
ADD R13,0x9
JMP 0x0012951f
LAB_001295f3:
XOR ECX,ECX
MOV R15,R12
JMP 0x00129602
LAB_001295fa:
MOV RAX,qword ptr [RDX + 0x8]
MOV R15,qword ptr [RBP + -0x58]
LAB_00129602:
MOV R12,RDX
MOV qword ptr [RAX + RCX*0x8],RBX
MOV RDI,R15
CALL 0x00126beb
MOV R14,RAX
MOV RBX,R12
MOV EAX,0xffffffff
CMP R14,RAX
MOV RDX,qword ptr [RBP + -0x40]
JNZ 0x00129472
MOV RBX,RDX
MOV RDI,qword ptr [RBP + -0x30]
XOR ESI,ESI
CALL 0x0012f53b
MOV RDI,RBX
CALL 0x00114590
JMP 0x001296a6
LAB_00129641:
XOR EBX,EBX
XOR ESI,ESI
CALL 0x0012f53b
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00114590
MOV R14,qword ptr [RBP + -0x58]
MOV dword ptr [R14 + 0x90],0x7d0
LEA RDI,[R14 + 0x297]
LEA RAX,[0x1629f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114230
MOV byte ptr [R14 + 0x29c],BL
LEA RDI,[R14 + 0x97]
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX]
MOV EDX,0x1ff
CALL 0x00114230
MOV byte ptr [R14 + 0x296],BL
LAB_001296a6:
XOR EDX,EDX
LAB_001296a8:
MOV RAX,RDX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001296ba:
MOV dword ptr [R15 + 0x90],0x7d8
LEA RDI,[R15 + 0x297]
LEA RAX,[0x1629f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114230
XOR EAX,EAX
MOV byte ptr [R15 + 0x29c],AL
LEA RDI,[R15 + 0x97]
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00114230
XOR EDX,EDX
MOV byte ptr [R15 + 0x296],DL
JMP 0x001296a8
LAB_00129710:
XOR EBX,EBX
MOV RDI,R15
XOR ESI,ESI
CALL 0x0012f53b
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00114590
MOV dword ptr [R12 + 0x90],0x7d8
LEA RDI,[R12 + 0x297]
LEA RAX,[0x1629f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114230
MOV byte ptr [R12 + 0x29c],BL
LEA RDI,[R12 + 0x97]
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00114230
MOV byte ptr [R12 + 0x296],BL
JMP 0x001296a6
LAB_0012977f:
MOV qword ptr [RBX],0x0
CMP R14,0x2
JC 0x001296a8
MOVZX EAX,word ptr [R13 + 0x1]
MOV dword ptr [R15 + 0x388],EAX
MOVZX EAX,word ptr [R13 + 0x3]
MOV dword ptr [R15 + 0x380],EAX
JMP 0x001296a8
|
int8 * mthd_my_read_rows(long param_1,long param_2,uint param_3)
{
byte bVar1;
ulong uVar2;
int8 *__ptr;
int8 *puVar3;
long lVar4;
ulong uVar5;
int8 *puVar6;
int1 *__dest;
int1 *puVar7;
int8 *puVar8;
int1 *puVar9;
byte *__src;
byte *pbVar10;
ulong __n;
ulong *puVar11;
uVar2 = ma_net_safe_read();
if (uVar2 != 0xffffffff) {
__ptr = (int8 *)calloc(1,0x60);
if (__ptr == (int8 *)0x0) {
*(int4 *)(param_1 + 0x90) = 0x7d8;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Client_run_out_of_memory_00162a40,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
return (int8 *)0x0;
}
puVar8 = __ptr + 2;
ma_init_alloc_root(puVar8,0x2000,0);
__ptr[5] = 0x18;
__ptr[9] = 0;
*(uint *)(__ptr + 10) = param_3;
uVar5 = (ulong)param_3;
puVar6 = __ptr;
do {
pbVar10 = *(byte **)(param_1 + 0x20);
if ((uVar2 < 8) && (*pbVar10 == 0xfe)) {
*puVar6 = 0;
if (1 < uVar2) {
*(uint *)(param_1 + 0x388) = (uint)*(ushort *)(pbVar10 + 1);
*(uint *)(param_1 + 0x380) = (uint)*(ushort *)(pbVar10 + 3);
return __ptr;
}
return __ptr;
}
__ptr[9] = __ptr[9] + 1;
puVar3 = (int8 *)ma_alloc_root(puVar8,0x18);
if (puVar3 == (int8 *)0x0) {
LAB_00129710:
ma_free_root(puVar8,0);
free(__ptr);
*(int4 *)(param_1 + 0x90) = 0x7d8;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Client_run_out_of_memory_00162a40,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
return (int8 *)0x0;
}
lVar4 = ma_alloc_root(puVar8,uVar5 + (ulong)(param_3 + 1) * 8 + uVar2);
puVar3[1] = lVar4;
if (lVar4 == 0) goto LAB_00129710;
*puVar6 = puVar3;
lVar4 = puVar3[1];
__dest = (int1 *)(lVar4 + uVar5 * 8 + 8);
if (param_3 == 0) {
uVar2 = 0;
}
else {
puVar9 = (int1 *)(uVar2 + lVar4 + uVar5 * 9 + 7);
uVar2 = 0;
puVar11 = (ulong *)(param_2 + 0x40);
do {
bVar1 = *pbVar10;
__n = (ulong)bVar1;
if (__n < 0xfb) {
__src = pbVar10 + 1;
LAB_0012951f:
*(int1 **)(puVar3[1] + uVar2 * 8) = __dest;
if (((ulong)((long)puVar9 - (long)__dest) < __n) || (puVar9 < __dest)) {
ma_free_root(puVar8,0);
free(__ptr);
*(int4 *)(param_1 + 0x90) = 2000;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),client_errors,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
return (int8 *)0x0;
}
memcpy(__dest,__src,__n);
pbVar10 = __src + __n;
puVar7 = __dest + __n;
__dest = puVar7 + 1;
*puVar7 = 0;
if ((param_2 != 0) && (*puVar11 < __n)) {
*puVar11 = __n;
}
}
else {
if (__n != 0xfb) {
if (bVar1 == 0xfd) {
__src = pbVar10 + 4;
__n = (ulong)*(uint3 *)(pbVar10 + 1);
}
else if (bVar1 == 0xfc) {
__n = (ulong)*(ushort *)(pbVar10 + 1);
__src = pbVar10 + 3;
}
else {
__n = (ulong)*(uint *)(pbVar10 + 1);
__src = pbVar10 + 9;
}
goto LAB_0012951f;
}
pbVar10 = pbVar10 + 1;
*(int8 *)(puVar3[1] + uVar2 * 8) = 0;
}
uVar2 = uVar2 + 1;
puVar11 = puVar11 + 0x10;
} while (uVar5 != uVar2);
lVar4 = puVar3[1];
uVar2 = uVar5;
}
*(int1 **)(lVar4 + uVar2 * 8) = __dest;
uVar2 = ma_net_safe_read(param_1);
puVar6 = puVar3;
} while (uVar2 != 0xffffffff);
ma_free_root(puVar8,0);
free(__ptr);
}
return (int8 *)0x0;
}
| |
25,975 | mariadb_compress | eloqsql/libmariadb/libmariadb/ma_compress.c | my_bool _mariadb_compress(NET *net, unsigned char *packet, size_t *len, size_t *complen)
{
if (*len < MIN_COMPRESS_LENGTH ||
!compression_plugin(net))
*complen=0;
else
{
unsigned char *compbuf=_mariadb_compress_alloc(net,packet,len,complen);
if (!compbuf)
return *complen ? 0 : 1;
memcpy(packet,compbuf,*len);
free(compbuf);
}
return 0;
} | O3 | c | mariadb_compress:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
cmpq $0x96, (%rdx)
jb 0x2115a
movq 0x2a0(%rdi), %rax
cmpq $0x0, 0x10(%rax)
je 0x2115a
movq %rdx, %r15
movq %rsi, %r14
movq %rbx, %rcx
callq 0x21175
testq %rax, %rax
je 0x2116c
movq %rax, %r12
movq (%r15), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x13390
movq %r12, %rdi
callq 0x13570
jmp 0x21161
movq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, (%rbx)
sete %al
jmp 0x21163
| _mariadb_compress:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rcx
cmp qword ptr [rdx], 96h
jb short loc_2115A
mov rax, [rdi+2A0h]
cmp qword ptr [rax+10h], 0
jz short loc_2115A
mov r15, rdx
mov r14, rsi
mov rcx, rbx
call _mariadb_compress_alloc
test rax, rax
jz short loc_2116C
mov r12, rax
mov rdx, [r15]
mov rdi, r14
mov rsi, rax
call _memcpy
mov rdi, r12
call _free
jmp short loc_21161
loc_2115A:
mov qword ptr [rbx], 0
loc_21161:
xor eax, eax
loc_21163:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_2116C:
cmp qword ptr [rbx], 0
setz al
jmp short loc_21163
| _BOOL8 mariadb_compress(long long a1, long long a2, _QWORD *a3, _QWORD *a4)
{
long long v6; // rax
long long v7; // r12
if ( *a3 < 0x96uLL || !*(_QWORD *)(*(_QWORD *)(a1 + 672) + 16LL) )
{
*a4 = 0LL;
return 0LL;
}
v6 = mariadb_compress_alloc(a1, a2, a3, a4);
if ( v6 )
{
v7 = v6;
memcpy(a2, v6, *a3);
free(v7);
return 0LL;
}
return *a4 == 0LL;
}
| _mariadb_compress:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RCX
CMP qword ptr [RDX],0x96
JC 0x0012115a
MOV RAX,qword ptr [RDI + 0x2a0]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x0012115a
MOV R15,RDX
MOV R14,RSI
MOV RCX,RBX
CALL 0x00121175
TEST RAX,RAX
JZ 0x0012116c
MOV R12,RAX
MOV RDX,qword ptr [R15]
MOV RDI,R14
MOV RSI,RAX
CALL 0x00113390
MOV RDI,R12
CALL 0x00113570
JMP 0x00121161
LAB_0012115a:
MOV qword ptr [RBX],0x0
LAB_00121161:
XOR EAX,EAX
LAB_00121163:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0012116c:
CMP qword ptr [RBX],0x0
SETZ AL
JMP 0x00121163
|
bool _mariadb_compress(long param_1,void *param_2,size_t *param_3,long *param_4)
{
void *__src;
if ((*param_3 < 0x96) || (*(long *)(*(long *)(param_1 + 0x2a0) + 0x10) == 0)) {
*param_4 = 0;
}
else {
__src = (void *)_mariadb_compress_alloc();
if (__src == (void *)0x0) {
return *param_4 == 0;
}
memcpy(param_2,__src,*param_3);
free(__src);
}
return false;
}
| |
25,976 | set_date_fields | bluesky950520[P]quickjs/quickjs.c | static double set_date_fields(double fields[minimum_length(7)], int is_local) {
double y, m, dt, ym, mn, day, h, s, milli, time, tv;
int yi, mi, i;
int64_t days;
volatile double temp; /* enforce evaluation order */
/* emulate 21.4.1.15 MakeDay ( year, month, date ) */
y = fields[0];
m = fields[1];
dt = fields[2];
ym = y + floor(m / 12);
mn = fmod(m, 12);
if (mn < 0)
mn += 12;
if (ym < -271821 || ym > 275760)
return NAN;
yi = ym;
mi = mn;
days = days_from_year(yi);
for(i = 0; i < mi; i++) {
days += month_days[i];
if (i == 1)
days += days_in_year(yi) - 365;
}
day = days + dt - 1;
/* emulate 21.4.1.14 MakeTime ( hour, min, sec, ms ) */
h = fields[3];
m = fields[4];
s = fields[5];
milli = fields[6];
/* Use a volatile intermediary variable to ensure order of evaluation
* as specified in ECMA. This fixes a test262 error on
* test262/test/built-ins/Date/UTC/fp-evaluation-order.js.
* Without the volatile qualifier, the compile can generate code
* that performs the computation in a different order or with instructions
* that produce a different result such as FMA (float multiply and add).
*/
time = h * 3600000;
time += (temp = m * 60000);
time += (temp = s * 1000);
time += milli;
/* emulate 21.4.1.16 MakeDate ( day, time ) */
tv = (temp = day * 86400000) + time; /* prevent generation of FMA */
if (!isfinite(tv))
return NAN;
/* adjust for local time and clip */
if (is_local) {
int64_t ti = tv < INT64_MIN ? INT64_MIN : tv >= 0x1p63 ? INT64_MAX : (int64_t)tv;
tv += getTimezoneOffset(ti) * 60000;
}
return time_clip(tv);
} | O0 | c | set_date_fields:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movq 0xa8(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x98(%rsp)
movq 0xa8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x90(%rsp)
movq 0xa8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x88(%rsp)
movsd 0x98(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x90(%rsp), %xmm0
movsd 0x74349(%rip), %xmm1 # 0x113ad0
divsd %xmm1, %xmm0
callq 0xe8b0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x80(%rsp)
movsd 0x90(%rsp), %xmm0
movsd 0x74319(%rip), %xmm1 # 0x113ad0
callq 0xe410
movsd %xmm0, 0x78(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x78(%rsp), %xmm0
jbe 0x9f7e1
movsd 0x742fb(%rip), %xmm0 # 0x113ad0
addsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x78(%rsp)
movsd 0x742ef(%rip), %xmm0 # 0x113ad8
ucomisd 0x80(%rsp), %xmm0
ja 0x9f80b
movsd 0x80(%rsp), %xmm0
movsd 0x742db(%rip), %xmm1 # 0x113ae0
ucomisd %xmm1, %xmm0
jbe 0x9f821
movsd 0x7425d(%rip), %xmm0 # 0x113a70
movsd %xmm0, 0xb0(%rsp)
jmp 0x9fa87
cvttsd2si 0x80(%rsp), %eax
movl %eax, 0x44(%rsp)
cvttsd2si 0x78(%rsp), %eax
movl %eax, 0x40(%rsp)
movslq 0x44(%rsp), %rdi
callq 0x9f590
movq %rax, 0x30(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jge 0x9f8a3
movslq 0x3c(%rsp), %rcx
leaq 0x7408b(%rip), %rax # 0x1138f0
movslq (%rax,%rcx,4), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpl $0x1, 0x3c(%rsp)
jne 0x9f894
movslq 0x44(%rsp), %rdi
callq 0x9f4c0
subq $0x16d, %rax # imm = 0x16D
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x9f896
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x9f84f
cvtsi2sdq 0x30(%rsp), %xmm0
addsd 0x88(%rsp), %xmm0
movsd 0x74165(%rip), %xmm1 # 0x113a20
subsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
movq 0xa8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x68(%rsp)
movq 0xa8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, 0x90(%rsp)
movq 0xa8(%rsp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x60(%rsp)
movq 0xa8(%rsp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x741e4(%rip), %xmm0 # 0x113b00
mulsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x741c8(%rip), %xmm0 # 0x113af8
mulsd 0x90(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
addsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x7419d(%rip), %xmm0 # 0x113af0
mulsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
addsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x58(%rsp), %xmm0
addsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x74163(%rip), %xmm0 # 0x113ae8
mulsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
addsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x48(%rsp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x9f9df
movsd 0x7409f(%rip), %xmm0 # 0x113a70
movsd %xmm0, 0xb0(%rsp)
jmp 0x9fa87
cmpl $0x0, 0xa4(%rsp)
je 0x9fa73
movsd 0x74053(%rip), %xmm0 # 0x113a48
ucomisd 0x48(%rsp), %xmm0
jbe 0x9fa0e
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rsp)
jmp 0x9fa49
movsd 0x48(%rsp), %xmm0
movsd 0x74034(%rip), %xmm1 # 0x113a50
ucomisd %xmm1, %xmm0
jb 0x9fa33
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x8(%rsp)
jmp 0x9fa3f
cvttsd2si 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x9f350
imull $0xea60, %eax, %eax # imm = 0xEA60
cvtsi2sd %eax, %xmm0
addsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x48(%rsp), %xmm0
callq 0x5b3f0
movsd %xmm0, 0xb0(%rsp)
movsd 0xb0(%rsp), %xmm0
addq $0xb8, %rsp
retq
nopl (%rax,%rax)
| set_date_fields:
sub rsp, 0B8h
mov [rsp+0B8h+var_10], rdi
mov [rsp+0B8h+var_14], esi
mov rax, [rsp+0B8h+var_10]
movsd xmm0, qword ptr [rax]
movsd [rsp+0B8h+var_20], xmm0
mov rax, [rsp+0B8h+var_10]
movsd xmm0, qword ptr [rax+8]
movsd [rsp+0B8h+var_28], xmm0
mov rax, [rsp+0B8h+var_10]
movsd xmm0, qword ptr [rax+10h]
movsd [rsp+0B8h+var_30], xmm0
movsd xmm0, [rsp+0B8h+var_20]
movsd [rsp+0B8h+var_A0], xmm0
movsd xmm0, [rsp+0B8h+var_28]
movsd xmm1, cs:qword_113AD0
divsd xmm0, xmm1
call _floor
movaps xmm1, xmm0
movsd xmm0, [rsp+0B8h+var_A0]
addsd xmm0, xmm1
movsd [rsp+0B8h+var_38], xmm0
movsd xmm0, [rsp+0B8h+var_28]
movsd xmm1, cs:qword_113AD0
call _fmod
movsd [rsp+0B8h+var_40], xmm0
xorps xmm0, xmm0
ucomisd xmm0, [rsp+0B8h+var_40]
jbe short loc_9F7E1
movsd xmm0, cs:qword_113AD0
addsd xmm0, [rsp+0B8h+var_40]
movsd [rsp+0B8h+var_40], xmm0
loc_9F7E1:
movsd xmm0, cs:qword_113AD8
ucomisd xmm0, [rsp+0B8h+var_38]
ja short loc_9F80B
movsd xmm0, [rsp+0B8h+var_38]
movsd xmm1, cs:qword_113AE0
ucomisd xmm0, xmm1
jbe short loc_9F821
loc_9F80B:
movsd xmm0, cs:qword_113A70
movsd [rsp+0B8h+var_8], xmm0
jmp loc_9FA87
loc_9F821:
cvttsd2si eax, [rsp+0B8h+var_38]
mov [rsp+0B8h+var_74], eax
cvttsd2si eax, [rsp+0B8h+var_40]
mov [rsp+0B8h+var_78], eax
movsxd rdi, [rsp+0B8h+var_74]
call days_from_year
mov [rsp+0B8h+var_88], rax
mov [rsp+0B8h+var_7C], 0
loc_9F84F:
mov eax, [rsp+0B8h+var_7C]
cmp eax, [rsp+0B8h+var_78]
jge short loc_9F8A3
movsxd rcx, [rsp+0B8h+var_7C]
lea rax, month_days
movsxd rax, dword ptr [rax+rcx*4]
add rax, [rsp+0B8h+var_88]
mov [rsp+0B8h+var_88], rax
cmp [rsp+0B8h+var_7C], 1
jnz short loc_9F894
movsxd rdi, [rsp+0B8h+var_74]
call days_in_year
sub rax, 16Dh
add rax, [rsp+0B8h+var_88]
mov [rsp+0B8h+var_88], rax
loc_9F894:
jmp short $+2
loc_9F896:
mov eax, [rsp+0B8h+var_7C]
add eax, 1
mov [rsp+0B8h+var_7C], eax
jmp short loc_9F84F
loc_9F8A3:
cvtsi2sd xmm0, [rsp+0B8h+var_88]
addsd xmm0, [rsp+0B8h+var_30]
movsd xmm1, cs:qword_113A20
subsd xmm0, xmm1
movsd [rsp+0B8h+var_48], xmm0
mov rax, [rsp+0B8h+var_10]
movsd xmm0, qword ptr [rax+18h]
movsd [rsp+0B8h+var_50], xmm0
mov rax, [rsp+0B8h+var_10]
movsd xmm0, qword ptr [rax+20h]
movsd [rsp+0B8h+var_28], xmm0
mov rax, [rsp+0B8h+var_10]
movsd xmm0, qword ptr [rax+28h]
movsd [rsp+0B8h+var_58], xmm0
mov rax, [rsp+0B8h+var_10]
movsd xmm0, qword ptr [rax+30h]
movsd [rsp+0B8h+var_60], xmm0
movsd xmm0, cs:qword_113B00
mulsd xmm0, [rsp+0B8h+var_50]
movsd [rsp+0B8h+var_68], xmm0
movsd xmm0, cs:qword_113AF8
mulsd xmm0, [rsp+0B8h+var_28]
movsd [rsp+0B8h+var_90], xmm0
addsd xmm0, [rsp+0B8h+var_68]
movsd [rsp+0B8h+var_68], xmm0
movsd xmm0, cs:qword_113AF0
mulsd xmm0, [rsp+0B8h+var_58]
movsd [rsp+0B8h+var_90], xmm0
addsd xmm0, [rsp+0B8h+var_68]
movsd [rsp+0B8h+var_68], xmm0
movsd xmm0, [rsp+0B8h+var_60]
addsd xmm0, [rsp+0B8h+var_68]
movsd [rsp+0B8h+var_68], xmm0
movsd xmm0, cs:qword_113AE8
mulsd xmm0, [rsp+0B8h+var_48]
movsd [rsp+0B8h+var_90], xmm0
addsd xmm0, [rsp+0B8h+var_68]
movsd [rsp+0B8h+var_70], xmm0
movsd xmm0, [rsp+0B8h+var_70]
movq rax, xmm0
mov rcx, 7FFFFFFFFFFFFFFFh
and rax, rcx
mov rcx, 7FF0000000000000h
sub rax, rcx
setl al
test al, 1
jnz short loc_9F9DF
movsd xmm0, cs:qword_113A70
movsd [rsp+0B8h+var_8], xmm0
jmp loc_9FA87
loc_9F9DF:
cmp [rsp+0B8h+var_14], 0
jz loc_9FA73
movsd xmm0, cs:qword_113A48
ucomisd xmm0, [rsp+0B8h+var_70]
jbe short loc_9FA0E
mov rax, 8000000000000000h
mov [rsp+0B8h+var_A8], rax
jmp short loc_9FA49
loc_9FA0E:
movsd xmm0, [rsp+0B8h+var_70]
movsd xmm1, cs:qword_113A50
ucomisd xmm0, xmm1
jb short loc_9FA33
mov rax, 7FFFFFFFFFFFFFFFh
mov [rsp+0B8h+var_B0], rax
jmp short loc_9FA3F
loc_9FA33:
cvttsd2si rax, [rsp+0B8h+var_70]
mov [rsp+0B8h+var_B0], rax
loc_9FA3F:
mov rax, [rsp+0B8h+var_B0]
mov [rsp+0B8h+var_A8], rax
loc_9FA49:
mov rax, [rsp+0B8h+var_A8]
mov [rsp+0B8h+var_98], rax
mov rdi, [rsp+0B8h+var_98]
call getTimezoneOffset
imul eax, 0EA60h
cvtsi2sd xmm0, eax
addsd xmm0, [rsp+0B8h+var_70]
movsd [rsp+0B8h+var_70], xmm0
loc_9FA73:
movsd xmm0, [rsp+0B8h+var_70]
call time_clip
movsd [rsp+0B8h+var_8], xmm0
loc_9FA87:
movsd xmm0, [rsp+0B8h+var_8]
add rsp, 0B8h
retn
| double set_date_fields(double *a1, int a2)
{
long long v3; // [rsp+8h] [rbp-B0h]
long long v4; // [rsp+10h] [rbp-A8h]
double v5; // [rsp+18h] [rbp-A0h]
long long v6; // [rsp+30h] [rbp-88h]
int i; // [rsp+3Ch] [rbp-7Ch]
double v8; // [rsp+48h] [rbp-70h]
double v9; // [rsp+78h] [rbp-40h]
double v10; // [rsp+80h] [rbp-38h]
double v11; // [rsp+88h] [rbp-30h]
double v12; // [rsp+90h] [rbp-28h]
v12 = a1[1];
v11 = a1[2];
v5 = *a1;
v10 = v5 + floor(v12 / 12.0);
v9 = fmod(v12, 12.0);
if ( v9 < 0.0 )
v9 = v9 + 12.0;
if ( v10 < -271821.0 || v10 > 275760.0 )
return NAN;
v6 = days_from_year((int)v10);
for ( i = 0; i < (int)v9; ++i )
{
v6 += month_days[i];
if ( i == 1 )
v6 += days_in_year((int)v10) - 365;
}
v8 = 86400000.0 * ((double)(int)v6 + v11 - 1.0) + a1[6] + 1000.0 * a1[5] + 60000.0 * a1[4] + 3600000.0 * a1[3];
if ( COERCE__INT64(fabs(v8)) >= 0x7FF0000000000000LL )
return NAN;
if ( a2 )
{
if ( v8 >= -9.223372036854776e18 )
{
if ( v8 < 9.223372036854776e18 )
v3 = (unsigned int)(int)v8;
else
v3 = 0x7FFFFFFFFFFFFFFFLL;
v4 = v3;
}
else
{
v4 = 0x8000000000000000LL;
}
v8 = (double)(int)(60000 * getTimezoneOffset(v4)) + v8;
}
return time_clip(v8);
}
| set_date_fields:
SUB RSP,0xb8
MOV qword ptr [RSP + 0xa8],RDI
MOV dword ptr [RSP + 0xa4],ESI
MOV RAX,qword ptr [RSP + 0xa8]
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RSP + 0x98],XMM0
MOV RAX,qword ptr [RSP + 0xa8]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOVSD qword ptr [RSP + 0x90],XMM0
MOV RAX,qword ptr [RSP + 0xa8]
MOVSD XMM0,qword ptr [RAX + 0x10]
MOVSD qword ptr [RSP + 0x88],XMM0
MOVSD XMM0,qword ptr [RSP + 0x98]
MOVSD qword ptr [RSP + 0x18],XMM0
MOVSD XMM0,qword ptr [RSP + 0x90]
MOVSD XMM1,qword ptr [0x00213ad0]
DIVSD XMM0,XMM1
CALL 0x0010e8b0
MOVAPS XMM1,XMM0
MOVSD XMM0,qword ptr [RSP + 0x18]
ADDSD XMM0,XMM1
MOVSD qword ptr [RSP + 0x80],XMM0
MOVSD XMM0,qword ptr [RSP + 0x90]
MOVSD XMM1,qword ptr [0x00213ad0]
CALL 0x0010e410
MOVSD qword ptr [RSP + 0x78],XMM0
XORPS XMM0,XMM0
UCOMISD XMM0,qword ptr [RSP + 0x78]
JBE 0x0019f7e1
MOVSD XMM0,qword ptr [0x00213ad0]
ADDSD XMM0,qword ptr [RSP + 0x78]
MOVSD qword ptr [RSP + 0x78],XMM0
LAB_0019f7e1:
MOVSD XMM0,qword ptr [0x00213ad8]
UCOMISD XMM0,qword ptr [RSP + 0x80]
JA 0x0019f80b
MOVSD XMM0,qword ptr [RSP + 0x80]
MOVSD XMM1,qword ptr [0x00213ae0]
UCOMISD XMM0,XMM1
JBE 0x0019f821
LAB_0019f80b:
MOVSD XMM0,qword ptr [0x00213a70]
MOVSD qword ptr [RSP + 0xb0],XMM0
JMP 0x0019fa87
LAB_0019f821:
CVTTSD2SI EAX,qword ptr [RSP + 0x80]
MOV dword ptr [RSP + 0x44],EAX
CVTTSD2SI EAX,qword ptr [RSP + 0x78]
MOV dword ptr [RSP + 0x40],EAX
MOVSXD RDI,dword ptr [RSP + 0x44]
CALL 0x0019f590
MOV qword ptr [RSP + 0x30],RAX
MOV dword ptr [RSP + 0x3c],0x0
LAB_0019f84f:
MOV EAX,dword ptr [RSP + 0x3c]
CMP EAX,dword ptr [RSP + 0x40]
JGE 0x0019f8a3
MOVSXD RCX,dword ptr [RSP + 0x3c]
LEA RAX,[0x2138f0]
MOVSXD RAX,dword ptr [RAX + RCX*0x4]
ADD RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x30],RAX
CMP dword ptr [RSP + 0x3c],0x1
JNZ 0x0019f894
MOVSXD RDI,dword ptr [RSP + 0x44]
CALL 0x0019f4c0
SUB RAX,0x16d
ADD RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x30],RAX
LAB_0019f894:
JMP 0x0019f896
LAB_0019f896:
MOV EAX,dword ptr [RSP + 0x3c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x3c],EAX
JMP 0x0019f84f
LAB_0019f8a3:
CVTSI2SD XMM0,qword ptr [RSP + 0x30]
ADDSD XMM0,qword ptr [RSP + 0x88]
MOVSD XMM1,qword ptr [0x00213a20]
SUBSD XMM0,XMM1
MOVSD qword ptr [RSP + 0x70],XMM0
MOV RAX,qword ptr [RSP + 0xa8]
MOVSD XMM0,qword ptr [RAX + 0x18]
MOVSD qword ptr [RSP + 0x68],XMM0
MOV RAX,qword ptr [RSP + 0xa8]
MOVSD XMM0,qword ptr [RAX + 0x20]
MOVSD qword ptr [RSP + 0x90],XMM0
MOV RAX,qword ptr [RSP + 0xa8]
MOVSD XMM0,qword ptr [RAX + 0x28]
MOVSD qword ptr [RSP + 0x60],XMM0
MOV RAX,qword ptr [RSP + 0xa8]
MOVSD XMM0,qword ptr [RAX + 0x30]
MOVSD qword ptr [RSP + 0x58],XMM0
MOVSD XMM0,qword ptr [0x00213b00]
MULSD XMM0,qword ptr [RSP + 0x68]
MOVSD qword ptr [RSP + 0x50],XMM0
MOVSD XMM0,qword ptr [0x00213af8]
MULSD XMM0,qword ptr [RSP + 0x90]
MOVSD qword ptr [RSP + 0x28],XMM0
ADDSD XMM0,qword ptr [RSP + 0x50]
MOVSD qword ptr [RSP + 0x50],XMM0
MOVSD XMM0,qword ptr [0x00213af0]
MULSD XMM0,qword ptr [RSP + 0x60]
MOVSD qword ptr [RSP + 0x28],XMM0
ADDSD XMM0,qword ptr [RSP + 0x50]
MOVSD qword ptr [RSP + 0x50],XMM0
MOVSD XMM0,qword ptr [RSP + 0x58]
ADDSD XMM0,qword ptr [RSP + 0x50]
MOVSD qword ptr [RSP + 0x50],XMM0
MOVSD XMM0,qword ptr [0x00213ae8]
MULSD XMM0,qword ptr [RSP + 0x70]
MOVSD qword ptr [RSP + 0x28],XMM0
ADDSD XMM0,qword ptr [RSP + 0x50]
MOVSD qword ptr [RSP + 0x48],XMM0
MOVSD XMM0,qword ptr [RSP + 0x48]
MOVQ RAX,XMM0
MOV RCX,0x7fffffffffffffff
AND RAX,RCX
MOV RCX,0x7ff0000000000000
SUB RAX,RCX
SETL AL
TEST AL,0x1
JNZ 0x0019f9df
MOVSD XMM0,qword ptr [0x00213a70]
MOVSD qword ptr [RSP + 0xb0],XMM0
JMP 0x0019fa87
LAB_0019f9df:
CMP dword ptr [RSP + 0xa4],0x0
JZ 0x0019fa73
MOVSD XMM0,qword ptr [0x00213a48]
UCOMISD XMM0,qword ptr [RSP + 0x48]
JBE 0x0019fa0e
MOV RAX,-0x8000000000000000
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0019fa49
LAB_0019fa0e:
MOVSD XMM0,qword ptr [RSP + 0x48]
MOVSD XMM1,qword ptr [0x00213a50]
UCOMISD XMM0,XMM1
JC 0x0019fa33
MOV RAX,0x7fffffffffffffff
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0019fa3f
LAB_0019fa33:
CVTTSD2SI RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x8],RAX
LAB_0019fa3f:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RAX
LAB_0019fa49:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0019f350
IMUL EAX,EAX,0xea60
CVTSI2SD XMM0,EAX
ADDSD XMM0,qword ptr [RSP + 0x48]
MOVSD qword ptr [RSP + 0x48],XMM0
LAB_0019fa73:
MOVSD XMM0,qword ptr [RSP + 0x48]
CALL 0x0015b3f0
MOVSD qword ptr [RSP + 0xb0],XMM0
LAB_0019fa87:
MOVSD XMM0,qword ptr [RSP + 0xb0]
ADD RSP,0xb8
RET
|
int8 set_date_fields(double *param_1,int param_2)
{
double dVar1;
double __x;
double dVar2;
int8 uVar3;
double dVar4;
int iVar5;
long lVar6;
long local_b0;
long local_a8;
long local_88;
int local_7c;
double local_70;
double local_40;
dVar1 = *param_1;
__x = param_1[1];
dVar2 = param_1[2];
dVar4 = floor(__x / DAT_00213ad0);
dVar1 = dVar1 + dVar4;
local_40 = fmod(__x,DAT_00213ad0);
if (local_40 < 0.0) {
local_40 = DAT_00213ad0 + local_40;
}
if ((dVar1 < DAT_00213ad8) || (DAT_00213ae0 < dVar1)) {
return DAT_00213a70;
}
local_88 = days_from_year((long)(int)dVar1);
for (local_7c = 0; local_7c < (int)local_40; local_7c = local_7c + 1) {
local_88 = *(int *)(month_days + (long)local_7c * 4) + local_88;
if (local_7c == 1) {
lVar6 = days_in_year((long)(int)dVar1);
local_88 = lVar6 + -0x16d + local_88;
}
}
local_70 = DAT_00213ae8 * (((double)local_88 + dVar2) - DAT_00213a20) +
param_1[6] +
DAT_00213af0 * param_1[5] + DAT_00213af8 * param_1[4] + DAT_00213b00 * param_1[3];
if (0x7fefffffffffffff < (ulong)ABS(local_70)) {
return DAT_00213a70;
}
if (param_2 != 0) {
if (DAT_00213a48 <= local_70) {
if (local_70 < DAT_00213a50) {
local_b0 = (long)local_70;
}
else {
local_b0 = 0x7fffffffffffffff;
}
local_a8 = local_b0;
}
else {
local_a8 = -0x8000000000000000;
}
iVar5 = getTimezoneOffset(local_a8);
local_70 = (double)(iVar5 * 60000) + local_70;
}
uVar3 = time_clip(SUB84(local_70,0));
return uVar3;
}
| |
25,977 | set_date_fields | bluesky950520[P]quickjs/quickjs.c | static double set_date_fields(double fields[minimum_length(7)], int is_local) {
double y, m, dt, ym, mn, day, h, s, milli, time, tv;
int yi, mi, i;
int64_t days;
volatile double temp; /* enforce evaluation order */
/* emulate 21.4.1.15 MakeDay ( year, month, date ) */
y = fields[0];
m = fields[1];
dt = fields[2];
ym = y + floor(m / 12);
mn = fmod(m, 12);
if (mn < 0)
mn += 12;
if (ym < -271821 || ym > 275760)
return NAN;
yi = ym;
mi = mn;
days = days_from_year(yi);
for(i = 0; i < mi; i++) {
days += month_days[i];
if (i == 1)
days += days_in_year(yi) - 365;
}
day = days + dt - 1;
/* emulate 21.4.1.14 MakeTime ( hour, min, sec, ms ) */
h = fields[3];
m = fields[4];
s = fields[5];
milli = fields[6];
/* Use a volatile intermediary variable to ensure order of evaluation
* as specified in ECMA. This fixes a test262 error on
* test262/test/built-ins/Date/UTC/fp-evaluation-order.js.
* Without the volatile qualifier, the compile can generate code
* that performs the computation in a different order or with instructions
* that produce a different result such as FMA (float multiply and add).
*/
time = h * 3600000;
time += (temp = m * 60000);
time += (temp = s * 1000);
time += milli;
/* emulate 21.4.1.16 MakeDate ( day, time ) */
tv = (temp = day * 86400000) + time; /* prevent generation of FMA */
if (!isfinite(tv))
return NAN;
/* adjust for local time and clip */
if (is_local) {
int64_t ti = tv < INT64_MIN ? INT64_MIN : tv >= 0x1p63 ? INT64_MAX : (int64_t)tv;
tv += getTimezoneOffset(ti) * 60000;
}
return time_clip(tv);
} | O1 | c | set_date_fields:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
movq %rdi, %r14
movsd 0x8(%rdi), %xmm1
movsd %xmm1, 0x30(%rsp)
movsd 0x10(%rdi), %xmm0
movaps %xmm0, 0x10(%rsp)
movapd %xmm1, %xmm0
divsd 0x47b4a(%rip), %xmm0 # 0xa2b98
callq 0xe8d0
addsd (%r14), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x47b2c(%rip), %xmm1 # 0xa2b98
callq 0xe420
movsd 0x28(%rsp), %xmm5
movsd 0x47b21(%rip), %xmm1 # 0xa2ba0
ucomisd %xmm5, %xmm1
movsd 0x47ad5(%rip), %xmm4 # 0xa2b60
ja 0x5b3b3
ucomisd 0x47b0f(%rip), %xmm5 # 0xa2ba8
ja 0x5b3b3
movsd 0x47af1(%rip), %xmm1 # 0xa2b98
addsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
cvttsd2si %xmm5, %eax
cvttsd2si %xmm3, %edi
movslq %eax, %r8
imulq $0x16d, %r8, %rax # imm = 0x16D
leaq -0x7b1(%r8), %r10
sarq $0x2, %r10
addq %rax, %r10
leaq -0x76d(%r8), %rsi
movabsq $-0x5c28f5c28f5c28f5, %r9 # imm = 0xA3D70A3D70A3D70B
movq %rsi, %rax
imulq %r9
leaq (%rdx,%r8), %rax
addq $-0x76d, %rax # imm = 0xF893
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x6, %rax
addq %rcx, %rax
imulq $0x64, %rax, %rax
subq %rax, %rsi
sarq $0x3f, %rsi
andq $-0x64, %rsi
addq %rax, %rsi
movabsq $0x5c28f5c28f5c28f5, %rcx # imm = 0x5C28F5C28F5C28F5
movq %rsi, %rax
imulq %rcx
movq %rdx, %rcx
subq %rsi, %rcx
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x6, %rcx
addq %rax, %rcx
addq %r10, %rcx
leaq -0x641(%r8), %rsi
movq %rsi, %rax
imulq %r9
leaq (%rdx,%r8), %rax
addq $-0x641, %rax # imm = 0xF9BF
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x8, %rax
addq %rdx, %rax
imulq $0x190, %rax, %rax # imm = 0x190
subq %rax, %rsi
sarq $0x3f, %rsi
andq $-0x190, %rsi # imm = 0xFE70
addq %rax, %rsi
movq %rsi, %rax
imulq %r9
addq %rsi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x8, %rdx
addq %rax, %rdx
addq %rdx, %rcx
addq $-0xaf8ca, %rcx # imm = 0xFFF50736
testl %edi, %edi
jle 0x5b24e
xorl %eax, %eax
testb $0x3, %r8b
sete %al
movabsq $-0x70a3d70a3d70a3d7, %rdx # imm = 0x8F5C28F5C28F5C29
imulq %r8, %rdx
movabsq $0x51eb851eb851eb8, %rsi # imm = 0x51EB851EB851EB8
addq %rdx, %rsi
rorq $0x2, %rsi
movabsq $0x28f5c28f5c28f5d, %r8 # imm = 0x28F5C28F5C28F5D
cmpq %r8, %rsi
sbbl $0x0, %eax
movabsq $0x51eb851eb851eb0, %rsi # imm = 0x51EB851EB851EB0
addq %rdx, %rsi
rorq $0x4, %rsi
movabsq $0xa3d70a3d70a3d7, %rdx # imm = 0xA3D70A3D70A3D7
cmpq %rdx, %rsi
adcl $0x16d, %eax # imm = 0x16D
addq $-0x16d, %rax # imm = 0xFE93
movl %edi, %edx
shlq $0x2, %rdx
xorl %esi, %esi
leaq 0x4761e(%rip), %rdi # 0xa2840
movapd 0x10(%rsp), %xmm0
movslq (%rsi,%rdi), %r9
cmpq $0x4, %rsi
movl $0x0, %r8d
cmoveq %rax, %r8
addq %rcx, %r8
addq %r9, %r8
addq $0x4, %rsi
movq %r8, %rcx
cmpq %rsi, %rdx
jne 0x5b228
jmp 0x5b257
movq %rcx, %r8
movapd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r8, %xmm1
addsd %xmm1, %xmm0
addsd 0x4788d(%rip), %xmm0 # 0xa2af8
movsd 0x18(%r14), %xmm3
mulsd 0x47937(%rip), %xmm3 # 0xa2bb0
movupd 0x20(%r14), %xmm1
mulpd 0x47779(%rip), %xmm1 # 0xa2a00
addsd %xmm1, %xmm3
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
addsd %xmm3, %xmm2
addsd 0x30(%r14), %xmm2
movlpd %xmm1, 0x8(%rsp)
movhpd %xmm1, 0x8(%rsp)
mulsd 0x47907(%rip), %xmm0 # 0xa2bb8
movsd %xmm0, 0x8(%rsp)
addsd %xmm2, %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jg 0x5b3b3
testl %ebx, %ebx
je 0x5b38c
cvttsd2si %xmm0, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
ucomisd 0x47828(%rip), %xmm0 # 0xa2b30
movabsq $0x20c49ba5e353f7, %rax # imm = 0x20C49BA5E353F7
cmovbq %rdx, %rax
movsd 0x4780a(%rip), %xmm1 # 0xa2b28
ucomisd %xmm0, %xmm1
movabsq $-0x20c49ba5e353f7, %rcx # imm = 0xFFDF3B645A1CAC09
cmovbeq %rax, %rcx
leaq 0x38(%rsp), %rdi
movq %rcx, (%rdi)
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
movaps %xmm0, 0x10(%rsp)
callq 0xe0f0
movsd 0x4780e(%rip), %xmm4 # 0xa2b60
movapd 0x10(%rsp), %xmm0
movq 0x28(%rbx), %rcx
movabsq $0x7777777777777777, %rdx # imm = 0x7777777777777777
movq %rcx, %rax
imulq %rdx
subq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrl $0x5, %edx
addl %eax, %edx
imull $0xea60, %edx, %eax # imm = 0xEA60
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
movapd 0x4764c(%rip), %xmm2 # 0xa29e0
andpd %xmm0, %xmm2
movsd 0x477b8(%rip), %xmm1 # 0xa2b58
ucomisd %xmm2, %xmm1
jb 0x5b3b3
callq 0xe150
xorpd %xmm4, %xmm4
addsd %xmm0, %xmm4
movapd %xmm4, %xmm0
addq $0x78, %rsp
popq %rbx
popq %r14
retq
| set_date_fields:
push r14
push rbx
sub rsp, 78h
mov ebx, esi
mov r14, rdi
movsd xmm1, qword ptr [rdi+8]
movsd [rsp+88h+var_58], xmm1
movsd xmm0, qword ptr [rdi+10h]
movaps [rsp+88h+var_78], xmm0
movapd xmm0, xmm1
divsd xmm0, cs:qword_A2B98
call _floor
addsd xmm0, qword ptr [r14]
movsd [rsp+88h+var_60], xmm0
movsd xmm0, [rsp+88h+var_58]
movsd xmm1, cs:qword_A2B98
call _fmod
movsd xmm5, [rsp+88h+var_60]
movsd xmm1, cs:qword_A2BA0
ucomisd xmm1, xmm5
movsd xmm4, cs:qword_A2B60
ja loc_5B3B3
ucomisd xmm5, cs:qword_A2BA8
ja loc_5B3B3
movsd xmm1, cs:qword_A2B98
addsd xmm1, xmm0
xorpd xmm2, xmm2
movapd xmm3, xmm0
cmpltsd xmm3, xmm2
andpd xmm1, xmm3
andnpd xmm3, xmm0
orpd xmm3, xmm1
cvttsd2si eax, xmm5
cvttsd2si edi, xmm3
movsxd r8, eax
imul rax, r8, 16Dh
lea r10, [r8-7B1h]
sar r10, 2
add r10, rax
lea rsi, [r8-76Dh]
mov r9, 0A3D70A3D70A3D70Bh
mov rax, rsi
imul r9
lea rax, [rdx+r8]
add rax, 0FFFFFFFFFFFFF893h
mov rcx, rax
shr rcx, 3Fh
sar rax, 6
add rax, rcx
imul rax, 64h ; 'd'
sub rsi, rax
sar rsi, 3Fh
and rsi, 0FFFFFFFFFFFFFF9Ch
add rsi, rax
mov rcx, 5C28F5C28F5C28F5h
mov rax, rsi
imul rcx
mov rcx, rdx
sub rcx, rsi
mov rax, rcx
shr rax, 3Fh
sar rcx, 6
add rcx, rax
add rcx, r10
lea rsi, [r8-641h]
mov rax, rsi
imul r9
lea rax, [rdx+r8]
add rax, 0FFFFFFFFFFFFF9BFh
mov rdx, rax
shr rdx, 3Fh
sar rax, 8
add rax, rdx
imul rax, 190h
sub rsi, rax
sar rsi, 3Fh
and rsi, 0FFFFFFFFFFFFFE70h
add rsi, rax
mov rax, rsi
imul r9
add rdx, rsi
mov rax, rdx
shr rax, 3Fh
sar rdx, 8
add rdx, rax
add rcx, rdx
add rcx, 0FFFFFFFFFFF50736h
test edi, edi
jle loc_5B24E
xor eax, eax
test r8b, 3
setz al
mov rdx, 8F5C28F5C28F5C29h
imul rdx, r8
mov rsi, 51EB851EB851EB8h
add rsi, rdx
ror rsi, 2
mov r8, 28F5C28F5C28F5Dh
cmp rsi, r8
sbb eax, 0
mov rsi, 51EB851EB851EB0h
add rsi, rdx
ror rsi, 4
mov rdx, 0A3D70A3D70A3D7h
cmp rsi, rdx
adc eax, 16Dh
add rax, 0FFFFFFFFFFFFFE93h
mov edx, edi
shl rdx, 2
xor esi, esi
lea rdi, month_days
movapd xmm0, [rsp+88h+var_78]
loc_5B228:
movsxd r9, dword ptr [rsi+rdi]
cmp rsi, 4
mov r8d, 0
cmovz r8, rax
add r8, rcx
add r8, r9
add rsi, 4
mov rcx, r8
cmp rdx, rsi
jnz short loc_5B228
jmp short loc_5B257
loc_5B24E:
mov r8, rcx
movapd xmm0, [rsp+88h+var_78]
loc_5B257:
xorps xmm1, xmm1
cvtsi2sd xmm1, r8
addsd xmm0, xmm1
addsd xmm0, cs:qword_A2AF8
movsd xmm3, qword ptr [r14+18h]
mulsd xmm3, cs:qword_A2BB0
movupd xmm1, xmmword ptr [r14+20h]
mulpd xmm1, cs:xmmword_A2A00
addsd xmm3, xmm1
movapd xmm2, xmm1
unpckhpd xmm2, xmm1
addsd xmm2, xmm3
addsd xmm2, qword ptr [r14+30h]
movlpd [rsp+88h+var_80], xmm1
movhpd [rsp+88h+var_80], xmm1
mulsd xmm0, cs:qword_A2BB8
movsd [rsp+88h+var_80], xmm0
addsd xmm0, xmm2
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FEFFFFFFFFFFFFFh
cmp rax, rcx
jg loc_5B3B3
test ebx, ebx
jz loc_5B38C
cvttsd2si rax, xmm0
mov rcx, 20C49BA5E353F7CFh
imul rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 7
add rdx, rax
ucomisd xmm0, cs:qword_A2B30
mov rax, 20C49BA5E353F7h
cmovb rax, rdx
movsd xmm1, cs:qword_A2B28
ucomisd xmm1, xmm0
mov rcx, 0FFDF3B645A1CAC09h
cmovbe rcx, rax
lea rdi, [rsp+88h+var_50]
mov [rdi], rcx
lea rbx, [rsp+88h+var_48]
mov rsi, rbx
movaps [rsp+88h+var_78], xmm0
call _localtime_r
movsd xmm4, cs:qword_A2B60
movapd xmm0, [rsp+88h+var_78]
mov rcx, [rbx+28h]
mov rdx, 7777777777777777h
mov rax, rcx
imul rdx
sub rdx, rcx
mov rax, rdx
shr rax, 3Fh
shr edx, 5
add edx, eax
imul eax, edx, 0EA60h
xorps xmm1, xmm1
cvtsi2sd xmm1, eax
addsd xmm0, xmm1
loc_5B38C:
movapd xmm2, cs:xmmword_A29E0
andpd xmm2, xmm0
movsd xmm1, cs:qword_A2B58
ucomisd xmm1, xmm2
jb short loc_5B3B3
call _trunc
xorpd xmm4, xmm4
addsd xmm4, xmm0
loc_5B3B3:
movapd xmm0, xmm4
add rsp, 78h
pop rbx
pop r14
retn
| __int128 __usercall set_date_fields@<xmm0>(__m128d *a1@<rdi>, int a2@<esi>)
{
__m128d v4; // xmm0
__int128 v5; // xmm4
double v6; // xmm3_8
unsigned long long v7; // rdi
long long v8; // r8
unsigned long long v9; // rax
signed long long v10; // rax
unsigned long long v11; // rcx
unsigned long long v12; // rax
signed long long v13; // rsi
long long v14; // rdx
long long v15; // rcx
long long v16; // rax
double v17; // xmm0_8
long long v18; // r8
long long v19; // r8
__m128d v20; // xmm1
double v21; // xmm0_8
unsigned long long v22; // rax
unsigned long long v23; // rcx
double v24; // xmm0_8
double v26; // [rsp+10h] [rbp-78h]
double v27; // [rsp+28h] [rbp-60h]
double v28; // [rsp+30h] [rbp-58h]
unsigned long long v29; // [rsp+38h] [rbp-50h] BYREF
char v30; // [rsp+40h] [rbp-48h] BYREF
long long v31; // [rsp+68h] [rbp-20h]
v28 = a1->m128d_f64[1];
v26 = a1[1].m128d_f64[0];
v27 = floor(v28 / 12.0) + a1->m128d_f64[0];
v4 = (__m128d)*(unsigned long long *)&v28;
v4.m128d_f64[0] = fmod(v28, 12.0);
v5 = 0x7FF8000000000000uLL;
if ( v27 >= -271821.0 && v27 <= 275760.0 )
{
v6 = _mm_cmplt_sd(v4, (__m128d)0LL).m128d_f64[0];
v7 = (unsigned int)(int)COERCE_DOUBLE(~*(_QWORD *)&v6 & *(_QWORD *)&v4.m128d_f64[0] | COERCE_UNSIGNED_INT64(v4.m128d_f64[0] + 12.0) & *(_QWORD *)&v6);
v8 = (int)v27;
v9 = 100
* (((unsigned long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1901)) >> 64)
+ v8
- 1901) >> 63)
+ ((long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1901)) >> 64) + v8 - 1901) >> 6));
v10 = v9 + (((long long)(v8 - 1901 - v9) >> 63) & 0xFFFFFFFFFFFFFF9CLL);
v11 = 365 * v8
+ ((v8 - 1969) >> 2)
+ ((unsigned long long)(((unsigned __int128)(0x5C28F5C28F5C28F5LL * (__int128)v10) >> 64) - v10) >> 63)
+ ((long long)(((unsigned __int128)(0x5C28F5C28F5C28F5LL * (__int128)v10) >> 64) - v10) >> 6);
v12 = 400
* (((unsigned long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1601)) >> 64)
+ v8
- 1601) >> 63)
+ ((long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1601)) >> 64) + v8 - 1601) >> 8));
v13 = v12 + (((long long)(v8 - 1601 - v12) >> 63) & 0xFFFFFFFFFFFFFE70LL);
v14 = v13 / 400;
v15 = v13 / 400 + v11 - 719050;
if ( (int)v7 <= 0 )
{
LODWORD(v19) = v15;
v17 = v26;
}
else
{
v16 = (__ROR8__(0x8F5C28F5C28F5C29LL * v8 + 0x51EB851EB851EB0LL, 4) < 0xA3D70A3D70A3D7uLL)
+ ((v8 & 3) == 0)
- (unsigned int)(__ROR8__(0x8F5C28F5C28F5C29LL * v8 + 0x51EB851EB851EB8LL, 2) < 0x28F5C28F5C28F5DuLL)
+ 365
- 365LL;
v14 = 4LL * (unsigned int)v7;
v13 = 0LL;
v7 = (unsigned long long)&month_days;
v17 = v26;
do
{
v18 = 0LL;
if ( v13 == 4 )
v18 = v16;
v19 = *(int *)((char *)&month_days + v13) + v15 + v18;
v13 += 4LL;
v15 = v19;
}
while ( v14 != v13 );
}
v20 = _mm_mul_pd(a1[2], (__m128d)xmmword_A2A00);
v21 = (v17 + (double)(int)v19 + -1.0) * 86400000.0
+ _mm_unpackhi_pd(v20, v20).m128d_f64[0]
+ a1[1].m128d_f64[1] * 3600000.0
+ v20.m128d_f64[0]
+ a1[3].m128d_f64[0];
if ( COERCE__INT64(fabs(v21)) <= 0x7FEFFFFFFFFFFFFFLL )
{
if ( a2 )
{
v22 = 0x20C49BA5E353F7LL;
if ( v21 < 9.223372036854776e18 )
v22 = ((unsigned long long)((0x20C49BA5E353F7CFLL * (unsigned __int128)(unsigned int)(int)v21) >> 64) >> 63)
+ (unsigned int)(int)v21 / 1000LL;
v23 = 0xFFDF3B645A1CAC09LL;
if ( v21 >= -9.223372036854776e18 )
v23 = v22;
v7 = (unsigned long long)&v29;
v29 = v23;
v13 = (signed long long)&v30;
localtime_r(&v29, &v30);
v5 = 0x7FF8000000000000uLL;
v14 = ((unsigned long long)(((unsigned __int128)(0x7777777777777777LL * (__int128)v31) >> 64) - v31) >> 63)
+ (((unsigned int)((unsigned __int128)(0x7777777777777777LL * (__int128)v31) >> 64) - (unsigned int)v31) >> 5);
v21 = v21 + (double)(60000 * (int)v14);
}
if ( fabs(v21) <= 8.64e15 )
{
v24 = trunc(v7, v13, v14);
v5 = 0LL;
*(double *)&v5 = v24 + 0.0;
}
}
}
return v5;
}
| set_date_fields:
PUSH R14
PUSH RBX
SUB RSP,0x78
MOV EBX,ESI
MOV R14,RDI
MOVSD XMM1,qword ptr [RDI + 0x8]
MOVSD qword ptr [RSP + 0x30],XMM1
MOVSD XMM0,qword ptr [RDI + 0x10]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPD XMM0,XMM1
DIVSD XMM0,qword ptr [0x001a2b98]
CALL 0x0010e8d0
ADDSD XMM0,qword ptr [R14]
MOVSD qword ptr [RSP + 0x28],XMM0
MOVSD XMM0,qword ptr [RSP + 0x30]
MOVSD XMM1,qword ptr [0x001a2b98]
CALL 0x0010e420
MOVSD XMM5,qword ptr [RSP + 0x28]
MOVSD XMM1,qword ptr [0x001a2ba0]
UCOMISD XMM1,XMM5
MOVSD XMM4,qword ptr [0x001a2b60]
JA 0x0015b3b3
UCOMISD XMM5,qword ptr [0x001a2ba8]
JA 0x0015b3b3
MOVSD XMM1,qword ptr [0x001a2b98]
ADDSD XMM1,XMM0
XORPD XMM2,XMM2
MOVAPD XMM3,XMM0
CMPLTSD XMM3,XMM2
ANDPD XMM1,XMM3
ANDNPD XMM3,XMM0
ORPD XMM3,XMM1
CVTTSD2SI EAX,XMM5
CVTTSD2SI EDI,XMM3
MOVSXD R8,EAX
IMUL RAX,R8,0x16d
LEA R10,[R8 + -0x7b1]
SAR R10,0x2
ADD R10,RAX
LEA RSI,[R8 + -0x76d]
MOV R9,-0x5c28f5c28f5c28f5
MOV RAX,RSI
IMUL R9
LEA RAX,[RDX + R8*0x1]
ADD RAX,-0x76d
MOV RCX,RAX
SHR RCX,0x3f
SAR RAX,0x6
ADD RAX,RCX
IMUL RAX,RAX,0x64
SUB RSI,RAX
SAR RSI,0x3f
AND RSI,-0x64
ADD RSI,RAX
MOV RCX,0x5c28f5c28f5c28f5
MOV RAX,RSI
IMUL RCX
MOV RCX,RDX
SUB RCX,RSI
MOV RAX,RCX
SHR RAX,0x3f
SAR RCX,0x6
ADD RCX,RAX
ADD RCX,R10
LEA RSI,[R8 + -0x641]
MOV RAX,RSI
IMUL R9
LEA RAX,[RDX + R8*0x1]
ADD RAX,-0x641
MOV RDX,RAX
SHR RDX,0x3f
SAR RAX,0x8
ADD RAX,RDX
IMUL RAX,RAX,0x190
SUB RSI,RAX
SAR RSI,0x3f
AND RSI,-0x190
ADD RSI,RAX
MOV RAX,RSI
IMUL R9
ADD RDX,RSI
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x8
ADD RDX,RAX
ADD RCX,RDX
ADD RCX,-0xaf8ca
TEST EDI,EDI
JLE 0x0015b24e
XOR EAX,EAX
TEST R8B,0x3
SETZ AL
MOV RDX,-0x70a3d70a3d70a3d7
IMUL RDX,R8
MOV RSI,0x51eb851eb851eb8
ADD RSI,RDX
ROR RSI,0x2
MOV R8,0x28f5c28f5c28f5d
CMP RSI,R8
SBB EAX,0x0
MOV RSI,0x51eb851eb851eb0
ADD RSI,RDX
ROR RSI,0x4
MOV RDX,0xa3d70a3d70a3d7
CMP RSI,RDX
ADC EAX,0x16d
ADD RAX,-0x16d
MOV EDX,EDI
SHL RDX,0x2
XOR ESI,ESI
LEA RDI,[0x1a2840]
MOVAPD XMM0,xmmword ptr [RSP + 0x10]
LAB_0015b228:
MOVSXD R9,dword ptr [RSI + RDI*0x1]
CMP RSI,0x4
MOV R8D,0x0
CMOVZ R8,RAX
ADD R8,RCX
ADD R8,R9
ADD RSI,0x4
MOV RCX,R8
CMP RDX,RSI
JNZ 0x0015b228
JMP 0x0015b257
LAB_0015b24e:
MOV R8,RCX
MOVAPD XMM0,xmmword ptr [RSP + 0x10]
LAB_0015b257:
XORPS XMM1,XMM1
CVTSI2SD XMM1,R8
ADDSD XMM0,XMM1
ADDSD XMM0,qword ptr [0x001a2af8]
MOVSD XMM3,qword ptr [R14 + 0x18]
MULSD XMM3,qword ptr [0x001a2bb0]
MOVUPD XMM1,xmmword ptr [R14 + 0x20]
MULPD XMM1,xmmword ptr [0x001a2a00]
ADDSD XMM3,XMM1
MOVAPD XMM2,XMM1
UNPCKHPD XMM2,XMM1
ADDSD XMM2,XMM3
ADDSD XMM2,qword ptr [R14 + 0x30]
MOVLPD qword ptr [RSP + 0x8],XMM1
MOVHPD qword ptr [RSP + 0x8],XMM1
MULSD XMM0,qword ptr [0x001a2bb8]
MOVSD qword ptr [RSP + 0x8],XMM0
ADDSD XMM0,XMM2
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7fefffffffffffff
CMP RAX,RCX
JG 0x0015b3b3
TEST EBX,EBX
JZ 0x0015b38c
CVTTSD2SI RAX,XMM0
MOV RCX,0x20c49ba5e353f7cf
IMUL RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x7
ADD RDX,RAX
UCOMISD XMM0,qword ptr [0x001a2b30]
MOV RAX,0x20c49ba5e353f7
CMOVC RAX,RDX
MOVSD XMM1,qword ptr [0x001a2b28]
UCOMISD XMM1,XMM0
MOV RCX,-0x20c49ba5e353f7
CMOVBE RCX,RAX
LEA RDI,[RSP + 0x38]
MOV qword ptr [RDI],RCX
LEA RBX,[RSP + 0x40]
MOV RSI,RBX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
CALL 0x0010e0f0
MOVSD XMM4,qword ptr [0x001a2b60]
MOVAPD XMM0,xmmword ptr [RSP + 0x10]
MOV RCX,qword ptr [RBX + 0x28]
MOV RDX,0x7777777777777777
MOV RAX,RCX
IMUL RDX
SUB RDX,RCX
MOV RAX,RDX
SHR RAX,0x3f
SHR EDX,0x5
ADD EDX,EAX
IMUL EAX,EDX,0xea60
XORPS XMM1,XMM1
CVTSI2SD XMM1,EAX
ADDSD XMM0,XMM1
LAB_0015b38c:
MOVAPD XMM2,xmmword ptr [0x001a29e0]
ANDPD XMM2,XMM0
MOVSD XMM1,qword ptr [0x001a2b58]
UCOMISD XMM1,XMM2
JC 0x0015b3b3
CALL 0x0010e150
XORPD XMM4,XMM4
ADDSD XMM4,XMM0
LAB_0015b3b3:
MOVAPD XMM0,XMM4
ADD RSP,0x78
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double set_date_fields(double *param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
uint uVar4;
ulong uVar5;
long lVar6;
double dVar7;
double dVar8;
double dVar9;
double dVar10;
long local_50;
tm local_48;
dVar10 = param_1[1];
dVar9 = param_1[2];
dVar7 = floor(dVar10 / DAT_001a2b98);
dVar7 = dVar7 + *param_1;
dVar8 = fmod(dVar10,DAT_001a2b98);
dVar10 = DAT_001a2b60;
if ((DAT_001a2ba0 <= dVar7) && (dVar7 <= _DAT_001a2ba8)) {
uVar4 = (uint)(double)(~-(ulong)(dVar8 < 0.0) & (ulong)dVar8 |
(ulong)(DAT_001a2b98 + dVar8) & -(ulong)(dVar8 < 0.0));
uVar5 = (ulong)(int)dVar7;
lVar1 = SUB168(SEXT816((long)(uVar5 - 0x76d)) * SEXT816(-0x5c28f5c28f5c28f5),8) + uVar5 + -0x76d
;
lVar1 = (lVar1 >> 6) - (lVar1 >> 0x3f);
lVar2 = ((long)((uVar5 - 0x76d) + lVar1 * -100) >> 0x3f & 0xffffffffffffff9cU) + lVar1 * 100;
lVar2 = SUB168(SEXT816(lVar2) * SEXT816(0x5c28f5c28f5c28f5),8) - lVar2;
lVar1 = SUB168(SEXT816((long)(uVar5 - 0x641)) * SEXT816(-0x5c28f5c28f5c28f5),8) + uVar5 + -0x641
;
lVar1 = (lVar1 >> 8) - (lVar1 >> 0x3f);
lVar1 = ((lVar2 >> 6) - (lVar2 >> 0x3f)) + ((long)(uVar5 - 0x7b1) >> 2) + uVar5 * 0x16d +
(long)(((long)((uVar5 - 0x641) + lVar1 * -400) >> 0x3f & 0xfffffffffffffe70U) +
lVar1 * 400) / 400 + -0xaf8ca;
if (0 < (int)uVar4) {
lVar2 = uVar5 * -0x70a3d70a3d70a3d7;
lVar3 = 0;
do {
lVar6 = 0;
if (lVar3 == 4) {
lVar6 = (ulong)(((uint)((uVar5 & 3) == 0) -
(uint)((lVar2 + 0x51eb851eb851eb8U >> 2 | lVar2 << 0x3e) <
0x28f5c28f5c28f5d)) + 0x16d +
(uint)((lVar2 + 0x51eb851eb851eb0U >> 4 | lVar2 << 0x3c) < 0xa3d70a3d70a3d7
)) - 0x16d;
}
lVar1 = lVar6 + lVar1 + (long)*(int *)((long)&month_days + lVar3);
lVar3 = lVar3 + 4;
} while ((ulong)uVar4 << 2 != lVar3);
}
dVar9 = (dVar9 + (double)lVar1 + _DAT_001a2af8) * _DAT_001a2bb8 +
param_1[5] * _UNK_001a2a08 + param_1[3] * _DAT_001a2bb0 + param_1[4] * _DAT_001a2a00 +
param_1[6];
if ((long)ABS(dVar9) < 0x7ff0000000000000) {
if (param_2 != 0) {
lVar1 = 0x20c49ba5e353f7;
if (dVar9 < DAT_001a2b30) {
lVar1 = (long)dVar9 / 1000;
}
local_50 = -0x20c49ba5e353f7;
if (DAT_001a2b28 <= dVar9) {
local_50 = lVar1;
}
localtime_r(&local_50,&local_48);
uVar5 = SUB168(SEXT816(local_48.tm_gmtoff) * SEXT816(0x7777777777777777),8) -
local_48.tm_gmtoff;
dVar9 = dVar9 + (double)(int)((((uint)(uVar5 >> 5) & 0x7ffffff) - (int)((long)uVar5 >> 0x3f)
) * 60000);
}
dVar10 = DAT_001a2b60;
if ((double)(_DAT_001a29e0 & (ulong)dVar9) <= DAT_001a2b58) {
dVar10 = trunc(dVar9);
dVar10 = dVar10 + 0.0;
}
}
}
return dVar10;
}
| |
25,978 | set_date_fields | bluesky950520[P]quickjs/quickjs.c | static double set_date_fields(double fields[minimum_length(7)], int is_local) {
double y, m, dt, ym, mn, day, h, s, milli, time, tv;
int yi, mi, i;
int64_t days;
volatile double temp; /* enforce evaluation order */
/* emulate 21.4.1.15 MakeDay ( year, month, date ) */
y = fields[0];
m = fields[1];
dt = fields[2];
ym = y + floor(m / 12);
mn = fmod(m, 12);
if (mn < 0)
mn += 12;
if (ym < -271821 || ym > 275760)
return NAN;
yi = ym;
mi = mn;
days = days_from_year(yi);
for(i = 0; i < mi; i++) {
days += month_days[i];
if (i == 1)
days += days_in_year(yi) - 365;
}
day = days + dt - 1;
/* emulate 21.4.1.14 MakeTime ( hour, min, sec, ms ) */
h = fields[3];
m = fields[4];
s = fields[5];
milli = fields[6];
/* Use a volatile intermediary variable to ensure order of evaluation
* as specified in ECMA. This fixes a test262 error on
* test262/test/built-ins/Date/UTC/fp-evaluation-order.js.
* Without the volatile qualifier, the compile can generate code
* that performs the computation in a different order or with instructions
* that produce a different result such as FMA (float multiply and add).
*/
time = h * 3600000;
time += (temp = m * 60000);
time += (temp = s * 1000);
time += milli;
/* emulate 21.4.1.16 MakeDate ( day, time ) */
tv = (temp = day * 86400000) + time; /* prevent generation of FMA */
if (!isfinite(tv))
return NAN;
/* adjust for local time and clip */
if (is_local) {
int64_t ti = tv < INT64_MIN ? INT64_MIN : tv >= 0x1p63 ? INT64_MAX : (int64_t)tv;
tv += getTimezoneOffset(ti) * 60000;
}
return time_clip(tv);
} | O2 | c | set_date_fields:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movsd 0x8(%rdi), %xmm1
movsd %xmm1, (%rsp)
movsd 0x10(%rdi), %xmm0
movaps %xmm0, 0x10(%rsp)
movapd %xmm1, %xmm0
divsd 0x3a73f(%rip), %xmm0 # 0x88ae8
callq 0xe8f0
addsd (%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd (%rsp), %xmm0
movsd 0x3a722(%rip), %xmm1 # 0x88ae8
callq 0xe430
movsd 0x20(%rsp), %xmm4
movsd 0x3a717(%rip), %xmm1 # 0x88af0
ucomisd %xmm4, %xmm1
movsd 0x3a65b(%rip), %xmm1 # 0x88a40
ja 0x4e5a0
ucomisd 0x3a705(%rip), %xmm4 # 0x88af8
ja 0x4e5a0
movl %ebx, (%rsp)
movsd 0x3a6e4(%rip), %xmm1 # 0x88ae8
addsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
cvttsd2si %xmm4, %eax
orpd %xmm1, %xmm3
cvttsd2si %xmm3, %r13d
movslq %eax, %r15
movq %r15, %rdi
callq 0x4e298
movq %rax, %r12
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
shlq $0x2, %r13
leaq 0x3a394(%rip), %rbx # 0x887e0
cmpq %rbp, %r13
je 0x4e477
movslq (%rbp,%rbx), %rax
addq %rax, %r12
cmpq $0x4, %rbp
jne 0x4e471
movq %r15, %rdi
callq 0x4e260
addq %rax, %r12
addq $-0x16d, %r12 # imm = 0xFE93
addq $0x4, %rbp
jmp 0x4e44c
cvtsi2sd %r12, %xmm0
movapd 0x10(%rsp), %xmm3
addsd %xmm0, %xmm3
addsd 0x3a63a(%rip), %xmm3 # 0x88ac8
movsd 0x18(%r14), %xmm0
mulsd 0x3a664(%rip), %xmm0 # 0x88b00
movupd 0x20(%r14), %xmm1
mulpd 0x3a4f6(%rip), %xmm1 # 0x889a0
addsd %xmm1, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
addsd %xmm0, %xmm2
addsd 0x30(%r14), %xmm2
movlpd %xmm1, 0x8(%rsp)
movhpd %xmm1, 0x8(%rsp)
mulsd 0x3a634(%rip), %xmm3 # 0x88b08
movsd %xmm3, 0x8(%rsp)
addsd %xmm2, %xmm3
movq %xmm3, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x4e504
movsd 0x3a541(%rip), %xmm1 # 0x88a40
jmp 0x4e5a0
movapd %xmm3, %xmm0
cmpl $0x0, (%rsp)
je 0x4e571
movapd %xmm0, %xmm1
movapd %xmm0, 0x10(%rsp)
ucomisd 0x3a540(%rip), %xmm0 # 0x88a60
cvttsd2si %xmm0, %rax
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
cmovaeq %rdi, %rax
incq %rdi
movsd 0x3a51a(%rip), %xmm0 # 0x88a58
ucomisd %xmm1, %xmm0
cmovbeq %rax, %rdi
callq 0x4e229
imull $0xea60, %eax, %eax # imm = 0xEA60
cvtsi2sd %eax, %xmm0
movapd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd 0x3a409(%rip), %xmm2 # 0x88970
movapd %xmm1, %xmm0
andpd %xmm1, %xmm2
jmp 0x4e57d
movapd 0x3a3f7(%rip), %xmm2 # 0x88970
andpd %xmm0, %xmm2
movsd 0x3a503(%rip), %xmm1 # 0x88a88
ucomisd %xmm2, %xmm1
movsd 0x3a4af(%rip), %xmm1 # 0x88a40
jb 0x4e5a0
callq 0xe160
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| set_date_fields:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebx, esi
mov r14, rdi
movsd xmm1, qword ptr [rdi+8]
movsd [rsp+58h+var_58], xmm1
movsd xmm0, qword ptr [rdi+10h]
movaps [rsp+58h+var_48], xmm0
movapd xmm0, xmm1
divsd xmm0, cs:qword_88AE8
call _floor
addsd xmm0, qword ptr [r14]
movsd [rsp+58h+var_38], xmm0
movsd xmm0, [rsp+58h+var_58]
movsd xmm1, cs:qword_88AE8
call _fmod
movsd xmm4, [rsp+58h+var_38]
movsd xmm1, cs:qword_88AF0
ucomisd xmm1, xmm4
movsd xmm1, cs:qword_88A40
ja loc_4E5A0
ucomisd xmm4, cs:qword_88AF8
ja loc_4E5A0
mov dword ptr [rsp+58h+var_58], ebx
movsd xmm1, cs:qword_88AE8
addsd xmm1, xmm0
xorpd xmm2, xmm2
movapd xmm3, xmm0
cmpltsd xmm3, xmm2
andpd xmm1, xmm3
andnpd xmm3, xmm0
cvttsd2si eax, xmm4
orpd xmm3, xmm1
cvttsd2si r13d, xmm3
movsxd r15, eax
mov rdi, r15
call days_from_year
mov r12, rax
xor ebp, ebp
test r13d, r13d
cmovle r13d, ebp
shl r13, 2
lea rbx, month_days
loc_4E44C:
cmp r13, rbp
jz short loc_4E477
movsxd rax, dword ptr [rbp+rbx+0]
add r12, rax
cmp rbp, 4
jnz short loc_4E471
mov rdi, r15
call days_in_year
add r12, rax
add r12, 0FFFFFFFFFFFFFE93h
loc_4E471:
add rbp, 4
jmp short loc_4E44C
loc_4E477:
cvtsi2sd xmm0, r12
movapd xmm3, [rsp+58h+var_48]
addsd xmm3, xmm0
addsd xmm3, cs:qword_88AC8
movsd xmm0, qword ptr [r14+18h]
mulsd xmm0, cs:qword_88B00
movupd xmm1, xmmword ptr [r14+20h]
mulpd xmm1, cs:xmmword_889A0
addsd xmm0, xmm1
movapd xmm2, xmm1
unpckhpd xmm2, xmm1
addsd xmm2, xmm0
addsd xmm2, qword ptr [r14+30h]
movlpd [rsp+58h+var_50], xmm1
movhpd [rsp+58h+var_50], xmm1
mulsd xmm3, cs:qword_88B08
movsd [rsp+58h+var_50], xmm3
addsd xmm3, xmm2
movq rax, xmm3
btr rax, 3Fh ; '?'
mov rcx, 7FEFFFFFFFFFFFFFh
cmp rax, rcx
jle short loc_4E504
movsd xmm1, cs:qword_88A40
jmp loc_4E5A0
loc_4E504:
movapd xmm0, xmm3
cmp dword ptr [rsp+58h+var_58], 0
jz short loc_4E571
movapd xmm1, xmm0
movapd [rsp+58h+var_48], xmm0
ucomisd xmm0, cs:qword_88A60
cvttsd2si rax, xmm0
mov rdi, 7FFFFFFFFFFFFFFFh
cmovnb rax, rdi
inc rdi
movsd xmm0, cs:qword_88A58
ucomisd xmm0, xmm1
cmovbe rdi, rax
call getTimezoneOffset
imul eax, 0EA60h
cvtsi2sd xmm0, eax
movapd xmm1, [rsp+58h+var_48]
addsd xmm1, xmm0
movapd xmm2, cs:xmmword_88970
movapd xmm0, xmm1
andpd xmm2, xmm1
jmp short loc_4E57D
loc_4E571:
movapd xmm2, cs:xmmword_88970
andpd xmm2, xmm0
loc_4E57D:
movsd xmm1, cs:qword_88A88
ucomisd xmm1, xmm2
movsd xmm1, cs:qword_88A40
jb short loc_4E5A0
call _trunc
xorpd xmm1, xmm1
addsd xmm1, xmm0
loc_4E5A0:
movapd xmm0, xmm1
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| __int128 __usercall set_date_fields@<xmm0>(__m128d *a1@<rdi>, int a2@<esi>)
{
__m128d v2; // xmm0
__int128 v3; // xmm1
double v4; // xmm3_8
long long v5; // r13
long long v6; // r12
long long v7; // rbp
long long v8; // r13
__m128d v9; // xmm1
double v10; // xmm3_8
double v11; // xmm0_8
long long v12; // rax
long long v13; // rdi
double v14; // xmm2_8
double v16; // [rsp+0h] [rbp-58h]
double v17; // [rsp+10h] [rbp-48h]
double v18; // [rsp+20h] [rbp-38h]
v16 = a1->m128d_f64[1];
v17 = a1[1].m128d_f64[0];
v18 = floor(v16 / 12.0) + a1->m128d_f64[0];
v2 = (__m128d)*(unsigned long long *)&v16;
v2.m128d_f64[0] = fmod(v16, 12.0);
v3 = 0x7FF8000000000000uLL;
if ( v18 >= -271821.0 && v18 <= 275760.0 )
{
v4 = _mm_cmplt_sd(v2, (__m128d)0LL).m128d_f64[0];
v5 = (unsigned int)(int)COERCE_DOUBLE(~*(_QWORD *)&v4 & *(_QWORD *)&v2.m128d_f64[0] | COERCE_UNSIGNED_INT64(v2.m128d_f64[0] + 12.0) & *(_QWORD *)&v4);
v6 = days_from_year((int)v18);
v7 = 0LL;
if ( (int)v5 <= 0 )
v5 = 0LL;
v8 = 4 * v5;
while ( v8 != v7 )
{
v6 += *(int *)((char *)&month_days + v7);
if ( v7 == 4 )
v6 = days_in_year((int)v18) + v6 - 365;
v7 += 4LL;
}
v9 = _mm_mul_pd(a1[2], (__m128d)xmmword_889A0);
v10 = (v17 + (double)(int)v6 + -1.0) * 86400000.0
+ _mm_unpackhi_pd(v9, v9).m128d_f64[0]
+ a1[1].m128d_f64[1] * 3600000.0
+ v9.m128d_f64[0]
+ a1[3].m128d_f64[0];
if ( COERCE__INT64(fabs(v10)) <= 0x7FEFFFFFFFFFFFFFLL )
{
v11 = v10;
if ( a2 )
{
v12 = (unsigned int)(int)v10;
if ( v10 >= 9.223372036854776e18 )
v12 = 0x7FFFFFFFFFFFFFFFLL;
v13 = 0x8000000000000000LL;
if ( v10 >= -9.223372036854776e18 )
v13 = v12;
v11 = v10 + (double)(int)(60000 * getTimezoneOffset(v13));
v14 = fabs(v11);
}
else
{
v14 = fabs(v10);
}
v3 = 0x7FF8000000000000uLL;
if ( v14 <= 8.64e15 )
{
v3 = 0LL;
*(double *)&v3 = trunc(v11) + 0.0;
}
}
else
{
return 0x7FF8000000000000uLL;
}
}
return v3;
}
| set_date_fields:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBX,ESI
MOV R14,RDI
MOVSD XMM1,qword ptr [RDI + 0x8]
MOVSD qword ptr [RSP],XMM1
MOVSD XMM0,qword ptr [RDI + 0x10]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPD XMM0,XMM1
DIVSD XMM0,qword ptr [0x00188ae8]
CALL 0x0010e8f0
ADDSD XMM0,qword ptr [R14]
MOVSD qword ptr [RSP + 0x20],XMM0
MOVSD XMM0,qword ptr [RSP]
MOVSD XMM1,qword ptr [0x00188ae8]
CALL 0x0010e430
MOVSD XMM4,qword ptr [RSP + 0x20]
MOVSD XMM1,qword ptr [0x00188af0]
UCOMISD XMM1,XMM4
MOVSD XMM1,qword ptr [0x00188a40]
JA 0x0014e5a0
UCOMISD XMM4,qword ptr [0x00188af8]
JA 0x0014e5a0
MOV dword ptr [RSP],EBX
MOVSD XMM1,qword ptr [0x00188ae8]
ADDSD XMM1,XMM0
XORPD XMM2,XMM2
MOVAPD XMM3,XMM0
CMPLTSD XMM3,XMM2
ANDPD XMM1,XMM3
ANDNPD XMM3,XMM0
CVTTSD2SI EAX,XMM4
ORPD XMM3,XMM1
CVTTSD2SI R13D,XMM3
MOVSXD R15,EAX
MOV RDI,R15
CALL 0x0014e298
MOV R12,RAX
XOR EBP,EBP
TEST R13D,R13D
CMOVLE R13D,EBP
SHL R13,0x2
LEA RBX,[0x1887e0]
LAB_0014e44c:
CMP R13,RBP
JZ 0x0014e477
MOVSXD RAX,dword ptr [RBP + RBX*0x1]
ADD R12,RAX
CMP RBP,0x4
JNZ 0x0014e471
MOV RDI,R15
CALL 0x0014e260
ADD R12,RAX
ADD R12,-0x16d
LAB_0014e471:
ADD RBP,0x4
JMP 0x0014e44c
LAB_0014e477:
CVTSI2SD XMM0,R12
MOVAPD XMM3,xmmword ptr [RSP + 0x10]
ADDSD XMM3,XMM0
ADDSD XMM3,qword ptr [0x00188ac8]
MOVSD XMM0,qword ptr [R14 + 0x18]
MULSD XMM0,qword ptr [0x00188b00]
MOVUPD XMM1,xmmword ptr [R14 + 0x20]
MULPD XMM1,xmmword ptr [0x001889a0]
ADDSD XMM0,XMM1
MOVAPD XMM2,XMM1
UNPCKHPD XMM2,XMM1
ADDSD XMM2,XMM0
ADDSD XMM2,qword ptr [R14 + 0x30]
MOVLPD qword ptr [RSP + 0x8],XMM1
MOVHPD qword ptr [RSP + 0x8],XMM1
MULSD XMM3,qword ptr [0x00188b08]
MOVSD qword ptr [RSP + 0x8],XMM3
ADDSD XMM3,XMM2
MOVQ RAX,XMM3
BTR RAX,0x3f
MOV RCX,0x7fefffffffffffff
CMP RAX,RCX
JLE 0x0014e504
MOVSD XMM1,qword ptr [0x00188a40]
JMP 0x0014e5a0
LAB_0014e504:
MOVAPD XMM0,XMM3
CMP dword ptr [RSP],0x0
JZ 0x0014e571
MOVAPD XMM1,XMM0
MOVAPD xmmword ptr [RSP + 0x10],XMM0
UCOMISD XMM0,qword ptr [0x00188a60]
CVTTSD2SI RAX,XMM0
MOV RDI,0x7fffffffffffffff
CMOVNC RAX,RDI
INC RDI
MOVSD XMM0,qword ptr [0x00188a58]
UCOMISD XMM0,XMM1
CMOVBE RDI,RAX
CALL 0x0014e229
IMUL EAX,EAX,0xea60
CVTSI2SD XMM0,EAX
MOVAPD XMM1,xmmword ptr [RSP + 0x10]
ADDSD XMM1,XMM0
MOVAPD XMM2,xmmword ptr [0x00188970]
MOVAPD XMM0,XMM1
ANDPD XMM2,XMM1
JMP 0x0014e57d
LAB_0014e571:
MOVAPD XMM2,xmmword ptr [0x00188970]
ANDPD XMM2,XMM0
LAB_0014e57d:
MOVSD XMM1,qword ptr [0x00188a88]
UCOMISD XMM1,XMM2
MOVSD XMM1,qword ptr [0x00188a40]
JC 0x0014e5a0
CALL 0x0010e160
XORPD XMM1,XMM1
ADDSD XMM1,XMM0
LAB_0014e5a0:
MOVAPD XMM0,XMM1
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double set_date_fields(double *param_1,int param_2)
{
int iVar1;
long lVar2;
long lVar3;
ulong uVar4;
uint uVar5;
ulong uVar6;
double dVar7;
double dVar8;
double dVar9;
double dVar10;
dVar9 = param_1[1];
dVar10 = param_1[2];
dVar7 = floor(dVar9 / DAT_00188ae8);
dVar7 = dVar7 + *param_1;
dVar8 = fmod(dVar9,DAT_00188ae8);
dVar9 = DAT_00188a40;
if ((DAT_00188af0 <= dVar7) && (dVar7 <= _DAT_00188af8)) {
uVar5 = (uint)(double)(~-(ulong)(dVar8 < 0.0) & (ulong)dVar8 |
(ulong)(DAT_00188ae8 + dVar8) & -(ulong)(dVar8 < 0.0));
lVar2 = days_from_year((long)(int)dVar7);
uVar4 = 0;
uVar6 = (ulong)uVar5;
if ((int)uVar5 < 1) {
uVar6 = uVar4;
}
for (; uVar6 * 4 != uVar4; uVar4 = uVar4 + 4) {
lVar2 = lVar2 + *(int *)((long)&month_days + uVar4);
if (uVar4 == 4) {
lVar3 = days_in_year((long)(int)dVar7);
lVar2 = lVar2 + lVar3 + -0x16d;
}
}
dVar10 = (dVar10 + (double)lVar2 + _DAT_00188ac8) * _DAT_00188b08 +
param_1[5] * _UNK_001889a8 + param_1[3] * _DAT_00188b00 + param_1[4] * _DAT_001889a0 +
param_1[6];
dVar9 = DAT_00188a40;
if ((long)ABS(dVar10) < 0x7ff0000000000000) {
if (param_2 == 0) {
dVar7 = (double)(_DAT_00188970 & (ulong)dVar10);
}
else {
lVar2 = (long)dVar10;
if (DAT_00188a60 <= dVar10) {
lVar2 = 0x7fffffffffffffff;
}
lVar3 = -0x8000000000000000;
if (DAT_00188a58 <= dVar10) {
lVar3 = lVar2;
}
iVar1 = getTimezoneOffset(lVar3);
dVar10 = dVar10 + (double)(iVar1 * 60000);
dVar7 = (double)(_DAT_00188970 & (ulong)dVar10);
}
dVar9 = DAT_00188a40;
if (dVar7 <= DAT_00188a88) {
dVar9 = trunc(dVar10);
dVar9 = dVar9 + 0.0;
}
}
}
return dVar9;
}
| |
25,979 | set_date_fields | bluesky950520[P]quickjs/quickjs.c | static double set_date_fields(double fields[minimum_length(7)], int is_local) {
double y, m, dt, ym, mn, day, h, s, milli, time, tv;
int yi, mi, i;
int64_t days;
volatile double temp; /* enforce evaluation order */
/* emulate 21.4.1.15 MakeDay ( year, month, date ) */
y = fields[0];
m = fields[1];
dt = fields[2];
ym = y + floor(m / 12);
mn = fmod(m, 12);
if (mn < 0)
mn += 12;
if (ym < -271821 || ym > 275760)
return NAN;
yi = ym;
mi = mn;
days = days_from_year(yi);
for(i = 0; i < mi; i++) {
days += month_days[i];
if (i == 1)
days += days_in_year(yi) - 365;
}
day = days + dt - 1;
/* emulate 21.4.1.14 MakeTime ( hour, min, sec, ms ) */
h = fields[3];
m = fields[4];
s = fields[5];
milli = fields[6];
/* Use a volatile intermediary variable to ensure order of evaluation
* as specified in ECMA. This fixes a test262 error on
* test262/test/built-ins/Date/UTC/fp-evaluation-order.js.
* Without the volatile qualifier, the compile can generate code
* that performs the computation in a different order or with instructions
* that produce a different result such as FMA (float multiply and add).
*/
time = h * 3600000;
time += (temp = m * 60000);
time += (temp = s * 1000);
time += milli;
/* emulate 21.4.1.16 MakeDate ( day, time ) */
tv = (temp = day * 86400000) + time; /* prevent generation of FMA */
if (!isfinite(tv))
return NAN;
/* adjust for local time and clip */
if (is_local) {
int64_t ti = tv < INT64_MIN ? INT64_MIN : tv >= 0x1p63 ? INT64_MAX : (int64_t)tv;
tv += getTimezoneOffset(ti) * 60000;
}
return time_clip(tv);
} | O3 | c | set_date_fields:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
movq %rdi, %r14
movsd 0x8(%rdi), %xmm1
movsd %xmm1, 0x30(%rsp)
movsd 0x10(%rdi), %xmm0
movaps %xmm0, 0x10(%rsp)
movapd %xmm1, %xmm0
divsd 0x4797e(%rip), %xmm0 # 0xa5b28
callq 0xe8d0
addsd (%r14), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x47960(%rip), %xmm1 # 0xa5b28
callq 0xe420
movsd 0x28(%rsp), %xmm5
movsd 0x47955(%rip), %xmm1 # 0xa5b30
ucomisd %xmm5, %xmm1
movsd 0x47909(%rip), %xmm4 # 0xa5af0
ja 0x5e4e9
ucomisd 0x47943(%rip), %xmm5 # 0xa5b38
ja 0x5e4e9
movsd 0x47925(%rip), %xmm1 # 0xa5b28
addsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
cvttsd2si %xmm5, %eax
cvttsd2si %xmm3, %edi
movslq %eax, %r8
imulq $0x16d, %r8, %rax # imm = 0x16D
leaq -0x7b1(%r8), %r10
sarq $0x2, %r10
addq %rax, %r10
leaq -0x76d(%r8), %rsi
movabsq $-0x5c28f5c28f5c28f5, %r9 # imm = 0xA3D70A3D70A3D70B
movq %rsi, %rax
imulq %r9
leaq (%rdx,%r8), %rax
addq $-0x76d, %rax # imm = 0xF893
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x6, %rax
addq %rcx, %rax
imulq $0x64, %rax, %rax
subq %rax, %rsi
sarq $0x3f, %rsi
andq $-0x64, %rsi
addq %rax, %rsi
movabsq $0x5c28f5c28f5c28f5, %rcx # imm = 0x5C28F5C28F5C28F5
movq %rsi, %rax
imulq %rcx
movq %rdx, %rcx
subq %rsi, %rcx
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x6, %rcx
addq %rax, %rcx
addq %r10, %rcx
leaq -0x641(%r8), %rsi
movq %rsi, %rax
imulq %r9
leaq (%rdx,%r8), %rax
addq $-0x641, %rax # imm = 0xF9BF
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x8, %rax
addq %rdx, %rax
imulq $0x190, %rax, %rax # imm = 0x190
subq %rax, %rsi
sarq $0x3f, %rsi
andq $-0x190, %rsi # imm = 0xFE70
addq %rax, %rsi
movq %rsi, %rax
imulq %r9
addq %rsi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x8, %rdx
addq %rax, %rdx
leaq (%rcx,%rdx), %rax
addq $-0xaf8ca, %rax # imm = 0xFFF50736
testl %edi, %edi
jle 0x5e384
xorl %edx, %edx
testb $0x3, %r8b
sete %dl
imull $0xc28f5c29, %r8d, %esi # imm = 0xC28F5C29
addl $0x51eb850, %esi # imm = 0x51EB850
movl %esi, %ecx
rorl $0x2, %ecx
rorl $0x4, %esi
cmpl $0x28f5c29, %ecx # imm = 0x28F5C29
movq $-0x16d, %rcx # imm = 0xFE93
sbbq $0x0, %rcx
cmpl $0xa3d70b, %esi # imm = 0xA3D70B
adcq %rdx, %rcx
addq $0x16d, %rcx # imm = 0x16D
movl %edi, %edx
shlq $0x2, %rdx
xorl %esi, %esi
leaq 0x47438(%rip), %rdi # 0xa5790
movapd 0x10(%rsp), %xmm0
movslq (%rsi,%rdi), %r9
cmpq $0x4, %rsi
movl $0x0, %r8d
cmoveq %rcx, %r8
addq %rax, %r8
addq %r9, %r8
addq $0x4, %rsi
movq %r8, %rax
cmpq %rsi, %rdx
jne 0x5e35e
jmp 0x5e38d
movq %rax, %r8
movapd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r8, %xmm1
addsd %xmm1, %xmm0
addsd 0x476e7(%rip), %xmm0 # 0xa5a88
movsd 0x18(%r14), %xmm3
mulsd 0x47791(%rip), %xmm3 # 0xa5b40
movupd 0x20(%r14), %xmm1
mulpd 0x475a3(%rip), %xmm1 # 0xa5960
addsd %xmm1, %xmm3
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
addsd %xmm3, %xmm2
addsd 0x30(%r14), %xmm2
movlpd %xmm1, 0x8(%rsp)
movhpd %xmm1, 0x8(%rsp)
mulsd 0x47761(%rip), %xmm0 # 0xa5b48
movsd %xmm0, 0x8(%rsp)
addsd %xmm2, %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jg 0x5e4e9
testl %ebx, %ebx
je 0x5e4c2
cvttsd2si %xmm0, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
ucomisd 0x47682(%rip), %xmm0 # 0xa5ac0
movabsq $0x20c49ba5e353f7, %rax # imm = 0x20C49BA5E353F7
cmovbq %rdx, %rax
movsd 0x47664(%rip), %xmm1 # 0xa5ab8
ucomisd %xmm0, %xmm1
movabsq $-0x20c49ba5e353f7, %rcx # imm = 0xFFDF3B645A1CAC09
cmovbeq %rax, %rcx
leaq 0x38(%rsp), %rdi
movq %rcx, (%rdi)
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
movaps %xmm0, 0x10(%rsp)
callq 0xe0f0
movsd 0x47668(%rip), %xmm4 # 0xa5af0
movapd 0x10(%rsp), %xmm0
movq 0x28(%rbx), %rcx
movabsq $0x7777777777777777, %rdx # imm = 0x7777777777777777
movq %rcx, %rax
imulq %rdx
subq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrl $0x5, %edx
addl %eax, %edx
imull $0xea60, %edx, %eax # imm = 0xEA60
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
movapd 0x47476(%rip), %xmm2 # 0xa5940
andpd %xmm0, %xmm2
movsd 0x47612(%rip), %xmm1 # 0xa5ae8
ucomisd %xmm2, %xmm1
jb 0x5e4e9
callq 0xe150
xorpd %xmm4, %xmm4
addsd %xmm0, %xmm4
movapd %xmm4, %xmm0
addq $0x78, %rsp
popq %rbx
popq %r14
retq
| set_date_fields:
push r14
push rbx
sub rsp, 78h
mov ebx, esi
mov r14, rdi
movsd xmm1, qword ptr [rdi+8]
movsd [rsp+88h+var_58], xmm1
movsd xmm0, qword ptr [rdi+10h]
movaps [rsp+88h+var_78], xmm0
movapd xmm0, xmm1
divsd xmm0, cs:qword_A5B28
call _floor
addsd xmm0, qword ptr [r14]
movsd [rsp+88h+var_60], xmm0
movsd xmm0, [rsp+88h+var_58]
movsd xmm1, cs:qword_A5B28
call _fmod
movsd xmm5, [rsp+88h+var_60]
movsd xmm1, cs:qword_A5B30
ucomisd xmm1, xmm5
movsd xmm4, cs:qword_A5AF0
ja loc_5E4E9
ucomisd xmm5, cs:qword_A5B38
ja loc_5E4E9
movsd xmm1, cs:qword_A5B28
addsd xmm1, xmm0
xorpd xmm2, xmm2
movapd xmm3, xmm0
cmpltsd xmm3, xmm2
andpd xmm1, xmm3
andnpd xmm3, xmm0
orpd xmm3, xmm1
cvttsd2si eax, xmm5
cvttsd2si edi, xmm3
movsxd r8, eax
imul rax, r8, 16Dh
lea r10, [r8-7B1h]
sar r10, 2
add r10, rax
lea rsi, [r8-76Dh]
mov r9, 0A3D70A3D70A3D70Bh
mov rax, rsi
imul r9
lea rax, [rdx+r8]
add rax, 0FFFFFFFFFFFFF893h
mov rcx, rax
shr rcx, 3Fh
sar rax, 6
add rax, rcx
imul rax, 64h ; 'd'
sub rsi, rax
sar rsi, 3Fh
and rsi, 0FFFFFFFFFFFFFF9Ch
add rsi, rax
mov rcx, 5C28F5C28F5C28F5h
mov rax, rsi
imul rcx
mov rcx, rdx
sub rcx, rsi
mov rax, rcx
shr rax, 3Fh
sar rcx, 6
add rcx, rax
add rcx, r10
lea rsi, [r8-641h]
mov rax, rsi
imul r9
lea rax, [rdx+r8]
add rax, 0FFFFFFFFFFFFF9BFh
mov rdx, rax
shr rdx, 3Fh
sar rax, 8
add rax, rdx
imul rax, 190h
sub rsi, rax
sar rsi, 3Fh
and rsi, 0FFFFFFFFFFFFFE70h
add rsi, rax
mov rax, rsi
imul r9
add rdx, rsi
mov rax, rdx
shr rax, 3Fh
sar rdx, 8
add rdx, rax
lea rax, [rcx+rdx]
add rax, 0FFFFFFFFFFF50736h
test edi, edi
jle short loc_5E384
xor edx, edx
test r8b, 3
setz dl
imul esi, r8d, 0C28F5C29h
add esi, 51EB850h
mov ecx, esi
ror ecx, 2
ror esi, 4
cmp ecx, 28F5C29h
mov rcx, 0FFFFFFFFFFFFFE93h
sbb rcx, 0
cmp esi, 0A3D70Bh
adc rcx, rdx
add rcx, 16Dh
mov edx, edi
shl rdx, 2
xor esi, esi
lea rdi, month_days
movapd xmm0, [rsp+88h+var_78]
loc_5E35E:
movsxd r9, dword ptr [rsi+rdi]
cmp rsi, 4
mov r8d, 0
cmovz r8, rcx
add r8, rax
add r8, r9
add rsi, 4
mov rax, r8
cmp rdx, rsi
jnz short loc_5E35E
jmp short loc_5E38D
loc_5E384:
mov r8, rax
movapd xmm0, [rsp+88h+var_78]
loc_5E38D:
xorps xmm1, xmm1
cvtsi2sd xmm1, r8
addsd xmm0, xmm1
addsd xmm0, cs:qword_A5A88
movsd xmm3, qword ptr [r14+18h]
mulsd xmm3, cs:qword_A5B40
movupd xmm1, xmmword ptr [r14+20h]
mulpd xmm1, cs:xmmword_A5960
addsd xmm3, xmm1
movapd xmm2, xmm1
unpckhpd xmm2, xmm1
addsd xmm2, xmm3
addsd xmm2, qword ptr [r14+30h]
movlpd [rsp+88h+var_80], xmm1
movhpd [rsp+88h+var_80], xmm1
mulsd xmm0, cs:qword_A5B48
movsd [rsp+88h+var_80], xmm0
addsd xmm0, xmm2
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FEFFFFFFFFFFFFFh
cmp rax, rcx
jg loc_5E4E9
test ebx, ebx
jz loc_5E4C2
cvttsd2si rax, xmm0
mov rcx, 20C49BA5E353F7CFh
imul rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 7
add rdx, rax
ucomisd xmm0, cs:qword_A5AC0
mov rax, 20C49BA5E353F7h
cmovb rax, rdx
movsd xmm1, cs:qword_A5AB8
ucomisd xmm1, xmm0
mov rcx, 0FFDF3B645A1CAC09h
cmovbe rcx, rax
lea rdi, [rsp+88h+var_50]
mov [rdi], rcx
lea rbx, [rsp+88h+var_48]
mov rsi, rbx
movaps [rsp+88h+var_78], xmm0
call _localtime_r
movsd xmm4, cs:qword_A5AF0
movapd xmm0, [rsp+88h+var_78]
mov rcx, [rbx+28h]
mov rdx, 7777777777777777h
mov rax, rcx
imul rdx
sub rdx, rcx
mov rax, rdx
shr rax, 3Fh
shr edx, 5
add edx, eax
imul eax, edx, 0EA60h
xorps xmm1, xmm1
cvtsi2sd xmm1, eax
addsd xmm0, xmm1
loc_5E4C2:
movapd xmm2, cs:xmmword_A5940
andpd xmm2, xmm0
movsd xmm1, cs:qword_A5AE8
ucomisd xmm1, xmm2
jb short loc_5E4E9
call _trunc
xorpd xmm4, xmm4
addsd xmm4, xmm0
loc_5E4E9:
movapd xmm0, xmm4
add rsp, 78h
pop rbx
pop r14
retn
| __int128 __usercall set_date_fields@<xmm0>(__m128d *a1@<rdi>, int a2@<esi>)
{
__m128d v4; // xmm0
__int128 v5; // xmm4
double v6; // xmm3_8
unsigned long long v7; // rdi
long long v8; // r8
unsigned long long v9; // rax
signed long long v10; // rax
unsigned long long v11; // rcx
unsigned long long v12; // rax
signed long long v13; // rsi
long long v14; // rdx
long long v15; // rax
unsigned long long v16; // rcx
double v17; // xmm0_8
unsigned long long v18; // r8
long long v19; // r8
__m128d v20; // xmm1
double v21; // xmm0_8
unsigned long long v22; // rax
unsigned long long v23; // rcx
double v24; // xmm0_8
double v26; // [rsp+10h] [rbp-78h]
double v27; // [rsp+28h] [rbp-60h]
double v28; // [rsp+30h] [rbp-58h]
unsigned long long v29; // [rsp+38h] [rbp-50h] BYREF
char v30; // [rsp+40h] [rbp-48h] BYREF
long long v31; // [rsp+68h] [rbp-20h]
v28 = a1->m128d_f64[1];
v26 = a1[1].m128d_f64[0];
v27 = floor(v28 / 12.0) + a1->m128d_f64[0];
v4 = (__m128d)*(unsigned long long *)&v28;
v4.m128d_f64[0] = fmod(v28, 12.0);
v5 = 0x7FF8000000000000uLL;
if ( v27 >= -271821.0 && v27 <= 275760.0 )
{
v6 = _mm_cmplt_sd(v4, (__m128d)0LL).m128d_f64[0];
v7 = (unsigned int)(int)COERCE_DOUBLE(~*(_QWORD *)&v6 & *(_QWORD *)&v4.m128d_f64[0] | COERCE_UNSIGNED_INT64(v4.m128d_f64[0] + 12.0) & *(_QWORD *)&v6);
v8 = (int)v27;
v9 = 100
* (((unsigned long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1901)) >> 64)
+ v8
- 1901) >> 63)
+ ((long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1901)) >> 64) + v8 - 1901) >> 6));
v10 = v9 + (((long long)(v8 - 1901 - v9) >> 63) & 0xFFFFFFFFFFFFFF9CLL);
v11 = 365 * v8
+ ((v8 - 1969) >> 2)
+ ((unsigned long long)(((unsigned __int128)(0x5C28F5C28F5C28F5LL * (__int128)v10) >> 64) - v10) >> 63)
+ ((long long)(((unsigned __int128)(0x5C28F5C28F5C28F5LL * (__int128)v10) >> 64) - v10) >> 6);
v12 = 400
* (((unsigned long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1601)) >> 64)
+ v8
- 1601) >> 63)
+ ((long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1601)) >> 64) + v8 - 1601) >> 8));
v13 = v12 + (((long long)(v8 - 1601 - v12) >> 63) & 0xFFFFFFFFFFFFFE70LL);
v14 = v13 / 400;
v15 = v11 + v13 / 400 - 719050;
if ( (int)v7 <= 0 )
{
v19 = v11 + v13 / 400 - 719050;
v17 = v26;
}
else
{
v16 = ((v8 & 3) == 0)
+ (__ROR4__(-1030792151 * v8 + 85899344, 4) < 0xA3D70Bu)
- (unsigned long long)(__ROR4__(-1030792151 * v8 + 85899344, 2) < 0x28F5C29u);
v14 = 4LL * (unsigned int)v7;
v13 = 0LL;
v7 = (unsigned long long)&month_days;
v17 = v26;
do
{
v18 = 0LL;
if ( v13 == 4 )
v18 = v16;
v19 = *(int *)((char *)&month_days + v13) + v15 + v18;
v13 += 4LL;
v15 = v19;
}
while ( v14 != v13 );
}
v20 = _mm_mul_pd(a1[2], (__m128d)xmmword_A5960);
v21 = (v17 + (double)(int)v19 + -1.0) * 86400000.0
+ _mm_unpackhi_pd(v20, v20).m128d_f64[0]
+ a1[1].m128d_f64[1] * 3600000.0
+ v20.m128d_f64[0]
+ a1[3].m128d_f64[0];
if ( COERCE__INT64(fabs(v21)) <= 0x7FEFFFFFFFFFFFFFLL )
{
if ( a2 )
{
v22 = 0x20C49BA5E353F7LL;
if ( v21 < 9.223372036854776e18 )
v22 = ((unsigned long long)((0x20C49BA5E353F7CFLL * (unsigned __int128)(unsigned int)(int)v21) >> 64) >> 63)
+ (unsigned int)(int)v21 / 1000LL;
v23 = 0xFFDF3B645A1CAC09LL;
if ( v21 >= -9.223372036854776e18 )
v23 = v22;
v7 = (unsigned long long)&v29;
v29 = v23;
v13 = (signed long long)&v30;
localtime_r(&v29, &v30);
v5 = 0x7FF8000000000000uLL;
v14 = ((unsigned long long)(((unsigned __int128)(0x7777777777777777LL * (__int128)v31) >> 64) - v31) >> 63)
+ (((unsigned int)((unsigned __int128)(0x7777777777777777LL * (__int128)v31) >> 64) - (unsigned int)v31) >> 5);
v21 = v21 + (double)(60000 * (int)v14);
}
if ( fabs(v21) <= 8.64e15 )
{
v24 = trunc(v7, v13, v14);
v5 = 0LL;
*(double *)&v5 = v24 + 0.0;
}
}
}
return v5;
}
| set_date_fields:
PUSH R14
PUSH RBX
SUB RSP,0x78
MOV EBX,ESI
MOV R14,RDI
MOVSD XMM1,qword ptr [RDI + 0x8]
MOVSD qword ptr [RSP + 0x30],XMM1
MOVSD XMM0,qword ptr [RDI + 0x10]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPD XMM0,XMM1
DIVSD XMM0,qword ptr [0x001a5b28]
CALL 0x0010e8d0
ADDSD XMM0,qword ptr [R14]
MOVSD qword ptr [RSP + 0x28],XMM0
MOVSD XMM0,qword ptr [RSP + 0x30]
MOVSD XMM1,qword ptr [0x001a5b28]
CALL 0x0010e420
MOVSD XMM5,qword ptr [RSP + 0x28]
MOVSD XMM1,qword ptr [0x001a5b30]
UCOMISD XMM1,XMM5
MOVSD XMM4,qword ptr [0x001a5af0]
JA 0x0015e4e9
UCOMISD XMM5,qword ptr [0x001a5b38]
JA 0x0015e4e9
MOVSD XMM1,qword ptr [0x001a5b28]
ADDSD XMM1,XMM0
XORPD XMM2,XMM2
MOVAPD XMM3,XMM0
CMPLTSD XMM3,XMM2
ANDPD XMM1,XMM3
ANDNPD XMM3,XMM0
ORPD XMM3,XMM1
CVTTSD2SI EAX,XMM5
CVTTSD2SI EDI,XMM3
MOVSXD R8,EAX
IMUL RAX,R8,0x16d
LEA R10,[R8 + -0x7b1]
SAR R10,0x2
ADD R10,RAX
LEA RSI,[R8 + -0x76d]
MOV R9,-0x5c28f5c28f5c28f5
MOV RAX,RSI
IMUL R9
LEA RAX,[RDX + R8*0x1]
ADD RAX,-0x76d
MOV RCX,RAX
SHR RCX,0x3f
SAR RAX,0x6
ADD RAX,RCX
IMUL RAX,RAX,0x64
SUB RSI,RAX
SAR RSI,0x3f
AND RSI,-0x64
ADD RSI,RAX
MOV RCX,0x5c28f5c28f5c28f5
MOV RAX,RSI
IMUL RCX
MOV RCX,RDX
SUB RCX,RSI
MOV RAX,RCX
SHR RAX,0x3f
SAR RCX,0x6
ADD RCX,RAX
ADD RCX,R10
LEA RSI,[R8 + -0x641]
MOV RAX,RSI
IMUL R9
LEA RAX,[RDX + R8*0x1]
ADD RAX,-0x641
MOV RDX,RAX
SHR RDX,0x3f
SAR RAX,0x8
ADD RAX,RDX
IMUL RAX,RAX,0x190
SUB RSI,RAX
SAR RSI,0x3f
AND RSI,-0x190
ADD RSI,RAX
MOV RAX,RSI
IMUL R9
ADD RDX,RSI
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x8
ADD RDX,RAX
LEA RAX,[RCX + RDX*0x1]
ADD RAX,-0xaf8ca
TEST EDI,EDI
JLE 0x0015e384
XOR EDX,EDX
TEST R8B,0x3
SETZ DL
IMUL ESI,R8D,-0x3d70a3d7
ADD ESI,0x51eb850
MOV ECX,ESI
ROR ECX,0x2
ROR ESI,0x4
CMP ECX,0x28f5c29
MOV RCX,-0x16d
SBB RCX,0x0
CMP ESI,0xa3d70b
ADC RCX,RDX
ADD RCX,0x16d
MOV EDX,EDI
SHL RDX,0x2
XOR ESI,ESI
LEA RDI,[0x1a5790]
MOVAPD XMM0,xmmword ptr [RSP + 0x10]
LAB_0015e35e:
MOVSXD R9,dword ptr [RSI + RDI*0x1]
CMP RSI,0x4
MOV R8D,0x0
CMOVZ R8,RCX
ADD R8,RAX
ADD R8,R9
ADD RSI,0x4
MOV RAX,R8
CMP RDX,RSI
JNZ 0x0015e35e
JMP 0x0015e38d
LAB_0015e384:
MOV R8,RAX
MOVAPD XMM0,xmmword ptr [RSP + 0x10]
LAB_0015e38d:
XORPS XMM1,XMM1
CVTSI2SD XMM1,R8
ADDSD XMM0,XMM1
ADDSD XMM0,qword ptr [0x001a5a88]
MOVSD XMM3,qword ptr [R14 + 0x18]
MULSD XMM3,qword ptr [0x001a5b40]
MOVUPD XMM1,xmmword ptr [R14 + 0x20]
MULPD XMM1,xmmword ptr [0x001a5960]
ADDSD XMM3,XMM1
MOVAPD XMM2,XMM1
UNPCKHPD XMM2,XMM1
ADDSD XMM2,XMM3
ADDSD XMM2,qword ptr [R14 + 0x30]
MOVLPD qword ptr [RSP + 0x8],XMM1
MOVHPD qword ptr [RSP + 0x8],XMM1
MULSD XMM0,qword ptr [0x001a5b48]
MOVSD qword ptr [RSP + 0x8],XMM0
ADDSD XMM0,XMM2
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7fefffffffffffff
CMP RAX,RCX
JG 0x0015e4e9
TEST EBX,EBX
JZ 0x0015e4c2
CVTTSD2SI RAX,XMM0
MOV RCX,0x20c49ba5e353f7cf
IMUL RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x7
ADD RDX,RAX
UCOMISD XMM0,qword ptr [0x001a5ac0]
MOV RAX,0x20c49ba5e353f7
CMOVC RAX,RDX
MOVSD XMM1,qword ptr [0x001a5ab8]
UCOMISD XMM1,XMM0
MOV RCX,-0x20c49ba5e353f7
CMOVBE RCX,RAX
LEA RDI,[RSP + 0x38]
MOV qword ptr [RDI],RCX
LEA RBX,[RSP + 0x40]
MOV RSI,RBX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
CALL 0x0010e0f0
MOVSD XMM4,qword ptr [0x001a5af0]
MOVAPD XMM0,xmmword ptr [RSP + 0x10]
MOV RCX,qword ptr [RBX + 0x28]
MOV RDX,0x7777777777777777
MOV RAX,RCX
IMUL RDX
SUB RDX,RCX
MOV RAX,RDX
SHR RAX,0x3f
SHR EDX,0x5
ADD EDX,EAX
IMUL EAX,EDX,0xea60
XORPS XMM1,XMM1
CVTSI2SD XMM1,EAX
ADDSD XMM0,XMM1
LAB_0015e4c2:
MOVAPD XMM2,xmmword ptr [0x001a5940]
ANDPD XMM2,XMM0
MOVSD XMM1,qword ptr [0x001a5ae8]
UCOMISD XMM1,XMM2
JC 0x0015e4e9
CALL 0x0010e150
XORPD XMM4,XMM4
ADDSD XMM4,XMM0
LAB_0015e4e9:
MOVAPD XMM0,XMM4
ADD RSP,0x78
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double set_date_fields(double *param_1,int param_2)
{
int iVar1;
long lVar2;
uint uVar3;
long lVar4;
uint uVar5;
ulong uVar6;
long lVar7;
double dVar8;
double dVar9;
double dVar10;
double dVar11;
long local_50;
tm local_48;
dVar11 = param_1[1];
dVar10 = param_1[2];
dVar8 = floor(dVar11 / DAT_001a5b28);
dVar8 = dVar8 + *param_1;
dVar9 = fmod(dVar11,DAT_001a5b28);
dVar11 = DAT_001a5af0;
if ((DAT_001a5b30 <= dVar8) && (dVar8 <= _DAT_001a5b38)) {
iVar1 = (int)dVar8;
uVar5 = (uint)(double)(~-(ulong)(dVar9 < 0.0) & (ulong)dVar9 |
(ulong)(DAT_001a5b28 + dVar9) & -(ulong)(dVar9 < 0.0));
uVar6 = (ulong)iVar1;
lVar2 = SUB168(SEXT816((long)(uVar6 - 0x76d)) * SEXT816(-0x5c28f5c28f5c28f5),8) + uVar6 + -0x76d
;
lVar2 = (lVar2 >> 6) - (lVar2 >> 0x3f);
lVar4 = ((long)((uVar6 - 0x76d) + lVar2 * -100) >> 0x3f & 0xffffffffffffff9cU) + lVar2 * 100;
lVar4 = SUB168(SEXT816(lVar4) * SEXT816(0x5c28f5c28f5c28f5),8) - lVar4;
lVar2 = SUB168(SEXT816((long)(uVar6 - 0x641)) * SEXT816(-0x5c28f5c28f5c28f5),8) + uVar6 + -0x641
;
lVar2 = (lVar2 >> 8) - (lVar2 >> 0x3f);
lVar2 = ((lVar4 >> 6) - (lVar4 >> 0x3f)) + ((long)(uVar6 - 0x7b1) >> 2) + uVar6 * 0x16d +
(long)(((long)((uVar6 - 0x641) + lVar2 * -400) >> 0x3f & 0xfffffffffffffe70U) +
lVar2 * 400) / 400 + -0xaf8ca;
if (0 < (int)uVar5) {
uVar3 = iVar1 * -0x3d70a3d7 + 0x51eb850;
lVar4 = 0;
do {
lVar7 = 0;
if (lVar4 == 4) {
lVar7 = ((ulong)((uVar6 & 3) == 0) -
(ulong)((uVar3 >> 2 | iVar1 * 0x40000000) < 0x28f5c29)) +
(ulong)((uVar3 >> 4 | iVar1 * -0x70000000) < 0xa3d70b);
}
lVar2 = lVar7 + lVar2 + (long)*(int *)((long)&month_days + lVar4);
lVar4 = lVar4 + 4;
} while ((ulong)uVar5 << 2 != lVar4);
}
dVar10 = (dVar10 + (double)lVar2 + _DAT_001a5a88) * _DAT_001a5b48 +
param_1[5] * _UNK_001a5968 + param_1[3] * _DAT_001a5b40 + param_1[4] * _DAT_001a5960 +
param_1[6];
if ((long)ABS(dVar10) < 0x7ff0000000000000) {
if (param_2 != 0) {
lVar2 = 0x20c49ba5e353f7;
if (dVar10 < DAT_001a5ac0) {
lVar2 = (long)dVar10 / 1000;
}
local_50 = -0x20c49ba5e353f7;
if (DAT_001a5ab8 <= dVar10) {
local_50 = lVar2;
}
localtime_r(&local_50,&local_48);
uVar6 = SUB168(SEXT816(local_48.tm_gmtoff) * SEXT816(0x7777777777777777),8) -
local_48.tm_gmtoff;
dVar10 = dVar10 + (double)(int)((((uint)(uVar6 >> 5) & 0x7ffffff) -
(int)((long)uVar6 >> 0x3f)) * 60000);
}
dVar11 = DAT_001a5af0;
if ((double)(_DAT_001a5940 & (ulong)dVar10) <= DAT_001a5ae8) {
dVar11 = trunc(dVar10);
dVar11 = dVar11 + 0.0;
}
}
}
return dVar11;
}
| |
25,980 | nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long) | ng-log[P]ng-log/src/vlog_is_on.cc | NGLOG_NO_EXPORT bool SafeFNMatch_(const char* pattern, size_t patt_len,
const char* str, size_t str_len) {
size_t p = 0;
size_t s = 0;
while (true) {
if (p == patt_len && s == str_len) return true;
if (p == patt_len) return false;
if (s == str_len) return p + 1 == patt_len && pattern[p] == '*';
if (pattern[p] == str[s] || pattern[p] == '?') {
p += 1;
s += 1;
continue;
}
if (pattern[p] == '*') {
if (p + 1 == patt_len) return true;
do {
if (SafeFNMatch_(pattern + (p + 1), patt_len - (p + 1), str + s,
str_len - s)) {
return true;
}
s += 1;
} while (s != str_len);
return false;
}
return false;
}
} | O2 | cpp | nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
xorl %r14d, %r14d
cmpq %r14, %rcx
sete %al
cmpq %r14, %rsi
je 0x2aa9a
movq %rcx, %r15
subq %r14, %r15
je 0x2aa40
movb (%rdi,%r14), %al
cmpb $0x3f, %al
je 0x2aa3b
cmpb (%rbx,%r14), %al
jne 0x2aa52
incq %r14
jmp 0x2aa1a
leaq 0x1(%rcx), %rax
cmpq %rsi, %rax
jne 0x2aa98
cmpb $0x2a, (%rdi,%rcx)
sete %al
jmp 0x2aa9a
cmpb $0x2a, %al
jne 0x2aa98
leaq -0x1(%rsi), %rcx
movb $0x1, %al
cmpq %r14, %rcx
je 0x2aa9a
addq %r14, %rbx
leaq (%rdi,%r14), %r12
incq %r12
notq %r14
addq %rsi, %r14
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x2aa0c
testb %al, %al
jne 0x2aa9a
leaq -0x1(%r15), %rcx
incq %rbx
cmpq $0x1, %r15
movq %rcx, %r15
jne 0x2aa71
jmp 0x2aa9a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN5nglog5tools12SafeFNMatch_EPKcmS2_m:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdx
xor r14d, r14d
loc_2AA1A:
cmp rcx, r14
setz al
cmp rsi, r14
jz short loc_2AA9A
mov r15, rcx
sub r15, r14
jz short loc_2AA40
mov al, [rdi+r14]
cmp al, 3Fh ; '?'
jz short loc_2AA3B
cmp al, [rbx+r14]
jnz short loc_2AA52
loc_2AA3B:
inc r14
jmp short loc_2AA1A
loc_2AA40:
lea rax, [rcx+1]
cmp rax, rsi
jnz short loc_2AA98
cmp byte ptr [rdi+rcx], 2Ah ; '*'
setz al
jmp short loc_2AA9A
loc_2AA52:
cmp al, 2Ah ; '*'
jnz short loc_2AA98
lea rcx, [rsi-1]
mov al, 1
cmp rcx, r14
jz short loc_2AA9A
add rbx, r14
lea r12, [rdi+r14]
inc r12
not r14
add r14, rsi
loc_2AA71:
mov rdi, r12; this
mov rsi, r14; char *
mov rdx, rbx; unsigned __int64
mov rcx, r15; char *
call _ZN5nglog5tools12SafeFNMatch_EPKcmS2_m; nglog::tools::SafeFNMatch_(char const*,ulong,char const*,ulong)
test al, al
jnz short loc_2AA9A
lea rcx, [r15-1]
inc rbx
cmp r15, 1
mov r15, rcx
jnz short loc_2AA71
jmp short loc_2AA9A
loc_2AA98:
xor eax, eax
loc_2AA9A:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| char nglog::tools::SafeFNMatch_(
nglog::tools *this,
const char *a2,
long long a3,
const char *a4,
unsigned long long a5)
{
const char *i; // r14
char result; // al
const char *v7; // r15
char v8; // al
unsigned long long v9; // rbx
nglog::tools *v10; // r12
const char *v11; // r14
for ( i = 0LL; ; ++i )
{
result = a4 == i;
if ( a2 == i )
return result;
v7 = (const char *)(a4 - i);
if ( a4 == i )
{
if ( a4 + 1 == a2 )
return a4[(_QWORD)this] == 42;
return 0;
}
v8 = i[(_QWORD)this];
if ( v8 != 63 && v8 != i[a3] )
break;
}
if ( v8 != 42 )
return 0;
result = 1;
if ( a2 - 1 != i )
{
v9 = (unsigned long long)&i[a3];
v10 = (nglog::tools *)&i[(_QWORD)this + 1];
v11 = &a2[~(unsigned long long)i];
do
{
result = nglog::tools::SafeFNMatch_(v10, v11, v9, v7, a5);
if ( result )
break;
++v9;
--v7;
}
while ( v7 );
}
return result;
}
| SafeFNMatch_:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
XOR R14D,R14D
LAB_0012aa1a:
CMP RCX,R14
SETZ AL
CMP RSI,R14
JZ 0x0012aa9a
MOV R15,RCX
SUB R15,R14
JZ 0x0012aa40
MOV AL,byte ptr [RDI + R14*0x1]
CMP AL,0x3f
JZ 0x0012aa3b
CMP AL,byte ptr [RBX + R14*0x1]
JNZ 0x0012aa52
LAB_0012aa3b:
INC R14
JMP 0x0012aa1a
LAB_0012aa40:
LEA RAX,[RCX + 0x1]
CMP RAX,RSI
JNZ 0x0012aa98
CMP byte ptr [RDI + RCX*0x1],0x2a
SETZ AL
JMP 0x0012aa9a
LAB_0012aa52:
CMP AL,0x2a
JNZ 0x0012aa98
LEA RCX,[RSI + -0x1]
MOV AL,0x1
CMP RCX,R14
JZ 0x0012aa9a
ADD RBX,R14
LEA R12,[RDI + R14*0x1]
INC R12
NOT R14
ADD R14,RSI
LAB_0012aa71:
MOV RDI,R12
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R15
CALL 0x0012aa0c
TEST AL,AL
JNZ 0x0012aa9a
LEA RCX,[R15 + -0x1]
INC RBX
CMP R15,0x1
MOV R15,RCX
JNZ 0x0012aa71
JMP 0x0012aa9a
LAB_0012aa98:
XOR EAX,EAX
LAB_0012aa9a:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long) */
bool nglog::tools::SafeFNMatch_(char *param_1,ulong param_2,char *param_3,ulong param_4)
{
char cVar1;
char *pcVar2;
ulong uVar3;
ulong uVar4;
bool bVar5;
uVar3 = 0;
while( true ) {
if (param_2 == uVar3) {
return param_4 == uVar3;
}
if (param_4 - uVar3 == 0) {
if (param_4 + 1 != param_2) {
return false;
}
return param_1[param_4] == '*';
}
cVar1 = param_1[uVar3];
if ((cVar1 != '?') && (cVar1 != param_3[uVar3])) break;
uVar3 = uVar3 + 1;
}
if (cVar1 != '*') {
return false;
}
if (param_2 - 1 != uVar3) {
pcVar2 = param_3 + uVar3;
uVar4 = param_4 - uVar3;
do {
cVar1 = SafeFNMatch_(param_1 + uVar3 + 1,~uVar3 + param_2,pcVar2,uVar4);
if (cVar1 != '\0') {
return (bool)cVar1;
}
pcVar2 = pcVar2 + 1;
bVar5 = uVar4 != 1;
uVar4 = uVar4 - 1;
} while (bVar5);
return false;
}
return true;
}
| |
25,981 | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [9], 0>(char const (&) [9]) | monkey531[P]llama/common/json.hpp | iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
} | O0 | cpp | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [9], 0>(char const (&) [9]):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xa0180
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa01b0
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa01e0
testb $0x1, %al
jne 0xd1dd6
jmp 0xd1e16
movq 0x10(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xa1350
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0xd1e30
testb $0x1, %al
jne 0xd1e06
jmp 0xd1e08
jmp 0xd1e25
jmp 0xd1e0a
leaq 0x30(%rsp), %rdi
callq 0xa0260
jmp 0xd1db2
movq 0x10(%rsp), %rdi
callq 0xa01b0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA10_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
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_28], rdi
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5beginEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::begin(void)
mov [rsp+38h+var_8], rax
loc_D1DB2:
mov rdi, [rsp+38h+var_28]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov [rsp+38h+var_20], rax
lea rdi, [rsp+38h+var_8]
lea rsi, [rsp+38h+var_20]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_D1DD6
jmp short loc_D1E16
loc_D1DD6:
mov rax, [rsp+38h+var_28]
add rax, 18h
mov [rsp+38h+var_30], rax
lea rdi, [rsp+38h+var_8]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator->(void)
mov rdi, [rsp+38h+var_30]
mov rsi, rax
mov rdx, [rsp+38h+var_18]
call _ZNKSt8equal_toIvEclIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA10_KcEEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSD_OSE_
test al, 1
jnz short loc_D1E06
jmp short loc_D1E08
loc_D1E06:
jmp short loc_D1E25
loc_D1E08:
jmp short $+2
loc_D1E0A:
lea rdi, [rsp+38h+var_8]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator++(void)
jmp short loc_D1DB2
loc_D1E16:
mov rdi, [rsp+38h+var_28]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov [rsp+38h+var_8], rax
loc_D1E25:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA10_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
long long a1,
long long a2)
{
long long v2; // rax
long long v4; // [rsp+18h] [rbp-20h] BYREF
long long v5; // [rsp+20h] [rbp-18h]
long long v6; // [rsp+28h] [rbp-10h]
long long i; // [rsp+30h] [rbp-8h] BYREF
v6 = a1;
v5 = a2;
for ( i = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::begin(a1);
;
__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator++(&i) )
{
v4 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(a1);
if ( !__gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
(long long)&i,
(long long)&v4) )
break;
v2 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator->((long long)&i);
if ( (std::equal_to<void>::operator()<std::string const&,char const(&)[10]>(a1 + 24, v2, v5) & 1) != 0 )
return i;
}
return std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(a1);
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA10_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
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 + 0x10],RDI
CALL 0x001a0180
MOV qword ptr [RSP + 0x30],RAX
LAB_001d1db2:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001a01b0
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x18]
CALL 0x001a01e0
TEST AL,0x1
JNZ 0x001d1dd6
JMP 0x001d1e16
LAB_001d1dd6:
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x18
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x30]
CALL 0x001a1350
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x001d1e30
TEST AL,0x1
JNZ 0x001d1e06
JMP 0x001d1e08
LAB_001d1e06:
JMP 0x001d1e25
LAB_001d1e08:
JMP 0x001d1e0a
LAB_001d1e0a:
LEA RDI,[RSP + 0x30]
CALL 0x001a0260
JMP 0x001d1db2
LAB_001d1e16:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001a01b0
MOV qword ptr [RSP + 0x30],RAX
LAB_001d1e25:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
int8
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA10_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*param_1,char *param_2)
{
bool bVar1;
string *psVar2;
ulong uVar3;
int8 uVar4;
int8 local_20;
char *local_18;
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*local_10;
int8 local_8;
local_18 = param_2;
local_10 = param_1;
local_8 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::begin(param_1);
while( true ) {
local_20 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::end(param_1);
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_8,(__normal_iterator *)&local_20);
if (!bVar1) {
uVar4 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::end(param_1);
return uVar4;
}
psVar2 = (string *)
__gnu_cxx::
__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
::operator->((__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
*)&local_8);
uVar3 = std::equal_to<void>::operator()((equal_to<void> *)(param_1 + 0x18),psVar2,local_18);
if ((uVar3 & 1) != 0) break;
__gnu_cxx::
__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
::operator++((__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
*)&local_8);
}
return local_8;
}
| |
25,982 | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [9], 0>(char const (&) [9]) | monkey531[P]llama/common/json.hpp | iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
} | O2 | cpp | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [9], 0>(char const (&) [9]):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x42337
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26bd3
testb %al, %al
jne 0x42334
addq $0x30, %r14
jmp 0x42316
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA6_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
push r15
push r14
push rbx
mov rbx, rsi
mov r15, rdi
mov r14, [rdi]
loc_42316:
mov rax, [r15+8]
cmp r14, rax
jz short loc_42337
mov rdi, r14
mov rsi, rbx
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_42334
add r14, 30h ; '0'
jmp short loc_42316
loc_42334:
mov rax, r14
loc_42337:
pop rbx
pop r14
pop r15
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA6_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
long long *a1)
{
long long i; // r14
long long result; // rax
for ( i = *a1; ; i += 48LL )
{
result = a1[1];
if ( i == result )
break;
if ( std::operator==<char>(i) )
return i;
}
return result;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA6_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R15,RDI
MOV R14,qword ptr [RDI]
LAB_00142316:
MOV RAX,qword ptr [R15 + 0x8]
CMP R14,RAX
JZ 0x00142337
MOV RDI,R14
MOV RSI,RBX
CALL 0x00126bd3
TEST AL,AL
JNZ 0x00142334
ADD R14,0x30
JMP 0x00142316
LAB_00142334:
MOV RAX,R14
LAB_00142337:
POP RBX
POP R14
POP R15
RET
|
string * _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA6_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(int8 *param_1,char *param_2)
{
bool bVar1;
string *psVar2;
string *psVar3;
psVar3 = (string *)*param_1;
while ((psVar2 = (string *)param_1[1], psVar3 != (string *)param_1[1] &&
(bVar1 = std::operator==(psVar3,param_2), psVar2 = psVar3, !bVar1))) {
psVar3 = psVar3 + 0x30;
}
return psVar2;
}
| |
25,983 | my_hash_sort_ucs2_bin | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_ucs2_bin(CHARSET_INFO *cs,
const uchar *key, size_t len, ulong *nr1, ulong *nr2)
{
size_t lengthsp= my_lengthsp_mb2(cs, (const char *) key, len);
my_hash_sort_ucs2_nopad_bin(cs, key, lengthsp, nr1, nr2);
} | O3 | c | my_hash_sort_ucs2_bin:
movq %rdx, %rax
cmpq $0x2, %rdx
jl 0x4b21d
cmpb $0x20, -0x1(%rsi,%rax)
jne 0x4b215
leaq -0x2(%rax), %rdx
cmpb $0x0, -0x2(%rsi,%rax)
je 0x4b1fa
movq (%rcx), %rdx
movq (%r8), %rdi
jmp 0x4b229
movq (%rcx), %rdx
movq (%r8), %rdi
cmpq $0x1, %rax
jne 0x4b25c
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rax
movl %edx, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rdx, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rdx
addq $0x3, %rdi
incq %rsi
cmpq %rax, %rsi
jb 0x4b230
popq %rbp
movq %rdx, (%rcx)
movq %rdi, (%r8)
retq
| my_hash_sort_ucs2_bin:
mov rax, rdx
cmp rdx, 2
jl short loc_4B21D
cmp byte ptr [rsi+rax-1], 20h ; ' '
jnz short loc_4B215
lea rdx, [rax-2]
cmp byte ptr [rsi+rax-2], 0
jz short my_hash_sort_ucs2_bin
loc_4B215:
mov rdx, [rcx]
mov rdi, [r8]
jmp short loc_4B229
loc_4B21D:
mov rdx, [rcx]
mov rdi, [r8]
cmp rax, 1
jnz short loc_4B25C
loc_4B229:
push rbp
mov rbp, rsp
add rax, rsi
loc_4B230:
mov r9d, edx
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rdx
shl r9, 8
add r9, r10
xor rdx, r9
add rdi, 3
inc rsi
cmp rsi, rax
jb short loc_4B230
pop rbp
loc_4B25C:
mov [rcx], rdx
mov [r8], rdi
retn
| unsigned long long my_hash_sort_ucs2_bin(
long long a1,
unsigned long long a2,
long long a3,
long long *a4,
long long *a5)
{
unsigned long long result; // rax
long long v6; // rdx
long long v7; // rdi
while ( 1 )
{
result = a3;
if ( a3 < 2 )
break;
if ( *(_BYTE *)(a2 + a3 - 1) == 32 )
{
a3 -= 2LL;
if ( !*(_BYTE *)(a2 + result - 2) )
continue;
}
v6 = *a4;
v7 = *a5;
goto LABEL_6;
}
v6 = *a4;
v7 = *a5;
if ( result != 1 )
goto LABEL_8;
LABEL_6:
result += a2;
do
{
v6 ^= (v7 + (v6 & 0x3F)) * *(unsigned __int8 *)a2 + (v6 << 8);
v7 += 3LL;
++a2;
}
while ( a2 < result );
LABEL_8:
*a4 = v6;
*a5 = v7;
return result;
}
| my_hash_sort_ucs2_bin:
MOV RAX,RDX
CMP RDX,0x2
JL 0x0014b21d
CMP byte ptr [RSI + RAX*0x1 + -0x1],0x20
JNZ 0x0014b215
LEA RDX,[RAX + -0x2]
CMP byte ptr [RSI + RAX*0x1 + -0x2],0x0
JZ 0x0014b1fa
LAB_0014b215:
MOV RDX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
JMP 0x0014b229
LAB_0014b21d:
MOV RDX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
CMP RAX,0x1
JNZ 0x0014b25c
LAB_0014b229:
PUSH RBP
MOV RBP,RSP
ADD RAX,RSI
LAB_0014b230:
MOV R9D,EDX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RDX
SHL R9,0x8
ADD R9,R10
XOR RDX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RAX
JC 0x0014b230
POP RBP
LAB_0014b25c:
MOV qword ptr [RCX],RDX
MOV qword ptr [R8],RDI
RET
|
void my_hash_sort_ucs2_bin
(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
ulong uVar3;
long lVar4;
do {
lVar2 = param_3;
if (lVar2 < 2) {
uVar3 = *param_4;
lVar4 = *param_5;
if (lVar2 != 1) goto LAB_0014b25c;
goto LAB_0014b229;
}
} while ((param_2[lVar2 + -1] == 0x20) && (param_3 = lVar2 + -2, param_2[lVar2 + -2] == 0));
uVar3 = *param_4;
lVar4 = *param_5;
LAB_0014b229:
pbVar1 = param_2 + lVar2;
do {
uVar3 = uVar3 ^ uVar3 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar3 & 0x3f) + lVar4);
lVar4 = lVar4 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar1);
LAB_0014b25c:
*param_4 = uVar3;
*param_5 = lVar4;
return;
}
| |
25,984 | myisam_log_command | eloqsql/storage/myisam/mi_log.c | void _myisam_log_command(enum myisam_log_commands command, MI_INFO *info,
const uchar *buffert, uint length, int result)
{
uchar buff[9];
int error,old_errno;
ulong pid=(ulong) GETPID();
old_errno=my_errno;
buff[0]=(char) command;
mi_int2store(buff+1,info->dfile);
mi_int4store(buff+3,pid);
mi_int2store(buff+7,result);
mysql_mutex_lock(&THR_LOCK_myisam);
error=my_lock(myisam_log_file,F_WRLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
(void) mysql_file_write(myisam_log_file, buff, sizeof(buff), MYF(0));
if (buffert)
(void) mysql_file_write(myisam_log_file, buffert, length, MYF(0));
if (!error)
error=my_lock(myisam_log_file,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
mysql_mutex_unlock(&THR_LOCK_myisam);
my_errno=old_errno;
} | O0 | c | myisam_log_command:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movl %r8d, -0x30(%rbp)
cmpl $0x1, 0xbc8c7a(%rip) # 0xc7c2c8
jne 0xb365d
movq 0xbc8c69(%rip), %rax # 0xc7c2c0
movq %rax, -0x60(%rbp)
jmp 0xb3666
callq 0xf8070
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xf7a70
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x18(%rbp), %eax
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c0(%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movb %al, -0xf(%rbp)
movl -0x44(%rbp), %eax
shrl $0x8, %eax
movb %al, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb %al, -0xb(%rbp)
movq -0x50(%rbp), %rax
shrq $0x8, %rax
movb %al, -0xc(%rbp)
movq -0x50(%rbp), %rax
shrq $0x10, %rax
movb %al, -0xd(%rbp)
movq -0x50(%rbp), %rax
shrq $0x18, %rax
movb %al, -0xe(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movb %al, -0x9(%rbp)
movl -0x54(%rbp), %eax
shrl $0x8, %eax
movb %al, -0xa(%rbp)
leaq 0xbd199a(%rip), %rdi # 0xc85080
leaq 0xa19ac(%rip), %rsi # 0x155099
movl $0x69, %edx
callq 0xb33e0
leaq 0x20dc32(%rip), %rax # 0x2c1330
movl (%rax), %edi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0x20, %r8d
movq %rcx, %rdx
callq 0xf4ee0
movl %eax, -0x34(%rbp)
leaq 0x20dc0f(%rip), %rax # 0x2c1330
movl (%rax), %edx
leaq -0x11(%rbp), %rcx
leaq 0xa196b(%rip), %rdi # 0x155099
movl $0x6b, %esi
movl $0x9, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0xb3450
cmpq $0x0, -0x28(%rbp)
je 0xb3773
leaq 0x20dbdf(%rip), %rax # 0x2c1330
movl (%rax), %edx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl %eax, %r8d
leaq 0xa1935(%rip), %rdi # 0x155099
movl $0x6d, %esi
xorl %eax, %eax
movl %eax, %r9d
callq 0xb3450
cmpl $0x0, -0x34(%rbp)
jne 0xb379c
leaq 0x20dbb0(%rip), %rax # 0x2c1330
movl (%rax), %edi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0x20, %r8d
movq %rcx, %rdx
callq 0xf4ee0
movl %eax, -0x34(%rbp)
leaq 0xbd18dd(%rip), %rdi # 0xc85080
callq 0xb35c0
movl -0x38(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0xf7a70
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xb37d0
addq $0x70, %rsp
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
| _myisam_log_command:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], edi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_30], r8d
cmp cs:log_type, 1
jnz short loc_B365D
mov rax, cs:myisam_pid
mov [rbp+var_60], rax
jmp short loc_B3666
loc_B365D:
call my_thread_dbug_id
mov [rbp+var_60], rax
loc_B3666:
mov rax, [rbp+var_60]
mov [rbp+var_40], rax
call _my_thread_var
mov eax, [rax]
mov [rbp+var_38], eax
mov eax, [rbp+var_18]
mov [rbp+var_11], al
mov rax, [rbp+var_20]
mov eax, [rax+1C0h]
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
mov [rbp+var_F], al
mov eax, [rbp+var_44]
shr eax, 8
mov [rbp+var_10], al
mov rax, [rbp+var_40]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov [rbp+var_B], al
mov rax, [rbp+var_50]
shr rax, 8
mov [rbp+var_C], al
mov rax, [rbp+var_50]
shr rax, 10h
mov [rbp+var_D], al
mov rax, [rbp+var_50]
shr rax, 18h
mov [rbp+var_E], al
mov eax, [rbp+var_30]
mov [rbp+var_54], eax
mov eax, [rbp+var_54]
mov [rbp+var_9], al
mov eax, [rbp+var_54]
shr eax, 8
mov [rbp+var_A], al
lea rdi, THR_LOCK_myisam
lea rsi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 69h ; 'i'
call inline_mysql_mutex_lock_18
lea rax, myisam_log_file
mov edi, [rax]
mov esi, 1
xor eax, eax
mov ecx, eax
mov r8d, 20h ; ' '
mov rdx, rcx
call my_lock
mov [rbp+var_34], eax
lea rax, myisam_log_file
mov edx, [rax]
lea rcx, [rbp+var_11]
lea rdi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 6Bh ; 'k'
mov r8d, 9
xor eax, eax
mov r9d, eax
call inline_mysql_file_write_1
cmp [rbp+var_28], 0
jz short loc_B3773
lea rax, myisam_log_file
mov edx, [rax]
mov rcx, [rbp+var_28]
mov eax, [rbp+var_2C]
mov r8d, eax
lea rdi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 6Dh ; 'm'
xor eax, eax
mov r9d, eax
call inline_mysql_file_write_1
loc_B3773:
cmp [rbp+var_34], 0
jnz short loc_B379C
lea rax, myisam_log_file
mov edi, [rax]
mov esi, 2
xor eax, eax
mov ecx, eax
mov r8d, 20h ; ' '
mov rdx, rcx
call my_lock
mov [rbp+var_34], eax
loc_B379C:
lea rdi, THR_LOCK_myisam
call inline_mysql_mutex_unlock_19
mov eax, [rbp+var_38]
mov [rbp+var_64], eax
call _my_thread_var
mov ecx, [rbp+var_64]
mov [rax], ecx
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_B37D0
add rsp, 70h
pop rbp
retn
loc_B37D0:
call ___stack_chk_fail
| unsigned long long myisam_log_command(long long a1, long long a2, long long a3, unsigned int a4, __int16 a5)
{
__int16 v5; // kr00_2
const char *v6; // rsi
int v8; // [rsp+10h] [rbp-60h]
int v9; // [rsp+38h] [rbp-38h]
int v10; // [rsp+3Ch] [rbp-34h]
_BYTE v14[9]; // [rsp+5Fh] [rbp-11h] BYREF
unsigned long long v15; // [rsp+68h] [rbp-8h]
v15 = __readfsqword(0x28u);
if ( log_type == 1 )
v8 = myisam_pid;
else
v8 = my_thread_dbug_id();
v9 = *(_DWORD *)my_thread_var(a1, (const char *)a2);
v14[0] = a1;
v5 = *(_DWORD *)(a2 + 448);
v14[1] = HIBYTE(v5);
v14[2] = v5;
v14[5] = BYTE1(v8);
v14[6] = v8;
v14[3] = HIBYTE(v8);
v14[4] = BYTE2(v8);
v14[7] = HIBYTE(a5);
v14[8] = a5;
inline_mysql_mutex_lock_18(
(long long)&THR_LOCK_myisam,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
0x69u);
v10 = my_lock(myisam_log_file, 1LL, 0LL, 0LL, 32LL);
v6 = (_BYTE *)(&qword_68 + 3);
inline_mysql_file_write_1(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
0x6Bu,
myisam_log_file,
(long long)v14,
9LL,
0LL);
if ( a3 )
{
v6 = (_BYTE *)(&qword_68 + 5);
inline_mysql_file_write_1(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
0x6Du,
myisam_log_file,
a3,
a4,
0LL);
}
if ( !v10 )
{
v6 = (_BYTE *)(&dword_0 + 2);
my_lock(myisam_log_file, 2LL, 0LL, 0LL, 32LL);
}
inline_mysql_mutex_unlock_19((long long)&THR_LOCK_myisam);
*(_DWORD *)my_thread_var(&THR_LOCK_myisam, v6) = v9;
return __readfsqword(0x28u);
}
| _myisam_log_command:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x18],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x30],R8D
CMP dword ptr [0x00d7c2c8],0x1
JNZ 0x001b365d
MOV RAX,qword ptr [0x00d7c2c0]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001b3666
LAB_001b365d:
CALL 0x001f8070
MOV qword ptr [RBP + -0x60],RAX
LAB_001b3666:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x40],RAX
CALL 0x001f7a70
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x1c0]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
MOV byte ptr [RBP + -0xf],AL
MOV EAX,dword ptr [RBP + -0x44]
SHR EAX,0x8
MOV byte ptr [RBP + -0x10],AL
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RBP + -0xb],AL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x8
MOV byte ptr [RBP + -0xc],AL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x10
MOV byte ptr [RBP + -0xd],AL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x18
MOV byte ptr [RBP + -0xe],AL
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x54],EAX
MOV EAX,dword ptr [RBP + -0x54]
MOV byte ptr [RBP + -0x9],AL
MOV EAX,dword ptr [RBP + -0x54]
SHR EAX,0x8
MOV byte ptr [RBP + -0xa],AL
LEA RDI,[0xd85080]
LEA RSI,[0x255099]
MOV EDX,0x69
CALL 0x001b33e0
LEA RAX,[0x3c1330]
MOV EDI,dword ptr [RAX]
MOV ESI,0x1
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0x20
MOV RDX,RCX
CALL 0x001f4ee0
MOV dword ptr [RBP + -0x34],EAX
LEA RAX,[0x3c1330]
MOV EDX,dword ptr [RAX]
LEA RCX,[RBP + -0x11]
LEA RDI,[0x255099]
MOV ESI,0x6b
MOV R8D,0x9
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001b3450
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001b3773
LEA RAX,[0x3c1330]
MOV EDX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x2c]
MOV R8D,EAX
LEA RDI,[0x255099]
MOV ESI,0x6d
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001b3450
LAB_001b3773:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x001b379c
LEA RAX,[0x3c1330]
MOV EDI,dword ptr [RAX]
MOV ESI,0x2
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0x20
MOV RDX,RCX
CALL 0x001f4ee0
MOV dword ptr [RBP + -0x34],EAX
LAB_001b379c:
LEA RDI,[0xd85080]
CALL 0x001b35c0
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x64],EAX
CALL 0x001f7a70
MOV ECX,dword ptr [RBP + -0x64]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001b37d0
ADD RSP,0x70
POP RBP
RET
LAB_001b37d0:
CALL 0x0012a250
|
void _myisam_log_command(int1 param_1,long param_2,long param_3,int4 param_4,
int4 param_5)
{
int4 uVar1;
int iVar2;
int4 *puVar3;
long in_FS_OFFSET;
int4 local_68;
int1 local_19;
int1 local_18;
int1 local_17;
int1 local_16;
int1 local_15;
int1 local_14;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (log_type == 1) {
local_68 = (int4)myisam_pid;
}
else {
local_68 = my_thread_dbug_id();
}
puVar3 = (int4 *)_my_thread_var();
uVar1 = *puVar3;
local_17 = (int1)*(int4 *)(param_2 + 0x1c0);
local_18 = (int1)((uint)*(int4 *)(param_2 + 0x1c0) >> 8);
local_13 = (int1)local_68;
local_14 = (int1)((uint)local_68 >> 8);
local_15 = (int1)((uint)local_68 >> 0x10);
local_16 = (int1)((uint)local_68 >> 0x18);
local_11 = (int1)param_5;
local_12 = (int1)((uint)param_5 >> 8);
local_19 = param_1;
inline_mysql_mutex_lock
(THR_LOCK_myisam,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x69
);
iVar2 = my_lock(myisam_log_file,1,0,0,0x20);
inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x6b,myisam_log_file
,&local_19,9,0);
if (param_3 != 0) {
inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x6d,
myisam_log_file,param_3,param_4,0);
}
if (iVar2 == 0) {
my_lock(myisam_log_file,2,0,0,0x20);
}
inline_mysql_mutex_unlock(THR_LOCK_myisam);
puVar3 = (int4 *)_my_thread_var();
*puVar3 = uVar1;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
25,985 | my_xml_enter | eloqsql/strings/xml.c | static int my_xml_enter(MY_XML_PARSER *st, const char *str, size_t len)
{
if (my_xml_attr_ensure_space(st, len + 1 /* the separator char */))
return MY_XML_ERROR;
if (st->attr.end > st->attr.start)
{
st->attr.end[0]= '/';
st->attr.end++;
}
memcpy(st->attr.end, str, len);
st->attr.end+= len;
st->attr.end[0]= '\0';
if (st->flags & MY_XML_FLAG_RELATIVE_NAMES)
return st->enter ? st->enter(st, str, len) : MY_XML_OK;
else
return st->enter ?
st->enter(st, st->attr.start, st->attr.end - st->attr.start) : MY_XML_OK;
} | O3 | c | my_xml_enter:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x120(%rdi), %rdi
movq 0x110(%rbx), %rcx
movq 0x118(%rbx), %rax
movq %rdi, %r12
subq %rax, %r12
addq %r12, %rdx
addq $0x2, %rdx
cmpq %rcx, %rdx
jbe 0x5aac5
leaq 0x2(%r14), %rax
movq $-0x3, %rdx
subq %r14, %rdx
shrq %rdx
cmpq %rcx, %rdx
leaq (%rax,%rcx,2), %rax
movq $-0x1, %rdx
cmovaq %rax, %rdx
movq %rdx, 0x110(%rbx)
movq 0x108(%rbx), %rsi
xorl %edi, %edi
testq %rsi, %rsi
je 0x5aa73
xorl %ecx, %ecx
callq 0x2aff0
movq %rax, 0x108(%rbx)
jmp 0x5aaa8
movq %rdx, %rsi
xorl %edx, %edx
callq 0x2aecd
movq %rax, 0x108(%rbx)
testq %rax, %rax
je 0x5ab43
leaq 0x88(%rbx), %rsi
leaq 0x1(%r12), %rdx
movq %rax, %rdi
callq 0x24250
movq 0x108(%rbx), %rax
movq %rax, 0x118(%rbx)
addq %rax, %r12
movq %r12, 0x120(%rbx)
movq %r12, %rdi
testq %rax, %rax
je 0x5ab55
cmpq %rax, %rdi
jbe 0x5aade
movb $0x2f, (%rdi)
movq 0x120(%rbx), %rdi
incq %rdi
movq %rdi, 0x120(%rbx)
movq %r15, %rsi
movq %r14, %rdx
callq 0x24250
movq 0x120(%rbx), %rax
leaq (%rax,%r14), %rcx
movq %rcx, 0x120(%rbx)
movb $0x0, (%rax,%r14)
testb $0x1, (%rbx)
movq 0x148(%rbx), %rax
jne 0x5ab27
testq %rax, %rax
je 0x5ab3f
movq 0x118(%rbx), %rsi
movq 0x120(%rbx), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
jmp 0x5ab35
testq %rax, %rax
je 0x5ab3f
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
jmp 0x5ab5a
movq $0x0, 0x118(%rbx)
movq %r12, 0x120(%rbx)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_xml_enter:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdi, [rdi+120h]
mov rcx, [rbx+110h]
mov rax, [rbx+118h]
mov r12, rdi
sub r12, rax
add rdx, r12
add rdx, 2
cmp rdx, rcx
jbe loc_5AAC5
lea rax, [r14+2]
mov rdx, 0FFFFFFFFFFFFFFFDh
sub rdx, r14
shr rdx, 1
cmp rdx, rcx
lea rax, [rax+rcx*2]
mov rdx, 0FFFFFFFFFFFFFFFFh
cmova rdx, rax
mov [rbx+110h], rdx
mov rsi, [rbx+108h]
xor edi, edi
test rsi, rsi
jz short loc_5AA73
xor ecx, ecx
call my_realloc
mov [rbx+108h], rax
jmp short loc_5AAA8
loc_5AA73:
mov rsi, rdx
xor edx, edx
call my_malloc
mov [rbx+108h], rax
test rax, rax
jz loc_5AB43
lea rsi, [rbx+88h]
lea rdx, [r12+1]
mov rdi, rax
call _memcpy
mov rax, [rbx+108h]
loc_5AAA8:
mov [rbx+118h], rax
add r12, rax
mov [rbx+120h], r12
mov rdi, r12
test rax, rax
jz loc_5AB55
loc_5AAC5:
cmp rdi, rax
jbe short loc_5AADE
mov byte ptr [rdi], 2Fh ; '/'
mov rdi, [rbx+120h]
inc rdi
mov [rbx+120h], rdi
loc_5AADE:
mov rsi, r15
mov rdx, r14
call _memcpy
mov rax, [rbx+120h]
lea rcx, [rax+r14]
mov [rbx+120h], rcx
mov byte ptr [rax+r14], 0
test byte ptr [rbx], 1
mov rax, [rbx+148h]
jnz short loc_5AB27
test rax, rax
jz short loc_5AB3F
mov rsi, [rbx+118h]
mov rdx, [rbx+120h]
sub rdx, rsi
mov rdi, rbx
jmp short loc_5AB35
loc_5AB27:
test rax, rax
jz short loc_5AB3F
mov rdi, rbx
mov rsi, r15
mov rdx, r14
loc_5AB35:
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp rax
loc_5AB3F:
xor eax, eax
jmp short loc_5AB5A
loc_5AB43:
mov qword ptr [rbx+118h], 0
mov [rbx+120h], r12
loc_5AB55:
mov eax, 1
loc_5AB5A:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_xml_enter(long long a1, long long a2, long long a3)
{
_BYTE *v6; // rdi
unsigned long long v7; // rcx
unsigned long long v8; // rax
_BYTE *v9; // r12
bool v10; // cc
unsigned long long v11; // rdx
long long v12; // rsi
long long v13; // rax
_BYTE *v14; // r12
_BYTE *v15; // rcx
long long ( *v16)(long long, long long, long long); // rax
long long v17; // rsi
long long v18; // rdx
long long v19; // rdi
v6 = *(_BYTE **)(a1 + 288);
v7 = *(_QWORD *)(a1 + 272);
v8 = *(_QWORD *)(a1 + 280);
v9 = &v6[-v8];
if ( (unsigned long long)&v6[a3 - v8 + 2] > v7 )
{
v10 = (unsigned long long)(-3 - a3) >> 1 <= v7;
v11 = -1LL;
if ( !v10 )
v11 = a3 + 2 + 2 * v7;
*(_QWORD *)(a1 + 272) = v11;
v12 = *(_QWORD *)(a1 + 264);
if ( v12 )
{
v8 = my_realloc(0, v12, v11, 0);
*(_QWORD *)(a1 + 264) = v8;
}
else
{
v13 = my_malloc(0, v11, 0);
*(_QWORD *)(a1 + 264) = v13;
if ( !v13 )
{
*(_QWORD *)(a1 + 280) = 0LL;
*(_QWORD *)(a1 + 288) = v9;
return 1LL;
}
memcpy(v13, a1 + 136, v9 + 1);
v8 = *(_QWORD *)(a1 + 264);
}
*(_QWORD *)(a1 + 280) = v8;
v14 = &v9[v8];
*(_QWORD *)(a1 + 288) = v14;
v6 = v14;
if ( v8 )
goto LABEL_9;
return 1LL;
}
LABEL_9:
if ( (unsigned long long)v6 > v8 )
{
*v6 = 47;
v6 = (_BYTE *)(*(_QWORD *)(a1 + 288) + 1LL);
*(_QWORD *)(a1 + 288) = v6;
}
memcpy(v6, a2, a3);
v15 = (_BYTE *)(*(_QWORD *)(a1 + 288) + a3);
*(_QWORD *)(a1 + 288) = v15;
*v15 = 0;
v16 = *(long long ( **)(long long, long long, long long))(a1 + 328);
if ( (*(_BYTE *)a1 & 1) != 0 )
{
if ( v16 )
{
v19 = a1;
v17 = a2;
v18 = a3;
return v16(v19, v17, v18);
}
}
else if ( v16 )
{
v17 = *(_QWORD *)(a1 + 280);
v18 = *(_QWORD *)(a1 + 288) - v17;
v19 = a1;
return v16(v19, v17, v18);
}
return 0LL;
}
| my_xml_enter:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x120]
MOV RCX,qword ptr [RBX + 0x110]
MOV RAX,qword ptr [RBX + 0x118]
MOV R12,RDI
SUB R12,RAX
ADD RDX,R12
ADD RDX,0x2
CMP RDX,RCX
JBE 0x0015aac5
LEA RAX,[R14 + 0x2]
MOV RDX,-0x3
SUB RDX,R14
SHR RDX,0x1
CMP RDX,RCX
LEA RAX,[RAX + RCX*0x2]
MOV RDX,-0x1
CMOVA RDX,RAX
MOV qword ptr [RBX + 0x110],RDX
MOV RSI,qword ptr [RBX + 0x108]
XOR EDI,EDI
TEST RSI,RSI
JZ 0x0015aa73
XOR ECX,ECX
CALL 0x0012aff0
MOV qword ptr [RBX + 0x108],RAX
JMP 0x0015aaa8
LAB_0015aa73:
MOV RSI,RDX
XOR EDX,EDX
CALL 0x0012aecd
MOV qword ptr [RBX + 0x108],RAX
TEST RAX,RAX
JZ 0x0015ab43
LEA RSI,[RBX + 0x88]
LEA RDX,[R12 + 0x1]
MOV RDI,RAX
CALL 0x00124250
MOV RAX,qword ptr [RBX + 0x108]
LAB_0015aaa8:
MOV qword ptr [RBX + 0x118],RAX
ADD R12,RAX
MOV qword ptr [RBX + 0x120],R12
MOV RDI,R12
TEST RAX,RAX
JZ 0x0015ab55
LAB_0015aac5:
CMP RDI,RAX
JBE 0x0015aade
MOV byte ptr [RDI],0x2f
MOV RDI,qword ptr [RBX + 0x120]
INC RDI
MOV qword ptr [RBX + 0x120],RDI
LAB_0015aade:
MOV RSI,R15
MOV RDX,R14
CALL 0x00124250
MOV RAX,qword ptr [RBX + 0x120]
LEA RCX,[RAX + R14*0x1]
MOV qword ptr [RBX + 0x120],RCX
MOV byte ptr [RAX + R14*0x1],0x0
TEST byte ptr [RBX],0x1
MOV RAX,qword ptr [RBX + 0x148]
JNZ 0x0015ab27
TEST RAX,RAX
JZ 0x0015ab3f
MOV RSI,qword ptr [RBX + 0x118]
MOV RDX,qword ptr [RBX + 0x120]
SUB RDX,RSI
MOV RDI,RBX
JMP 0x0015ab35
LAB_0015ab27:
TEST RAX,RAX
JZ 0x0015ab3f
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
LAB_0015ab35:
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP RAX
LAB_0015ab3f:
XOR EAX,EAX
JMP 0x0015ab5a
LAB_0015ab43:
MOV qword ptr [RBX + 0x118],0x0
MOV qword ptr [RBX + 0x120],R12
LAB_0015ab55:
MOV EAX,0x1
LAB_0015ab5a:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 my_xml_enter(byte *param_1,void *param_2,size_t param_3)
{
ulong uVar1;
code *UNRECOVERED_JUMPTABLE;
int1 *puVar2;
void *__dest;
int8 uVar3;
long lVar4;
long lVar5;
int1 *__dest_00;
__dest_00 = *(int1 **)(param_1 + 0x120);
uVar1 = *(ulong *)(param_1 + 0x110);
puVar2 = *(int1 **)(param_1 + 0x118);
lVar5 = (long)__dest_00 - (long)puVar2;
if (uVar1 < param_3 + lVar5 + 2) {
lVar4 = -1;
if (uVar1 < -param_3 - 3 >> 1) {
lVar4 = param_3 + 2 + uVar1 * 2;
}
*(long *)(param_1 + 0x110) = lVar4;
if (*(long *)(param_1 + 0x108) == 0) {
__dest = (void *)my_malloc(0,lVar4,0);
*(void **)(param_1 + 0x108) = __dest;
if (__dest != (void *)0x0) {
memcpy(__dest,param_1 + 0x88,lVar5 + 1);
puVar2 = *(int1 **)(param_1 + 0x108);
goto LAB_0015aaa8;
}
param_1[0x118] = 0;
param_1[0x119] = 0;
param_1[0x11a] = 0;
param_1[0x11b] = 0;
param_1[0x11c] = 0;
param_1[0x11d] = 0;
param_1[0x11e] = 0;
param_1[0x11f] = 0;
*(long *)(param_1 + 0x120) = lVar5;
}
else {
puVar2 = (int1 *)my_realloc();
*(int1 **)(param_1 + 0x108) = puVar2;
LAB_0015aaa8:
*(int1 **)(param_1 + 0x118) = puVar2;
__dest_00 = puVar2 + lVar5;
*(int1 **)(param_1 + 0x120) = __dest_00;
if (puVar2 != (int1 *)0x0) goto LAB_0015aac5;
}
uVar3 = 1;
}
else {
LAB_0015aac5:
if (puVar2 < __dest_00) {
*__dest_00 = 0x2f;
__dest_00 = (int1 *)(*(long *)(param_1 + 0x120) + 1);
*(int1 **)(param_1 + 0x120) = __dest_00;
}
memcpy(__dest_00,param_2,param_3);
lVar5 = *(long *)(param_1 + 0x120);
*(size_t *)(param_1 + 0x120) = lVar5 + param_3;
*(int1 *)(lVar5 + param_3) = 0;
UNRECOVERED_JUMPTABLE = *(code **)(param_1 + 0x148);
if ((*param_1 & 1) == 0) {
if (UNRECOVERED_JUMPTABLE != (code *)0x0) {
param_2 = *(void **)(param_1 + 0x118);
param_3 = *(long *)(param_1 + 0x120) - (long)param_2;
LAB_0015ab35:
/* WARNING: Could not recover jumptable at 0x0015ab3d. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar3 = (*UNRECOVERED_JUMPTABLE)(param_1,param_2,param_3);
return uVar3;
}
}
else if (UNRECOVERED_JUMPTABLE != (code *)0x0) goto LAB_0015ab35;
uVar3 = 0;
}
return uVar3;
}
| |
25,986 | _bf_div | bluesky950520[P]quickjs/libbf.c | static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
bf_flags_t flags)
{
bf_context_t *s = r->ctx;
int ret, r_sign;
limb_t n, nb, precl;
r_sign = a->sign ^ b->sign;
if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
bf_set_nan(r);
return 0;
} else if (a->expn == BF_EXP_INF && b->expn == BF_EXP_INF) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else if (a->expn == BF_EXP_INF) {
bf_set_inf(r, r_sign);
return 0;
} else {
bf_set_zero(r, r_sign);
return 0;
}
} else if (a->expn == BF_EXP_ZERO) {
if (b->expn == BF_EXP_ZERO) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else {
bf_set_zero(r, r_sign);
return 0;
}
} else if (b->expn == BF_EXP_ZERO) {
bf_set_inf(r, r_sign);
return BF_ST_DIVIDE_ZERO;
}
/* number of limbs of the quotient (2 extra bits for rounding) */
precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
nb = b->len;
n = bf_max(a->len, precl);
{
limb_t *taba, na;
slimb_t d;
na = n + nb;
#if LIMB_LOG2_BITS == 6
if (na >= (SIZE_MAX / sizeof(limb_t)) - 1) {
return BF_ST_MEM_ERROR; /* Return memory error status */
}
#endif
taba = bf_malloc(s, (na + 1) * sizeof(limb_t));
if (!taba)
goto fail;
d = na - a->len;
memset(taba, 0, d * sizeof(limb_t));
memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
if (bf_resize(r, n + 1))
goto fail1;
if (mp_divnorm(s, r->tab, taba, na, b->tab, nb)) {
fail1:
bf_free(s, taba);
goto fail;
}
/* see if non zero remainder */
if (mp_scan_nz(taba, nb))
r->tab[0] |= 1;
bf_free(r->ctx, taba);
r->expn = a->expn - b->expn + LIMB_BITS;
r->sign = r_sign;
ret = bf_normalize_and_round(r, prec, flags);
}
return ret;
fail:
bf_set_nan(r);
return BF_ST_MEM_ERROR;
} | O0 | c | _bf_div:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movl %r8d, 0x4c(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x58(%rsp), %rcx
xorl 0x8(%rcx), %eax
movl %eax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jge 0xe91cc
movq 0x58(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jl 0xe9299
movq 0x60(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x10(%rax)
je 0xe91f6
movq 0x58(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x10(%rax)
jne 0xe920d
movq 0x68(%rsp), %rdi
callq 0xe4ee0
movl $0x0, 0x74(%rsp)
jmp 0xe950b
movq 0x60(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jne 0xe924e
movq 0x58(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jne 0xe924e
movq 0x68(%rsp), %rdi
callq 0xe4ee0
movl $0x1, 0x74(%rsp)
jmp 0xe950b
movq 0x60(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jne 0xe927e
movq 0x68(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0xe4fc0
movl $0x0, 0x74(%rsp)
jmp 0xe950b
movq 0x68(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0xe4f80
movl $0x0, 0x74(%rsp)
jmp 0xe950b
movq 0x60(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, 0x10(%rax)
jne 0xe92f5
movq 0x58(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, 0x10(%rax)
jne 0xe92da
movq 0x68(%rsp), %rdi
callq 0xe4ee0
movl $0x1, 0x74(%rsp)
jmp 0xe950b
movq 0x68(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0xe4f80
movl $0x0, 0x74(%rsp)
jmp 0xe950b
movq 0x58(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, 0x10(%rax)
jne 0xe9325
movq 0x68(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0xe4fc0
movl $0x2, 0x74(%rsp)
jmp 0xe950b
jmp 0xe9327
jmp 0xe9329
movq 0x50(%rsp), %rax
addq $0x2, %rax
addq $0x40, %rax
subq $0x1, %rax
shrq $0x6, %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0xe5da0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movabsq $0x1ffffffffffffffe, %rax # imm = 0x1FFFFFFFFFFFFFFE
cmpq %rax, 0x10(%rsp)
jb 0xe9396
movl $0x20, 0x74(%rsp)
jmp 0xe950b
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0xe6da0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xe93bf
jmp 0xe94f9
movq 0x10(%rsp), %rax
movq 0x60(%rsp), %rcx
subq 0x18(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0xe340
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rdx
shlq $0x3, %rdx
callq 0xe5a0
movq 0x68(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x1, %rsi
callq 0xe4d10
cmpl $0x0, %eax
je 0xe942d
jmp 0xe945f
movq 0x40(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x58(%rsp), %rax
movq 0x20(%rax), %r8
movq 0x28(%rsp), %r9
callq 0xe6dd0
cmpl $0x0, %eax
je 0xe9473
jmp 0xe945f
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xe5110
jmp 0xe94f9
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xe7290
cmpq $0x0, %rax
je 0xe949b
movq 0x68(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
orq $0x1, %rcx
movq %rcx, (%rax)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0xe5110
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x58(%rsp), %rax
subq 0x10(%rax), %rcx
addq $0x40, %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x38(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x4c(%rsp), %edx
callq 0xe5140
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x74(%rsp)
jmp 0xe950b
movq 0x68(%rsp), %rdi
callq 0xe4ee0
movl $0x20, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
| __bf_div:
sub rsp, 78h
mov [rsp+78h+var_10], rdi
mov [rsp+78h+var_18], rsi
mov [rsp+78h+var_20], rdx
mov [rsp+78h+var_28], rcx
mov [rsp+78h+var_2C], r8d
mov rax, [rsp+78h+var_10]
mov rax, [rax]
mov [rsp+78h+var_38], rax
mov rax, [rsp+78h+var_18]
mov eax, [rax+8]
mov rcx, [rsp+78h+var_20]
xor eax, [rcx+8]
mov [rsp+78h+var_40], eax
mov rax, [rsp+78h+var_18]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jge short loc_E91CC
mov rax, [rsp+78h+var_20]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jl loc_E9299
loc_E91CC:
mov rax, [rsp+78h+var_18]
mov rcx, 7FFFFFFFFFFFFFFFh
cmp [rax+10h], rcx
jz short loc_E91F6
mov rax, [rsp+78h+var_20]
mov rcx, 7FFFFFFFFFFFFFFFh
cmp [rax+10h], rcx
jnz short loc_E920D
loc_E91F6:
mov rdi, [rsp+78h+var_10]
call bf_set_nan
mov [rsp+78h+var_4], 0
jmp loc_E950B
loc_E920D:
mov rax, [rsp+78h+var_18]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jnz short loc_E924E
mov rax, [rsp+78h+var_20]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jnz short loc_E924E
mov rdi, [rsp+78h+var_10]
call bf_set_nan
mov [rsp+78h+var_4], 1
jmp loc_E950B
loc_E924E:
mov rax, [rsp+78h+var_18]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jnz short loc_E927E
mov rdi, [rsp+78h+var_10]
mov esi, [rsp+78h+var_40]
call bf_set_inf
mov [rsp+78h+var_4], 0
jmp loc_E950B
loc_E927E:
mov rdi, [rsp+78h+var_10]
mov esi, [rsp+78h+var_40]
call bf_set_zero
mov [rsp+78h+var_4], 0
jmp loc_E950B
loc_E9299:
mov rax, [rsp+78h+var_18]
mov rcx, 8000000000000000h
cmp [rax+10h], rcx
jnz short loc_E92F5
mov rax, [rsp+78h+var_20]
mov rcx, 8000000000000000h
cmp [rax+10h], rcx
jnz short loc_E92DA
mov rdi, [rsp+78h+var_10]
call bf_set_nan
mov [rsp+78h+var_4], 1
jmp loc_E950B
loc_E92DA:
mov rdi, [rsp+78h+var_10]
mov esi, [rsp+78h+var_40]
call bf_set_zero
mov [rsp+78h+var_4], 0
jmp loc_E950B
loc_E92F5:
mov rax, [rsp+78h+var_20]
mov rcx, 8000000000000000h
cmp [rax+10h], rcx
jnz short loc_E9325
mov rdi, [rsp+78h+var_10]
mov esi, [rsp+78h+var_40]
call bf_set_inf
mov [rsp+78h+var_4], 2
jmp loc_E950B
loc_E9325:
jmp short $+2
loc_E9327:
jmp short $+2
loc_E9329:
mov rax, [rsp+78h+var_28]
add rax, 2
add rax, 40h ; '@'
sub rax, 1
shr rax, 6
mov [rsp+78h+var_58], rax
mov rax, [rsp+78h+var_20]
mov rax, [rax+18h]
mov [rsp+78h+var_50], rax
mov rax, [rsp+78h+var_18]
mov rdi, [rax+18h]
mov rsi, [rsp+78h+var_58]
call bf_max
mov [rsp+78h+var_48], rax
mov rax, [rsp+78h+var_48]
add rax, [rsp+78h+var_50]
mov [rsp+78h+var_68], rax
mov rax, 1FFFFFFFFFFFFFFEh
cmp [rsp+78h+var_68], rax
jb short loc_E9396
mov [rsp+78h+var_4], 20h ; ' '
jmp loc_E950B
loc_E9396:
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_68]
add rsi, 1
shl rsi, 3
call bf_malloc
mov [rsp+78h+var_60], rax
cmp [rsp+78h+var_60], 0
jnz short loc_E93BF
jmp loc_E94F9
loc_E93BF:
mov rax, [rsp+78h+var_68]
mov rcx, [rsp+78h+var_18]
sub rax, [rcx+18h]
mov [rsp+78h+var_70], rax
mov rdi, [rsp+78h+var_60]
mov rdx, [rsp+78h+var_70]
shl rdx, 3
xor esi, esi
call _memset
mov rdi, [rsp+78h+var_60]
mov rax, [rsp+78h+var_70]
shl rax, 3
add rdi, rax
mov rax, [rsp+78h+var_18]
mov rsi, [rax+20h]
mov rax, [rsp+78h+var_18]
mov rdx, [rax+18h]
shl rdx, 3
call _memcpy
mov rdi, [rsp+78h+var_10]
mov rsi, [rsp+78h+var_48]
add rsi, 1
call bf_resize
cmp eax, 0
jz short loc_E942D
jmp short loc_E945F
loc_E942D:
mov rdi, [rsp+78h+var_38]
mov rax, [rsp+78h+var_10]
mov rsi, [rax+20h]
mov rdx, [rsp+78h+var_60]
mov rcx, [rsp+78h+var_68]
mov rax, [rsp+78h+var_20]
mov r8, [rax+20h]
mov r9, [rsp+78h+var_50]
call mp_divnorm
cmp eax, 0
jz short loc_E9473
jmp short $+2
loc_E945F:
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_60]
call bf_free_0
jmp loc_E94F9
loc_E9473:
mov rdi, [rsp+78h+var_60]
mov rsi, [rsp+78h+var_50]
call mp_scan_nz
cmp rax, 0
jz short loc_E949B
mov rax, [rsp+78h+var_10]
mov rax, [rax+20h]
mov rcx, [rax]
or rcx, 1
mov [rax], rcx
loc_E949B:
mov rax, [rsp+78h+var_10]
mov rdi, [rax]
mov rsi, [rsp+78h+var_60]
call bf_free_0
mov rax, [rsp+78h+var_18]
mov rcx, [rax+10h]
mov rax, [rsp+78h+var_20]
sub rcx, [rax+10h]
add rcx, 40h ; '@'
mov rax, [rsp+78h+var_10]
mov [rax+10h], rcx
mov ecx, [rsp+78h+var_40]
mov rax, [rsp+78h+var_10]
mov [rax+8], ecx
mov rdi, [rsp+78h+var_10]
mov rsi, [rsp+78h+var_28]
mov edx, [rsp+78h+var_2C]
call bf_normalize_and_round
mov [rsp+78h+var_3C], eax
mov eax, [rsp+78h+var_3C]
mov [rsp+78h+var_4], eax
jmp short loc_E950B
loc_E94F9:
mov rdi, [rsp+78h+var_10]
call bf_set_nan
mov [rsp+78h+var_4], 20h ; ' '
loc_E950B:
mov eax, [rsp+78h+var_4]
add rsp, 78h
retn
| long long _bf_div(long long a1, long long a2, long long a3, long long a4, unsigned int a5)
{
long long v5; // rdx
long long v6; // rcx
long long v7; // r8
long long v8; // r9
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
long long v12; // r9
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
long long v16; // r9
long long *v17; // rax
long long v19; // [rsp+8h] [rbp-70h]
long long v20; // [rsp+10h] [rbp-68h]
_QWORD *v21; // [rsp+18h] [rbp-60h]
unsigned long long v22; // [rsp+28h] [rbp-50h]
long long v23; // [rsp+30h] [rbp-48h]
int v24; // [rsp+38h] [rbp-40h]
long long v25; // [rsp+40h] [rbp-38h]
v25 = *(_QWORD *)a1;
v24 = *(_DWORD *)(a3 + 8) ^ *(_DWORD *)(a2 + 8);
if ( *(long long *)(a2 + 16) < 0x7FFFFFFFFFFFFFFELL && *(long long *)(a3 + 16) < 0x7FFFFFFFFFFFFFFELL )
{
if ( *(_QWORD *)(a2 + 16) == 0x8000000000000000LL )
{
if ( *(_QWORD *)(a3 + 16) != 0x8000000000000000LL )
{
bf_set_zero(a1, v24);
return 0;
}
goto LABEL_8;
}
if ( *(_QWORD *)(a3 + 16) == 0x8000000000000000LL )
{
bf_set_inf(a1, v24);
return 2;
}
v22 = *(_QWORD *)(a3 + 24);
v23 = bf_max(*(_QWORD *)(a2 + 24), (unsigned long long)(a4 + 65) >> 6);
v20 = v22 + v23;
if ( v22 + v23 >= 0x1FFFFFFFFFFFFFFELL )
return 32;
v21 = (_QWORD *)bf_malloc(v25, 8 * (v20 + 1), v5, v6, v7, v8);
if ( v21 )
{
v19 = v20 - *(_QWORD *)(a2 + 24);
memset(v21, 0LL, 8 * v19);
memcpy(&v21[v19], *(_QWORD *)(a2 + 32), 8LL * *(_QWORD *)(a2 + 24));
if ( !(unsigned int)bf_resize((_QWORD *)a1, v23 + 1)
&& !(unsigned int)mp_divnorm(v25, *(_QWORD *)(a1 + 32), v21, v20, *(_QWORD *)(a3 + 32), v22) )
{
if ( mp_scan_nz((long long)v21, v22) )
{
v17 = *(long long **)(a1 + 32);
v14 = *v17 | 1;
*v17 = v14;
}
bf_free_0(*(_QWORD *)a1, (long long)v21, v13, v14, v15, v16);
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a2 + 16) - *(_QWORD *)(a3 + 16) + 64LL;
*(_DWORD *)(a1 + 8) = v24;
return (unsigned int)bf_normalize_and_round((_QWORD *)a1, a4, a5);
}
bf_free_0(v25, (long long)v21, v9, v10, v11, v12);
}
bf_set_nan(a1);
return 32;
}
if ( *(_QWORD *)(a2 + 16) == 0x7FFFFFFFFFFFFFFFLL || *(_QWORD *)(a3 + 16) == 0x7FFFFFFFFFFFFFFFLL )
{
bf_set_nan(a1);
return 0;
}
if ( *(_QWORD *)(a2 + 16) == 0x7FFFFFFFFFFFFFFELL && *(_QWORD *)(a3 + 16) == 0x7FFFFFFFFFFFFFFELL )
{
LABEL_8:
bf_set_nan(a1);
return 1;
}
if ( *(_QWORD *)(a2 + 16) == 0x7FFFFFFFFFFFFFFELL )
bf_set_inf(a1, v24);
else
bf_set_zero(a1, v24);
return 0;
}
| __bf_div:
SUB RSP,0x78
MOV qword ptr [RSP + 0x68],RDI
MOV qword ptr [RSP + 0x60],RSI
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x50],RCX
MOV dword ptr [RSP + 0x4c],R8D
MOV RAX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RSP + 0x58]
XOR EAX,dword ptr [RCX + 0x8]
MOV dword ptr [RSP + 0x38],EAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JGE 0x001e91cc
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JL 0x001e9299
LAB_001e91cc:
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,0x7fffffffffffffff
CMP qword ptr [RAX + 0x10],RCX
JZ 0x001e91f6
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,0x7fffffffffffffff
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001e920d
LAB_001e91f6:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001e4ee0
MOV dword ptr [RSP + 0x74],0x0
JMP 0x001e950b
LAB_001e920d:
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001e924e
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001e924e
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001e4ee0
MOV dword ptr [RSP + 0x74],0x1
JMP 0x001e950b
LAB_001e924e:
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001e927e
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x38]
CALL 0x001e4fc0
MOV dword ptr [RSP + 0x74],0x0
JMP 0x001e950b
LAB_001e927e:
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x38]
CALL 0x001e4f80
MOV dword ptr [RSP + 0x74],0x0
JMP 0x001e950b
LAB_001e9299:
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,-0x8000000000000000
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001e92f5
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,-0x8000000000000000
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001e92da
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001e4ee0
MOV dword ptr [RSP + 0x74],0x1
JMP 0x001e950b
LAB_001e92da:
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x38]
CALL 0x001e4f80
MOV dword ptr [RSP + 0x74],0x0
JMP 0x001e950b
LAB_001e92f5:
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,-0x8000000000000000
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001e9325
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x38]
CALL 0x001e4fc0
MOV dword ptr [RSP + 0x74],0x2
JMP 0x001e950b
LAB_001e9325:
JMP 0x001e9327
LAB_001e9327:
JMP 0x001e9329
LAB_001e9329:
MOV RAX,qword ptr [RSP + 0x50]
ADD RAX,0x2
ADD RAX,0x40
SUB RAX,0x1
SHR RAX,0x6
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x001e5da0
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x30]
ADD RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,0x1ffffffffffffffe
CMP qword ptr [RSP + 0x10],RAX
JC 0x001e9396
MOV dword ptr [RSP + 0x74],0x20
JMP 0x001e950b
LAB_001e9396:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0x1
SHL RSI,0x3
CALL 0x001e6da0
MOV qword ptr [RSP + 0x18],RAX
CMP qword ptr [RSP + 0x18],0x0
JNZ 0x001e93bf
JMP 0x001e94f9
LAB_001e93bf:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x60]
SUB RAX,qword ptr [RCX + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x8]
SHL RDX,0x3
XOR ESI,ESI
CALL 0x0010e340
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x8]
SHL RAX,0x3
ADD RDI,RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RAX + 0x18]
SHL RDX,0x3
CALL 0x0010e5a0
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x30]
ADD RSI,0x1
CALL 0x001e4d10
CMP EAX,0x0
JZ 0x001e942d
JMP 0x001e945f
LAB_001e942d:
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x58]
MOV R8,qword ptr [RAX + 0x20]
MOV R9,qword ptr [RSP + 0x28]
CALL 0x001e6dd0
CMP EAX,0x0
JZ 0x001e9473
JMP 0x001e945f
LAB_001e945f:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001e5110
JMP 0x001e94f9
LAB_001e9473:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x001e7290
CMP RAX,0x0
JZ 0x001e949b
MOV RAX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX]
OR RCX,0x1
MOV qword ptr [RAX],RCX
LAB_001e949b:
MOV RAX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001e5110
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSP + 0x58]
SUB RCX,qword ptr [RAX + 0x10]
ADD RCX,0x40
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RAX + 0x10],RCX
MOV ECX,dword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x68]
MOV dword ptr [RAX + 0x8],ECX
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x50]
MOV EDX,dword ptr [RSP + 0x4c]
CALL 0x001e5140
MOV dword ptr [RSP + 0x3c],EAX
MOV EAX,dword ptr [RSP + 0x3c]
MOV dword ptr [RSP + 0x74],EAX
JMP 0x001e950b
LAB_001e94f9:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001e4ee0
MOV dword ptr [RSP + 0x74],0x20
LAB_001e950b:
MOV EAX,dword ptr [RSP + 0x74]
ADD RSP,0x78
RET
|
int4 __bf_div(int8 *param_1,long param_2,long param_3,long param_4,int4 param_5)
{
int8 uVar1;
uint uVar2;
int iVar3;
int4 uVar4;
long lVar5;
ulong uVar6;
void *__s;
long lVar7;
long lVar8;
int4 local_4;
uVar1 = *param_1;
uVar2 = *(uint *)(param_2 + 8) ^ *(uint *)(param_3 + 8);
if ((*(long *)(param_2 + 0x10) < 0x7ffffffffffffffe) &&
(*(long *)(param_3 + 0x10) < 0x7ffffffffffffffe)) {
if (*(long *)(param_2 + 0x10) == -0x8000000000000000) {
if (*(long *)(param_3 + 0x10) == -0x8000000000000000) {
bf_set_nan(param_1);
local_4 = 1;
}
else {
bf_set_zero(param_1,uVar2);
local_4 = 0;
}
}
else if (*(long *)(param_3 + 0x10) == -0x8000000000000000) {
bf_set_inf(param_1,uVar2);
local_4 = 2;
}
else {
lVar8 = *(long *)(param_3 + 0x18);
lVar5 = bf_max(*(int8 *)(param_2 + 0x18),param_4 + 0x41U >> 6);
uVar6 = lVar5 + lVar8;
if (uVar6 < 0x1ffffffffffffffe) {
__s = (void *)bf_malloc(uVar1);
if (__s != (void *)0x0) {
lVar7 = uVar6 - *(long *)(param_2 + 0x18);
memset(__s,0,lVar7 * 8);
memcpy((void *)((long)__s + lVar7 * 8),*(void **)(param_2 + 0x20),
*(long *)(param_2 + 0x18) << 3);
iVar3 = bf_resize(param_1,lVar5 + 1);
if ((iVar3 == 0) &&
(iVar3 = mp_divnorm(uVar1,param_1[4],__s,uVar6,*(int8 *)(param_3 + 0x20),lVar8),
iVar3 == 0)) {
lVar8 = mp_scan_nz(__s,lVar8);
if (lVar8 != 0) {
*(ulong *)param_1[4] = *(ulong *)param_1[4] | 1;
}
bf_free(*param_1,__s);
param_1[2] = (*(long *)(param_2 + 0x10) - *(long *)(param_3 + 0x10)) + 0x40;
*(uint *)(param_1 + 1) = uVar2;
uVar4 = bf_normalize_and_round(param_1,param_4,param_5);
return uVar4;
}
bf_free(uVar1,__s);
}
bf_set_nan(param_1);
local_4 = 0x20;
}
else {
local_4 = 0x20;
}
}
}
else if ((*(long *)(param_2 + 0x10) == 0x7fffffffffffffff) ||
(*(long *)(param_3 + 0x10) == 0x7fffffffffffffff)) {
bf_set_nan(param_1);
local_4 = 0;
}
else if ((*(long *)(param_2 + 0x10) == 0x7ffffffffffffffe) &&
(*(long *)(param_3 + 0x10) == 0x7ffffffffffffffe)) {
bf_set_nan(param_1);
local_4 = 1;
}
else if (*(long *)(param_2 + 0x10) == 0x7ffffffffffffffe) {
bf_set_inf(param_1,uVar2);
local_4 = 0;
}
else {
bf_set_zero(param_1,uVar2);
local_4 = 0;
}
return local_4;
}
| |
25,987 | _bf_div | bluesky950520[P]quickjs/libbf.c | static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
bf_flags_t flags)
{
bf_context_t *s = r->ctx;
int ret, r_sign;
limb_t n, nb, precl;
r_sign = a->sign ^ b->sign;
if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
bf_set_nan(r);
return 0;
} else if (a->expn == BF_EXP_INF && b->expn == BF_EXP_INF) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else if (a->expn == BF_EXP_INF) {
bf_set_inf(r, r_sign);
return 0;
} else {
bf_set_zero(r, r_sign);
return 0;
}
} else if (a->expn == BF_EXP_ZERO) {
if (b->expn == BF_EXP_ZERO) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else {
bf_set_zero(r, r_sign);
return 0;
}
} else if (b->expn == BF_EXP_ZERO) {
bf_set_inf(r, r_sign);
return BF_ST_DIVIDE_ZERO;
}
/* number of limbs of the quotient (2 extra bits for rounding) */
precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
nb = b->len;
n = bf_max(a->len, precl);
{
limb_t *taba, na;
slimb_t d;
na = n + nb;
#if LIMB_LOG2_BITS == 6
if (na >= (SIZE_MAX / sizeof(limb_t)) - 1) {
return BF_ST_MEM_ERROR; /* Return memory error status */
}
#endif
taba = bf_malloc(s, (na + 1) * sizeof(limb_t));
if (!taba)
goto fail;
d = na - a->len;
memset(taba, 0, d * sizeof(limb_t));
memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
if (bf_resize(r, n + 1))
goto fail1;
if (mp_divnorm(s, r->tab, taba, na, b->tab, nb)) {
fail1:
bf_free(s, taba);
goto fail;
}
/* see if non zero remainder */
if (mp_scan_nz(taba, nb))
r->tab[0] |= 1;
bf_free(r->ctx, taba);
r->expn = a->expn - b->expn + LIMB_BITS;
r->sign = r_sign;
ret = bf_normalize_and_round(r, prec, flags);
}
return ret;
fail:
bf_set_nan(r);
return BF_ST_MEM_ERROR;
} | O1 | c | _bf_div:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rdi, %rbx
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
movl 0x8(%rdx), %ebp
xorl 0x8(%rsi), %ebp
movq (%rdi), %r9
movq 0x10(%rsi), %rax
leaq -0x2(%r15), %rdx
cmpq %rdx, %rax
jg 0x87020
movq %rsi, %r13
movq 0x10(%r12), %rsi
cmpq %rdx, %rsi
jle 0x8705f
cmpq %r15, %rax
je 0x8702f
movq 0x10(%r12), %rdx
cmpq %r15, %rdx
jne 0x8707c
cmpq $0x0, 0x18(%rbx)
je 0x8704f
movq 0x20(%rbx), %rsi
movq (%r9), %rdi
xorl %edx, %edx
callq *0x8(%r9)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
jmp 0x871ad
leaq 0x1(%r15), %r14
cmpq %r14, %rax
jne 0x870c5
movq 0x18(%rbx), %rax
cmpq %r14, %rsi
jne 0x8712b
testq %rax, %rax
jne 0x87097
jmp 0x870b0
leaq -0x1(%r15), %r12
movq %rax, %rsi
xorq %r12, %rsi
xorq %r12, %rdx
movq 0x18(%rbx), %rcx
orq %rsi, %rdx
jne 0x87102
testq %rcx, %rcx
je 0x870b0
movq 0x20(%rbx), %rsi
movq (%r9), %rdi
xorl %edx, %edx
callq *0x8(%r9)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
movl $0x1, %ebp
jmp 0x871af
cmpq %r14, %rsi
jne 0x8714f
cmpq $0x0, 0x18(%rbx)
je 0x870ee
movq 0x20(%rbx), %rsi
movq (%r9), %rdi
xorl %edx, %edx
callq *0x8(%r9)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
decq %r15
movq %r15, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
movl $0x2, %ebp
jmp 0x871af
cmpq %r12, %rax
jne 0x87185
testq %rcx, %rcx
je 0x87125
movq 0x20(%rbx), %rsi
movq (%r9), %rdi
xorl %edx, %edx
callq *0x8(%r9)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r12, 0x10(%rbx)
jmp 0x871aa
testq %rax, %rax
je 0x87149
movq 0x20(%rbx), %rsi
movq (%r9), %rdi
xorl %edx, %edx
callq *0x8(%r9)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r14, 0x10(%rbx)
jmp 0x871aa
leaq 0x41(%rcx), %rdi
shrq $0x6, %rdi
movq 0x18(%r13), %rax
cmpq %rdi, %rax
cmovgq %rax, %rdi
movq 0x18(%r12), %rdx
leaq (%rdi,%rdx), %rsi
movabsq $0x1ffffffffffffffd, %rax # imm = 0x1FFFFFFFFFFFFFFD
cmpq %rax, %rsi
jbe 0x871c0
movl $0x1, %r14d
jmp 0x8728b
testq %rcx, %rcx
je 0x871a3
movq 0x20(%rbx), %rsi
movq (%r9), %rdi
xorl %edx, %edx
callq *0x8(%r9)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
incq %r15
movq %r15, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, 0x30(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x4(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x8(,%rsi,8), %rdx
movq (%r9), %rdi
xorl %esi, %esi
movq %r9, 0x10(%rsp)
callq *0x8(%r9)
movl $0x2, %r14d
testq %rax, %rax
je 0x8728b
movq 0x18(%rsp), %r14
subq 0x18(%r13), %r14
leaq (,%r14,8), %rdx
movq %rax, %rdi
movq %rax, 0x28(%rsp)
xorl %esi, %esi
callq 0xe340
movq 0x28(%rsp), %rax
leaq (%rax,%r14,8), %rdi
movq %rax, %r14
movq 0x18(%r13), %rdx
movq 0x20(%r13), %rsi
shlq $0x3, %rdx
callq 0xe5a0
movq 0x30(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x83e5c
testl %eax, %eax
jne 0x87273
movq 0x20(%rbx), %rsi
movq 0x20(%r12), %r8
movq 0x10(%rsp), %rdi
movq %r14, %rdx
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %r9
callq 0x8548e
testl %eax, %eax
je 0x872d8
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *0x8(%rax)
movl $0x2, %r14d
jmp 0x8728b
movl $0x20, %ebp
cmpl $0x2, %r14d
je 0x872a6
testl %r14d, %r14d
jne 0x871af
movl %eax, %ebp
jmp 0x871af
cmpq $0x0, 0x18(%rbx)
je 0x872c8
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
jmp 0x871af
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
movq %r14, %rsi
jle 0x87300
xorl %eax, %eax
cmpq $0x0, (%rsi,%rax,8)
jne 0x872f8
incq %rax
cmpq %rax, %rcx
jne 0x872e7
jmp 0x87300
movq 0x20(%rbx), %rax
orq $0x1, (%rax)
movq (%rbx), %rax
movq (%rax), %rdi
xorl %r14d, %r14d
xorl %edx, %edx
callq *0x8(%rax)
movq 0x10(%r13), %rax
subq 0x10(%r12), %rax
addq $0x40, %rax
movq %rax, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x84148
jmp 0x8728b
| __bf_div:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r12, rdx
mov rbx, rdi
mov r15, 7FFFFFFFFFFFFFFFh
mov ebp, [rdx+8]
xor ebp, [rsi+8]
mov r9, [rdi]
mov rax, [rsi+10h]
lea rdx, [r15-2]
cmp rax, rdx
jg short loc_87020
mov r13, rsi
mov rsi, [r12+10h]
cmp rsi, rdx
jle short loc_8705F
loc_87020:
cmp rax, r15
jz short loc_8702F
mov rdx, [r12+10h]
cmp rdx, r15
jnz short loc_8707C
loc_8702F:
cmp qword ptr [rbx+18h], 0
jz short loc_8704F
mov rsi, [rbx+20h]
mov rdi, [r9]
xor edx, edx
call qword ptr [r9+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8704F:
mov [rbx+10h], r15
mov dword ptr [rbx+8], 0
jmp loc_871AD
loc_8705F:
lea r14, [r15+1]
cmp rax, r14
jnz short loc_870C5
mov rax, [rbx+18h]
cmp rsi, r14
jnz loc_8712B
test rax, rax
jnz short loc_87097
jmp short loc_870B0
loc_8707C:
lea r12, [r15-1]
mov rsi, rax
xor rsi, r12
xor rdx, r12
mov rcx, [rbx+18h]
or rdx, rsi
jnz short loc_87102
test rcx, rcx
jz short loc_870B0
loc_87097:
mov rsi, [rbx+20h]
mov rdi, [r9]
xor edx, edx
call qword ptr [r9+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_870B0:
mov [rbx+10h], r15
mov dword ptr [rbx+8], 0
mov ebp, 1
jmp loc_871AF
loc_870C5:
cmp rsi, r14
jnz loc_8714F
cmp qword ptr [rbx+18h], 0
jz short loc_870EE
mov rsi, [rbx+20h]
mov rdi, [r9]
xor edx, edx
call qword ptr [r9+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_870EE:
dec r15
mov [rbx+10h], r15
mov [rbx+8], ebp
mov ebp, 2
jmp loc_871AF
loc_87102:
cmp rax, r12
jnz short loc_87185
test rcx, rcx
jz short loc_87125
mov rsi, [rbx+20h]
mov rdi, [r9]
xor edx, edx
call qword ptr [r9+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_87125:
mov [rbx+10h], r12
jmp short loc_871AA
loc_8712B:
test rax, rax
jz short loc_87149
mov rsi, [rbx+20h]
mov rdi, [r9]
xor edx, edx
call qword ptr [r9+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_87149:
mov [rbx+10h], r14
jmp short loc_871AA
loc_8714F:
lea rdi, [rcx+41h]
shr rdi, 6
mov rax, [r13+18h]
cmp rax, rdi
cmovg rdi, rax
mov rdx, [r12+18h]
lea rsi, [rdi+rdx]
mov rax, 1FFFFFFFFFFFFFFDh
cmp rsi, rax
jbe short loc_871C0
mov r14d, 1
jmp loc_8728B
loc_87185:
test rcx, rcx
jz short loc_871A3
mov rsi, [rbx+20h]
mov rdi, [r9]
xor edx, edx
call qword ptr [r9+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_871A3:
inc r15
mov [rbx+10h], r15
loc_871AA:
mov [rbx+8], ebp
loc_871AD:
xor ebp, ebp
loc_871AF:
mov eax, ebp
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_871C0:
mov [rsp+68h+var_38], rdi
mov [rsp+68h+var_60], rdx
mov [rsp+68h+var_48], rcx
mov [rsp+68h+var_64], r8d
mov [rsp+68h+var_50], rsi
lea rdx, ds:8[rsi*8]
mov rdi, [r9]
xor esi, esi
mov [rsp+68h+var_58], r9
call qword ptr [r9+8]
mov r14d, 2
test rax, rax
jz loc_8728B
mov r14, [rsp+68h+var_50]
sub r14, [r13+18h]
lea rdx, ds:0[r14*8]
mov rdi, rax
mov [rsp+68h+var_40], rax
xor esi, esi
call _memset
mov rax, [rsp+68h+var_40]
lea rdi, [rax+r14*8]
mov r14, rax
mov rdx, [r13+18h]
mov rsi, [r13+20h]
shl rdx, 3
call _memcpy
mov rsi, [rsp+68h+var_38]
inc rsi
mov rdi, rbx
call bf_resize
test eax, eax
jnz short loc_87273
mov rsi, [rbx+20h]
mov r8, [r12+20h]
mov rdi, [rsp+68h+var_58]
mov rdx, r14
mov rcx, [rsp+68h+var_50]
mov r9, [rsp+68h+var_60]
call mp_divnorm
test eax, eax
jz short loc_872D8
loc_87273:
mov rax, [rsp+68h+var_58]
mov rdi, [rax]
mov rsi, r14
xor edx, edx
call qword ptr [rax+8]
mov r14d, 2
jmp short $+2
loc_8728B:
mov ebp, 20h ; ' '
cmp r14d, 2
jz short loc_872A6
test r14d, r14d
jnz loc_871AF
mov ebp, eax
jmp loc_871AF
loc_872A6:
cmp qword ptr [rbx+18h], 0
jz short loc_872C8
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_872C8:
mov [rbx+10h], r15
mov dword ptr [rbx+8], 0
jmp loc_871AF
loc_872D8:
mov rcx, [rsp+68h+var_60]
test rcx, rcx
mov rsi, r14
jle short loc_87300
xor eax, eax
loc_872E7:
cmp qword ptr [rsi+rax*8], 0
jnz short loc_872F8
inc rax
cmp rcx, rax
jnz short loc_872E7
jmp short loc_87300
loc_872F8:
mov rax, [rbx+20h]
or qword ptr [rax], 1
loc_87300:
mov rax, [rbx]
mov rdi, [rax]
xor r14d, r14d
xor edx, edx
call qword ptr [rax+8]
mov rax, [r13+10h]
sub rax, [r12+10h]
add rax, 40h ; '@'
mov [rbx+10h], rax
mov [rbx+8], ebp
mov rdi, rbx
mov rsi, [rsp+68h+var_48]
mov edx, [rsp+68h+var_64]
call bf_normalize_and_round
jmp loc_8728B
| long long _bf_div(_QWORD **a1, long long a2, long long a3, long long a4, long long a5)
{
int v7; // ebp
_QWORD *v8; // r9
long long v9; // rax
long long v11; // rsi
long long v12; // rdx
_QWORD *v13; // rax
_QWORD *v14; // rcx
unsigned int v15; // ebp
signed long long v16; // rdi
long long v17; // rdx
long long v18; // rax
int v19; // r14d
unsigned long long v21; // r14
long long v22; // rax
unsigned int v23; // [rsp+4h] [rbp-64h]
long long v24; // [rsp+8h] [rbp-60h]
_QWORD *v25; // [rsp+10h] [rbp-58h]
unsigned long long v26; // [rsp+18h] [rbp-50h]
unsigned long long *v28; // [rsp+28h] [rbp-40h]
v7 = *(_DWORD *)(a2 + 8) ^ *(_DWORD *)(a3 + 8);
v8 = *a1;
v9 = *(_QWORD *)(a2 + 16);
if ( v9 > 0x7FFFFFFFFFFFFFFDLL || (v11 = *(_QWORD *)(a3 + 16), v11 > 0x7FFFFFFFFFFFFFFDLL) )
{
if ( v9 == 0x7FFFFFFFFFFFFFFFLL || (v12 = *(_QWORD *)(a3 + 16), v12 == 0x7FFFFFFFFFFFFFFFLL) )
{
if ( a1[3] )
{
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))v8[1])(*v8, a1[4], 0LL);
a1[3] = 0LL;
}
a1[2] = (_QWORD *)0x7FFFFFFFFFFFFFFFLL;
*((_DWORD *)a1 + 2) = 0;
return 0;
}
v14 = a1[3];
if ( !(v9 ^ 0x7FFFFFFFFFFFFFFELL | v12 ^ 0x7FFFFFFFFFFFFFFELL) )
{
if ( !v14 )
{
LABEL_15:
a1[2] = (_QWORD *)0x7FFFFFFFFFFFFFFFLL;
*((_DWORD *)a1 + 2) = 0;
return 1;
}
LABEL_14:
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))v8[1])(*v8, a1[4], 0LL);
a1[3] = 0LL;
goto LABEL_15;
}
if ( v9 == 0x7FFFFFFFFFFFFFFELL )
{
if ( v14 )
{
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))v8[1])(*v8, a1[4], 0LL);
a1[3] = 0LL;
}
a1[2] = (_QWORD *)0x7FFFFFFFFFFFFFFELL;
}
else
{
if ( v14 )
{
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))v8[1])(*v8, a1[4], 0LL);
a1[3] = 0LL;
}
a1[2] = (_QWORD *)0x8000000000000000LL;
}
goto LABEL_34;
}
if ( v9 == 0x8000000000000000LL )
{
v13 = a1[3];
if ( v11 == 0x8000000000000000LL )
{
if ( !v13 )
goto LABEL_15;
goto LABEL_14;
}
if ( v13 )
{
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))v8[1])(*v8, a1[4], 0LL);
a1[3] = 0LL;
}
a1[2] = (_QWORD *)0x8000000000000000LL;
LABEL_34:
*((_DWORD *)a1 + 2) = v7;
return 0;
}
if ( v11 == 0x8000000000000000LL )
{
if ( a1[3] )
{
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))v8[1])(*v8, a1[4], 0LL);
a1[3] = 0LL;
}
a1[2] = (_QWORD *)0x7FFFFFFFFFFFFFFELL;
*((_DWORD *)a1 + 2) = v7;
return 2;
}
else
{
v16 = (unsigned long long)(a4 + 65) >> 6;
if ( *(_QWORD *)(a2 + 24) > v16 )
v16 = *(_QWORD *)(a2 + 24);
v17 = *(_QWORD *)(a3 + 24);
LODWORD(v18) = -3;
if ( (unsigned long long)(v16 + v17) <= 0x1FFFFFFFFFFFFFFDLL )
{
v24 = v17;
v23 = a5;
v26 = v16 + v17;
v25 = v8;
v18 = ((long long ( *)(_QWORD, _QWORD, signed long long))v8[1])(*v8, 0LL, 8 * (v16 + v17) + 8);
v19 = 2;
if ( v18 )
{
v21 = v26 - *(_QWORD *)(a2 + 24);
v28 = (unsigned long long *)v18;
memset(v18, 0LL, 8 * v21);
memcpy(&v28[v21], *(_QWORD *)(a2 + 32), 8LL * *(_QWORD *)(a2 + 24));
if ( (unsigned int)bf_resize((long long)a1, v16 + 1)
|| (unsigned int)mp_divnorm(v25, (long long)a1[4], v28, v26, *(_QWORD **)(a3 + 32), v24) )
{
LODWORD(v18) = ((long long ( *)(_QWORD, unsigned long long *, _QWORD))v25[1])(*v25, v28, 0LL);
v19 = 2;
}
else
{
if ( v24 > 0 )
{
v22 = 0LL;
while ( !v28[v22] )
{
if ( v24 == ++v22 )
goto LABEL_53;
}
*a1[4] |= 1uLL;
}
LABEL_53:
v19 = 0;
((void ( *)(_QWORD, unsigned long long *, _QWORD))(*a1)[1])(**a1, v28, 0LL);
a1[2] = (_QWORD *)(*(_QWORD *)(a2 + 16) - *(_QWORD *)(a3 + 16) + 64LL);
*((_DWORD *)a1 + 2) = v7;
LODWORD(v18) = bf_normalize_and_round(a1, a4, v23);
}
}
}
else
{
v19 = 1;
}
v15 = 32;
if ( v19 == 2 )
{
if ( a1[3] )
{
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD, long long, long long, _QWORD *))(*a1)[1])(
**a1,
a1[4],
0LL,
a4,
a5,
v8);
a1[3] = 0LL;
}
a1[2] = (_QWORD *)0x7FFFFFFFFFFFFFFFLL;
*((_DWORD *)a1 + 2) = 0;
}
else if ( !v19 )
{
return (unsigned int)v18;
}
}
return v15;
}
| __bf_div:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R12,RDX
MOV RBX,RDI
MOV R15,0x7fffffffffffffff
MOV EBP,dword ptr [RDX + 0x8]
XOR EBP,dword ptr [RSI + 0x8]
MOV R9,qword ptr [RDI]
MOV RAX,qword ptr [RSI + 0x10]
LEA RDX,[R15 + -0x2]
CMP RAX,RDX
JG 0x00187020
MOV R13,RSI
MOV RSI,qword ptr [R12 + 0x10]
CMP RSI,RDX
JLE 0x0018705f
LAB_00187020:
CMP RAX,R15
JZ 0x0018702f
MOV RDX,qword ptr [R12 + 0x10]
CMP RDX,R15
JNZ 0x0018707c
LAB_0018702f:
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018704f
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [R9]
XOR EDX,EDX
CALL qword ptr [R9 + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018704f:
MOV qword ptr [RBX + 0x10],R15
MOV dword ptr [RBX + 0x8],0x0
JMP 0x001871ad
LAB_0018705f:
LEA R14,[R15 + 0x1]
CMP RAX,R14
JNZ 0x001870c5
MOV RAX,qword ptr [RBX + 0x18]
CMP RSI,R14
JNZ 0x0018712b
TEST RAX,RAX
JNZ 0x00187097
JMP 0x001870b0
LAB_0018707c:
LEA R12,[R15 + -0x1]
MOV RSI,RAX
XOR RSI,R12
XOR RDX,R12
MOV RCX,qword ptr [RBX + 0x18]
OR RDX,RSI
JNZ 0x00187102
TEST RCX,RCX
JZ 0x001870b0
LAB_00187097:
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [R9]
XOR EDX,EDX
CALL qword ptr [R9 + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_001870b0:
MOV qword ptr [RBX + 0x10],R15
MOV dword ptr [RBX + 0x8],0x0
MOV EBP,0x1
JMP 0x001871af
LAB_001870c5:
CMP RSI,R14
JNZ 0x0018714f
CMP qword ptr [RBX + 0x18],0x0
JZ 0x001870ee
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [R9]
XOR EDX,EDX
CALL qword ptr [R9 + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_001870ee:
DEC R15
MOV qword ptr [RBX + 0x10],R15
MOV dword ptr [RBX + 0x8],EBP
MOV EBP,0x2
JMP 0x001871af
LAB_00187102:
CMP RAX,R12
JNZ 0x00187185
TEST RCX,RCX
JZ 0x00187125
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [R9]
XOR EDX,EDX
CALL qword ptr [R9 + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_00187125:
MOV qword ptr [RBX + 0x10],R12
JMP 0x001871aa
LAB_0018712b:
TEST RAX,RAX
JZ 0x00187149
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [R9]
XOR EDX,EDX
CALL qword ptr [R9 + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_00187149:
MOV qword ptr [RBX + 0x10],R14
JMP 0x001871aa
LAB_0018714f:
LEA RDI,[RCX + 0x41]
SHR RDI,0x6
MOV RAX,qword ptr [R13 + 0x18]
CMP RAX,RDI
CMOVG RDI,RAX
MOV RDX,qword ptr [R12 + 0x18]
LEA RSI,[RDI + RDX*0x1]
MOV RAX,0x1ffffffffffffffd
CMP RSI,RAX
JBE 0x001871c0
MOV R14D,0x1
JMP 0x0018728b
LAB_00187185:
TEST RCX,RCX
JZ 0x001871a3
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [R9]
XOR EDX,EDX
CALL qword ptr [R9 + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_001871a3:
INC R15
MOV qword ptr [RBX + 0x10],R15
LAB_001871aa:
MOV dword ptr [RBX + 0x8],EBP
LAB_001871ad:
XOR EBP,EBP
LAB_001871af:
MOV EAX,EBP
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001871c0:
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP + 0x20],RCX
MOV dword ptr [RSP + 0x4],R8D
MOV qword ptr [RSP + 0x18],RSI
LEA RDX,[0x8 + RSI*0x8]
MOV RDI,qword ptr [R9]
XOR ESI,ESI
MOV qword ptr [RSP + 0x10],R9
CALL qword ptr [R9 + 0x8]
MOV R14D,0x2
TEST RAX,RAX
JZ 0x0018728b
MOV R14,qword ptr [RSP + 0x18]
SUB R14,qword ptr [R13 + 0x18]
LEA RDX,[R14*0x8]
MOV RDI,RAX
MOV qword ptr [RSP + 0x28],RAX
XOR ESI,ESI
CALL 0x0010e340
MOV RAX,qword ptr [RSP + 0x28]
LEA RDI,[RAX + R14*0x8]
MOV R14,RAX
MOV RDX,qword ptr [R13 + 0x18]
MOV RSI,qword ptr [R13 + 0x20]
SHL RDX,0x3
CALL 0x0010e5a0
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
MOV RDI,RBX
CALL 0x00183e5c
TEST EAX,EAX
JNZ 0x00187273
MOV RSI,qword ptr [RBX + 0x20]
MOV R8,qword ptr [R12 + 0x20]
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,R14
MOV RCX,qword ptr [RSP + 0x18]
MOV R9,qword ptr [RSP + 0x8]
CALL 0x0018548e
TEST EAX,EAX
JZ 0x001872d8
LAB_00187273:
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX]
MOV RSI,R14
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV R14D,0x2
JMP 0x0018728b
LAB_0018728b:
MOV EBP,0x20
CMP R14D,0x2
JZ 0x001872a6
TEST R14D,R14D
JNZ 0x001871af
MOV EBP,EAX
JMP 0x001871af
LAB_001872a6:
CMP qword ptr [RBX + 0x18],0x0
JZ 0x001872c8
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_001872c8:
MOV qword ptr [RBX + 0x10],R15
MOV dword ptr [RBX + 0x8],0x0
JMP 0x001871af
LAB_001872d8:
MOV RCX,qword ptr [RSP + 0x8]
TEST RCX,RCX
MOV RSI,R14
JLE 0x00187300
XOR EAX,EAX
LAB_001872e7:
CMP qword ptr [RSI + RAX*0x8],0x0
JNZ 0x001872f8
INC RAX
CMP RCX,RAX
JNZ 0x001872e7
JMP 0x00187300
LAB_001872f8:
MOV RAX,qword ptr [RBX + 0x20]
OR qword ptr [RAX],0x1
LAB_00187300:
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX]
XOR R14D,R14D
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R13 + 0x10]
SUB RAX,qword ptr [R12 + 0x10]
ADD RAX,0x40
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x8],EBP
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x20]
MOV EDX,dword ptr [RSP + 0x4]
CALL 0x00184148
JMP 0x0018728b
|
int4 __bf_div(long *param_1,long param_2,long param_3,long param_4,int4 param_5)
{
ulong uVar1;
int8 *puVar2;
long lVar3;
int iVar4;
long lVar5;
void *__s;
uint uVar6;
ulong uVar7;
long lVar8;
uVar6 = *(uint *)(param_3 + 8) ^ *(uint *)(param_2 + 8);
puVar2 = (int8 *)*param_1;
lVar5 = *(long *)(param_2 + 0x10);
if ((lVar5 < 0x7ffffffffffffffe) &&
(lVar8 = *(long *)(param_3 + 0x10), lVar8 < 0x7ffffffffffffffe)) {
if (lVar5 != -0x8000000000000000) {
if (lVar8 == -0x8000000000000000) {
if (param_1[3] != 0) {
lVar5 = (*(code *)puVar2[1])(*puVar2,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = 0x7ffffffffffffffe;
*(uint *)(param_1 + 1) = uVar6;
return 2;
}
uVar7 = param_4 + 0x41U >> 6;
if ((long)uVar7 < (long)*(ulong *)(param_2 + 0x18)) {
uVar7 = *(ulong *)(param_2 + 0x18);
}
lVar5 = *(long *)(param_3 + 0x18);
uVar1 = uVar7 + lVar5;
__s = (void *)0x1ffffffffffffffd;
if (uVar1 < 0x1ffffffffffffffe) {
__s = (void *)(*(code *)puVar2[1])(*puVar2,0,uVar1 * 8 + 8);
iVar4 = 2;
if (__s != (void *)0x0) {
lVar8 = uVar1 - *(long *)(param_2 + 0x18);
memset(__s,0,lVar8 * 8);
memcpy((void *)((long)__s + lVar8 * 8),*(void **)(param_2 + 0x20),
*(long *)(param_2 + 0x18) << 3);
iVar4 = bf_resize(param_1,uVar7 + 1);
if ((iVar4 == 0) &&
(iVar4 = mp_divnorm(puVar2,param_1[4],__s,uVar1,*(int8 *)(param_3 + 0x20),lVar5),
iVar4 == 0)) {
if (0 < lVar5) {
lVar8 = 0;
do {
if (*(long *)((long)__s + lVar8 * 8) != 0) {
*(ulong *)param_1[4] = *(ulong *)param_1[4] | 1;
break;
}
lVar8 = lVar8 + 1;
} while (lVar5 != lVar8);
}
iVar4 = 0;
(*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,__s,0);
param_1[2] = (*(long *)(param_2 + 0x10) - *(long *)(param_3 + 0x10)) + 0x40;
*(uint *)(param_1 + 1) = uVar6;
__s = (void *)bf_normalize_and_round(param_1,param_4,param_5);
}
else {
__s = (void *)(*(code *)puVar2[1])(*puVar2,__s,0);
iVar4 = 2;
}
}
}
else {
iVar4 = 1;
}
if (iVar4 == 2) {
if (param_1[3] != 0) {
lVar5 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = 0x7fffffffffffffff;
*(int4 *)(param_1 + 1) = 0;
return 0x20;
}
if (iVar4 == 0) {
return (int)__s;
}
return 0x20;
}
lVar3 = param_1[3];
if (lVar8 == -0x8000000000000000) {
joined_r0x00187095:
if (lVar3 != 0) {
lVar5 = (*(code *)puVar2[1])(*puVar2,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = 0x7fffffffffffffff;
*(int4 *)(param_1 + 1) = 0;
return 1;
}
if (lVar3 != 0) {
lVar5 = (*(code *)puVar2[1])(*puVar2,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = -0x8000000000000000;
}
else {
if ((lVar5 == 0x7fffffffffffffff) || (*(long *)(param_3 + 0x10) == 0x7fffffffffffffff)) {
if (param_1[3] != 0) {
lVar5 = (*(code *)puVar2[1])(*puVar2,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = 0x7fffffffffffffff;
*(int4 *)(param_1 + 1) = 0;
return 0;
}
lVar3 = param_1[3];
if (*(long *)(param_3 + 0x10) == 0x7ffffffffffffffe && lVar5 == 0x7ffffffffffffffe)
goto joined_r0x00187095;
if (lVar5 == 0x7ffffffffffffffe) {
if (lVar3 != 0) {
lVar5 = (*(code *)puVar2[1])(*puVar2,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = 0x7ffffffffffffffe;
}
else {
if (lVar3 != 0) {
lVar5 = (*(code *)puVar2[1])(*puVar2,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = -0x8000000000000000;
}
}
*(uint *)(param_1 + 1) = uVar6;
return 0;
}
| |
25,988 | _bf_div | bluesky950520[P]quickjs/libbf.c | static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
bf_flags_t flags)
{
bf_context_t *s = r->ctx;
int ret, r_sign;
limb_t n, nb, precl;
r_sign = a->sign ^ b->sign;
if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
bf_set_nan(r);
return 0;
} else if (a->expn == BF_EXP_INF && b->expn == BF_EXP_INF) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else if (a->expn == BF_EXP_INF) {
bf_set_inf(r, r_sign);
return 0;
} else {
bf_set_zero(r, r_sign);
return 0;
}
} else if (a->expn == BF_EXP_ZERO) {
if (b->expn == BF_EXP_ZERO) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else {
bf_set_zero(r, r_sign);
return 0;
}
} else if (b->expn == BF_EXP_ZERO) {
bf_set_inf(r, r_sign);
return BF_ST_DIVIDE_ZERO;
}
/* number of limbs of the quotient (2 extra bits for rounding) */
precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
nb = b->len;
n = bf_max(a->len, precl);
{
limb_t *taba, na;
slimb_t d;
na = n + nb;
#if LIMB_LOG2_BITS == 6
if (na >= (SIZE_MAX / sizeof(limb_t)) - 1) {
return BF_ST_MEM_ERROR; /* Return memory error status */
}
#endif
taba = bf_malloc(s, (na + 1) * sizeof(limb_t));
if (!taba)
goto fail;
d = na - a->len;
memset(taba, 0, d * sizeof(limb_t));
memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
if (bf_resize(r, n + 1))
goto fail1;
if (mp_divnorm(s, r->tab, taba, na, b->tab, nb)) {
fail1:
bf_free(s, taba);
goto fail;
}
/* see if non zero remainder */
if (mp_scan_nz(taba, nb))
r->tab[0] |= 1;
bf_free(r->ctx, taba);
r->expn = a->expn - b->expn + LIMB_BITS;
r->sign = r_sign;
ret = bf_normalize_and_round(r, prec, flags);
}
return ret;
fail:
bf_set_nan(r);
return BF_ST_MEM_ERROR;
} | O2 | c | _bf_div:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movabsq $0x7ffffffffffffffd, %rax # imm = 0x7FFFFFFFFFFFFFFD
movl 0x8(%rdx), %ebp
xorl 0x8(%rsi), %ebp
movq 0x10(%rsi), %rcx
cmpq %rax, %rcx
jle 0x711c2
leaq 0x2(%rax), %rdx
cmpq %rdx, %rcx
je 0x711d5
movq 0x10(%r12), %rdx
jmp 0x711cc
movq 0x10(%r12), %rdx
cmpq %rax, %rdx
jle 0x711e2
leaq 0x2(%rax), %rsi
cmpq %rsi, %rdx
jne 0x711f2
movq %rbx, %rdi
callq 0x6ea51
xorl %r14d, %r14d
jmp 0x71222
addq $0x3, %rax
cmpq %rax, %rcx
jne 0x7120f
cmpq %rax, %rdx
je 0x71203
jmp 0x71245
incq %rax
movq %rcx, %rsi
xorq %rax, %rsi
xorq %rax, %rdx
orq %rsi, %rdx
jne 0x71234
movq %rbx, %rdi
callq 0x6ea51
pushq $0x1
jmp 0x71220
cmpq %rax, %rdx
jne 0x71251
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6eac0
pushq $0x2
popq %r14
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rax, %rcx
jne 0x71245
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6eac0
jmp 0x711dd
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6ea96
jmp 0x711dd
movq %rsi, %r13
leaq 0x41(%r15), %rsi
shrq $0x6, %rsi
movq 0x18(%r12), %rcx
movq 0x18(%r13), %rax
cmpq %rsi, %rax
cmovgq %rax, %rsi
leaq (%rsi,%rcx), %rdx
pushq $0x20
popq %r14
movabsq $0x1ffffffffffffffd, %rax # imm = 0x1FFFFFFFFFFFFFFD
cmpq %rax, %rdx
ja 0x71222
movq %rsi, 0x30(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movq (%rbx), %rax
movq %rdx, 0x20(%rsp)
leaq 0x8(,%rdx,8), %rdx
movq (%rax), %rdi
xorl %esi, %esi
movq %rax, 0x18(%rsp)
callq *0x8(%rax)
testq %rax, %rax
je 0x71344
movq 0x20(%rsp), %rcx
subq 0x18(%r13), %rcx
movq %rcx, 0x28(%rsp)
leaq (,%rcx,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
movq %rax, (%rsp)
callq 0xe350
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq 0x18(%r13), %rdx
movq 0x20(%r13), %rsi
shlq $0x3, %rdx
callq 0xe5b0
movq 0x30(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x6e993
testl %eax, %eax
jne 0x71333
movq 0x20(%rbx), %rsi
movq 0x20(%r12), %r8
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %r9
callq 0x6fcea
testl %eax, %eax
je 0x71351
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x6ea51
jmp 0x71222
movq (%rsp), %rdi
movq %rdi, %r14
movq 0x10(%rsp), %rsi
callq 0x7020d
testq %rax, %rax
je 0x7136f
movq 0x20(%rbx), %rax
orq $0x1, (%rax)
movq (%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *0x8(%rax)
movq 0x10(%r13), %rax
subq 0x10(%r12), %rax
addq $0x40, %rax
movq %rax, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl 0xc(%rsp), %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6eb8b
| __bf_div:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, rcx
mov r12, rdx
mov rbx, rdi
mov rax, 7FFFFFFFFFFFFFFDh
mov ebp, [rdx+8]
xor ebp, [rsi+8]
mov rcx, [rsi+10h]
cmp rcx, rax
jle short loc_711C2
lea rdx, [rax+2]
cmp rcx, rdx
jz short loc_711D5
mov rdx, [r12+10h]
jmp short loc_711CC
loc_711C2:
mov rdx, [r12+10h]
cmp rdx, rax
jle short loc_711E2
loc_711CC:
lea rsi, [rax+2]
cmp rdx, rsi
jnz short loc_711F2
loc_711D5:
mov rdi, rbx
call bf_set_nan
loc_711DD:
xor r14d, r14d
jmp short loc_71222
loc_711E2:
add rax, 3
cmp rcx, rax
jnz short loc_7120F
cmp rdx, rax
jz short loc_71203
jmp short loc_71245
loc_711F2:
inc rax
mov rsi, rcx
xor rsi, rax
xor rdx, rax
or rdx, rsi
jnz short loc_71234
loc_71203:
mov rdi, rbx
call bf_set_nan
push 1
jmp short loc_71220
loc_7120F:
cmp rdx, rax
jnz short loc_71251
mov rdi, rbx
mov esi, ebp
call bf_set_inf
push 2
loc_71220:
pop r14
loc_71222:
mov eax, r14d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_71234:
cmp rcx, rax
jnz short loc_71245
mov rdi, rbx
mov esi, ebp
call bf_set_inf
jmp short loc_711DD
loc_71245:
mov rdi, rbx
mov esi, ebp
call bf_set_zero
jmp short loc_711DD
loc_71251:
mov r13, rsi
lea rsi, [r15+41h]
shr rsi, 6
mov rcx, [r12+18h]
mov rax, [r13+18h]
cmp rax, rsi
cmovg rsi, rax
lea rdx, [rsi+rcx]
push 20h ; ' '
pop r14
mov rax, 1FFFFFFFFFFFFFFDh
cmp rdx, rax
ja short loc_71222
mov [rsp+68h+var_38], rsi
mov [rsp+68h+var_58], rcx
mov [rsp+68h+var_5C], r8d
mov rax, [rbx]
mov [rsp+68h+var_48], rdx
lea rdx, ds:8[rdx*8]
mov rdi, [rax]
xor esi, esi
mov [rsp+68h+var_50], rax
call qword ptr [rax+8]
test rax, rax
jz loc_71344
mov rcx, [rsp+68h+var_48]
sub rcx, [r13+18h]
mov [rsp+68h+var_40], rcx
lea rdx, ds:0[rcx*8]
mov rdi, rax
xor esi, esi
mov [rsp+68h+var_68], rax
call _memset
mov rax, [rsp+68h+var_40]
mov rcx, [rsp+68h+var_68]
lea rdi, [rcx+rax*8]
mov rdx, [r13+18h]
mov rsi, [r13+20h]
shl rdx, 3
call _memcpy
mov rsi, [rsp+68h+var_38]
inc rsi
mov rdi, rbx
call bf_resize
test eax, eax
jnz short loc_71333
mov rsi, [rbx+20h]
mov r8, [r12+20h]
mov rdi, [rsp+68h+var_50]
mov rdx, [rsp+68h+var_68]
mov rcx, [rsp+68h+var_48]
mov r9, [rsp+68h+var_58]
call mp_divnorm
test eax, eax
jz short loc_71351
loc_71333:
mov rax, [rsp+68h+var_50]
mov rdi, [rax]
mov rsi, [rsp+68h+var_68]
xor edx, edx
call qword ptr [rax+8]
loc_71344:
mov rdi, rbx
call bf_set_nan
jmp loc_71222
loc_71351:
mov rdi, [rsp+68h+var_68]
mov r14, rdi
mov rsi, [rsp+68h+var_58]
call mp_scan_nz
test rax, rax
jz short loc_7136F
mov rax, [rbx+20h]
or qword ptr [rax], 1
loc_7136F:
mov rax, [rbx]
mov rdi, [rax]
mov rsi, r14
xor edx, edx
call qword ptr [rax+8]
mov rax, [r13+10h]
sub rax, [r12+10h]
add rax, 40h ; '@'
mov [rbx+10h], rax
mov [rbx+8], ebp
mov rdi, rbx
mov rsi, r15
mov edx, [rsp+68h+var_5C]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp bf_normalize_and_round
| long long _bf_div(_QWORD *a1, long long a2, long long a3, long long a4, unsigned int a5)
{
int v7; // ebp
long long v8; // rcx
long long v9; // rdx
unsigned int v10; // r14d
signed long long v13; // rsi
long long v14; // rcx
long long v15; // rax
_QWORD *v17; // [rsp+0h] [rbp-68h]
unsigned long long v19; // [rsp+10h] [rbp-58h]
_QWORD *v20; // [rsp+18h] [rbp-50h]
unsigned long long v21; // [rsp+20h] [rbp-48h]
unsigned long long v22; // [rsp+28h] [rbp-40h]
v7 = *(_DWORD *)(a2 + 8) ^ *(_DWORD *)(a3 + 8);
v8 = *(_QWORD *)(a2 + 16);
if ( v8 > 0x7FFFFFFFFFFFFFFDLL )
{
if ( v8 == 0x7FFFFFFFFFFFFFFFLL )
{
LABEL_6:
bf_set_nan((long long)a1);
return 0;
}
v9 = *(_QWORD *)(a3 + 16);
goto LABEL_5;
}
v9 = *(_QWORD *)(a3 + 16);
if ( v9 > 0x7FFFFFFFFFFFFFFDLL )
{
LABEL_5:
if ( v9 == 0x7FFFFFFFFFFFFFFFLL )
goto LABEL_6;
if ( !(v8 ^ 0x7FFFFFFFFFFFFFFELL | v9 ^ 0x7FFFFFFFFFFFFFFELL) )
goto LABEL_12;
if ( v8 == 0x7FFFFFFFFFFFFFFELL )
{
bf_set_inf((long long)a1, v7);
return 0;
}
goto LABEL_19;
}
if ( v8 == 0x8000000000000000LL )
{
if ( v9 == 0x8000000000000000LL )
{
LABEL_12:
bf_set_nan((long long)a1);
return 1;
}
LABEL_19:
bf_set_zero((long long)a1, v7);
return 0;
}
if ( v9 == 0x8000000000000000LL )
{
bf_set_inf((long long)a1, v7);
return 2;
}
v13 = (unsigned long long)(a4 + 65) >> 6;
v14 = *(_QWORD *)(a3 + 24);
if ( *(_QWORD *)(a2 + 24) > v13 )
v13 = *(_QWORD *)(a2 + 24);
v10 = 32;
if ( (unsigned long long)(v13 + v14) > 0x1FFFFFFFFFFFFFFDLL )
return v10;
v19 = *(_QWORD *)(a3 + 24);
v21 = v13 + v14;
v20 = (_QWORD *)*a1;
v15 = (*(long long ( **)(_QWORD, _QWORD, signed long long))(*a1 + 8LL))(
*(_QWORD *)*a1,
0LL,
8 * (v13 + v14) + 8);
if ( !v15 )
{
LABEL_27:
bf_set_nan((long long)a1);
return v10;
}
v22 = v21 - *(_QWORD *)(a2 + 24);
v17 = (_QWORD *)v15;
memset(v15, 0LL, 8 * v22);
memcpy(&v17[v22], *(_QWORD *)(a2 + 32), 8LL * *(_QWORD *)(a2 + 24));
if ( (unsigned int)bf_resize((long long)a1, v13 + 1)
|| (unsigned int)mp_divnorm(v20, a1[4], v17, v21, *(_QWORD *)(a3 + 32), v19) )
{
((void ( *)(_QWORD, _QWORD *, _QWORD))v20[1])(*v20, v17, 0LL);
goto LABEL_27;
}
if ( mp_scan_nz((long long)v17, v19) )
*(_QWORD *)a1[4] |= 1uLL;
(*(void ( **)(_QWORD, _QWORD *, _QWORD))(*a1 + 8LL))(*(_QWORD *)*a1, v17, 0LL);
a1[2] = *(_QWORD *)(a2 + 16) - *(_QWORD *)(a3 + 16) + 64LL;
*((_DWORD *)a1 + 2) = v7;
return bf_normalize_and_round(a1, a4, a5);
}
| __bf_div:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,RCX
MOV R12,RDX
MOV RBX,RDI
MOV RAX,0x7ffffffffffffffd
MOV EBP,dword ptr [RDX + 0x8]
XOR EBP,dword ptr [RSI + 0x8]
MOV RCX,qword ptr [RSI + 0x10]
CMP RCX,RAX
JLE 0x001711c2
LEA RDX,[RAX + 0x2]
CMP RCX,RDX
JZ 0x001711d5
MOV RDX,qword ptr [R12 + 0x10]
JMP 0x001711cc
LAB_001711c2:
MOV RDX,qword ptr [R12 + 0x10]
CMP RDX,RAX
JLE 0x001711e2
LAB_001711cc:
LEA RSI,[RAX + 0x2]
CMP RDX,RSI
JNZ 0x001711f2
LAB_001711d5:
MOV RDI,RBX
CALL 0x0016ea51
LAB_001711dd:
XOR R14D,R14D
JMP 0x00171222
LAB_001711e2:
ADD RAX,0x3
CMP RCX,RAX
JNZ 0x0017120f
CMP RDX,RAX
JZ 0x00171203
JMP 0x00171245
LAB_001711f2:
INC RAX
MOV RSI,RCX
XOR RSI,RAX
XOR RDX,RAX
OR RDX,RSI
JNZ 0x00171234
LAB_00171203:
MOV RDI,RBX
CALL 0x0016ea51
PUSH 0x1
JMP 0x00171220
LAB_0017120f:
CMP RDX,RAX
JNZ 0x00171251
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0016eac0
PUSH 0x2
LAB_00171220:
POP R14
LAB_00171222:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00171234:
CMP RCX,RAX
JNZ 0x00171245
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0016eac0
JMP 0x001711dd
LAB_00171245:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0016ea96
JMP 0x001711dd
LAB_00171251:
MOV R13,RSI
LEA RSI,[R15 + 0x41]
SHR RSI,0x6
MOV RCX,qword ptr [R12 + 0x18]
MOV RAX,qword ptr [R13 + 0x18]
CMP RAX,RSI
CMOVG RSI,RAX
LEA RDX,[RSI + RCX*0x1]
PUSH 0x20
POP R14
MOV RAX,0x1ffffffffffffffd
CMP RDX,RAX
JA 0x00171222
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x10],RCX
MOV dword ptr [RSP + 0xc],R8D
MOV RAX,qword ptr [RBX]
MOV qword ptr [RSP + 0x20],RDX
LEA RDX,[0x8 + RDX*0x8]
MOV RDI,qword ptr [RAX]
XOR ESI,ESI
MOV qword ptr [RSP + 0x18],RAX
CALL qword ptr [RAX + 0x8]
TEST RAX,RAX
JZ 0x00171344
MOV RCX,qword ptr [RSP + 0x20]
SUB RCX,qword ptr [R13 + 0x18]
MOV qword ptr [RSP + 0x28],RCX
LEA RDX,[RCX*0x8]
MOV RDI,RAX
XOR ESI,ESI
MOV qword ptr [RSP],RAX
CALL 0x0010e350
MOV RAX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP]
LEA RDI,[RCX + RAX*0x8]
MOV RDX,qword ptr [R13 + 0x18]
MOV RSI,qword ptr [R13 + 0x20]
SHL RDX,0x3
CALL 0x0010e5b0
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
MOV RDI,RBX
CALL 0x0016e993
TEST EAX,EAX
JNZ 0x00171333
MOV RSI,qword ptr [RBX + 0x20]
MOV R8,qword ptr [R12 + 0x20]
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x20]
MOV R9,qword ptr [RSP + 0x10]
CALL 0x0016fcea
TEST EAX,EAX
JZ 0x00171351
LAB_00171333:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
LAB_00171344:
MOV RDI,RBX
CALL 0x0016ea51
JMP 0x00171222
LAB_00171351:
MOV RDI,qword ptr [RSP]
MOV R14,RDI
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x0017020d
TEST RAX,RAX
JZ 0x0017136f
MOV RAX,qword ptr [RBX + 0x20]
OR qword ptr [RAX],0x1
LAB_0017136f:
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX]
MOV RSI,R14
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R13 + 0x10]
SUB RAX,qword ptr [R12 + 0x10]
ADD RAX,0x40
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x8],EBP
MOV RDI,RBX
MOV RSI,R15
MOV EDX,dword ptr [RSP + 0xc]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0016eb8b
|
int8 __bf_div(long *param_1,long param_2,long param_3,long param_4,int4 param_5)
{
ulong uVar1;
int8 *puVar2;
int iVar3;
void *__s;
long lVar4;
int8 uVar5;
long lVar6;
uint uVar7;
ulong uVar8;
uVar7 = *(uint *)(param_3 + 8) ^ *(uint *)(param_2 + 8);
lVar4 = *(long *)(param_2 + 0x10);
if (lVar4 < 0x7ffffffffffffffe) {
lVar6 = *(long *)(param_3 + 0x10);
if (0x7ffffffffffffffd < lVar6) goto LAB_001711cc;
if (lVar4 != -0x8000000000000000) {
if (lVar6 == -0x8000000000000000) {
bf_set_inf(param_1,uVar7);
return 2;
}
uVar8 = param_4 + 0x41U >> 6;
lVar4 = *(long *)(param_3 + 0x18);
if ((long)uVar8 < (long)*(ulong *)(param_2 + 0x18)) {
uVar8 = *(ulong *)(param_2 + 0x18);
}
uVar1 = uVar8 + lVar4;
if (uVar1 < 0x1ffffffffffffffe) {
puVar2 = (int8 *)*param_1;
__s = (void *)(*(code *)puVar2[1])(*puVar2,0,uVar1 * 8 + 8);
if (__s != (void *)0x0) {
lVar6 = uVar1 - *(long *)(param_2 + 0x18);
memset(__s,0,lVar6 * 8);
memcpy((void *)((long)__s + lVar6 * 8),*(void **)(param_2 + 0x20),
*(long *)(param_2 + 0x18) << 3);
iVar3 = bf_resize(param_1,uVar8 + 1);
if ((iVar3 == 0) &&
(iVar3 = mp_divnorm(puVar2,param_1[4],__s,uVar1,*(int8 *)(param_3 + 0x20),lVar4),
iVar3 == 0)) {
lVar4 = mp_scan_nz(__s,lVar4);
if (lVar4 != 0) {
*(ulong *)param_1[4] = *(ulong *)param_1[4] | 1;
}
(*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,__s,0);
param_1[2] = (*(long *)(param_2 + 0x10) - *(long *)(param_3 + 0x10)) + 0x40;
*(uint *)(param_1 + 1) = uVar7;
uVar5 = bf_normalize_and_round(param_1,param_4,param_5);
return uVar5;
}
(*(code *)puVar2[1])(*puVar2,__s,0);
}
bf_set_nan(param_1);
return 0x20;
}
return 0x20;
}
if (lVar6 == -0x8000000000000000) goto LAB_00171203;
LAB_00171245:
bf_set_zero(param_1,uVar7);
}
else {
if (lVar4 != 0x7fffffffffffffff) {
lVar6 = *(long *)(param_3 + 0x10);
LAB_001711cc:
if (lVar6 != 0x7fffffffffffffff) {
if (lVar6 == 0x7ffffffffffffffe && lVar4 == 0x7ffffffffffffffe) {
LAB_00171203:
bf_set_nan(param_1);
return 1;
}
if (lVar4 == 0x7ffffffffffffffe) {
bf_set_inf(param_1,uVar7);
return 0;
}
goto LAB_00171245;
}
}
bf_set_nan(param_1);
}
return 0;
}
| |
25,989 | void alaya::load_ivecs<unsigned int>(std::filesystem::__cxx11::path const&, std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned int&, unsigned int&) | AlayaLite/include/utils/io_utils.hpp | inline void load_ivecs(const std::filesystem::path &filepath, std::vector<T> &data, uint32_t &num,
uint32_t &dim) {
std::ifstream file(filepath, std::ios::binary);
if (!file.is_open()) {
LOG_CRITICAL("Open fvecs file error {}.", filepath.string());
exit(-1);
}
file.read(reinterpret_cast<char *>(&dim), sizeof(uint32_t));
if (file.fail()) {
std::cerr << "Failed to read dimension from file: " << filepath.string() << std::endl;
}
file.seekg(0, std::ios::end);
size_t file_size = file.tellg();
file.seekg(0, std::ios::beg);
num = file_size / (sizeof(uint32_t) + dim * sizeof(float));
data.resize(num * dim);
for (uint32_t i = 0; i < num; ++i) {
file.read(reinterpret_cast<char *>(&dim), sizeof(uint32_t));
file.read(reinterpret_cast<char *>(data.data() + i * dim), dim * sizeof(float));
if (file.fail()) {
throw std::runtime_error("Failed to read data from file: " + filepath.string());
}
}
} | O0 | cpp | void alaya::load_ivecs<unsigned int>(std::filesystem::__cxx11::path const&, std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned int&, unsigned int&):
subq $0x3b8, %rsp # imm = 0x3B8
movq %rdi, 0x3b0(%rsp)
movq %rsi, 0x3a8(%rsp)
movq %rdx, 0x3a0(%rsp)
movq %rcx, 0x398(%rsp)
movq 0x3b0(%rsp), %rsi
leaq 0x190(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movl $0x4, %edx
callq 0x230a0
movq 0x50(%rsp), %rdi
callq 0x15cb0
movb %al, 0x5e(%rsp)
jmp 0x22af6
movb 0x5e(%rsp), %al
testb $0x1, %al
jne 0x22d1c
jmp 0x22b04
leaq 0x12ab64(%rip), %rax # 0x14d66f
movq %rax, 0x170(%rsp)
movq $0x29, 0x178(%rsp)
leaq 0x12f(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x15de0
movq 0x48(%rsp), %rdx
leaq 0x12ab5c(%rip), %rsi # 0x14d699
leaq 0x130(%rsp), %rdi
callq 0x1bd40
jmp 0x22b4c
leaq 0x107(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x15de0
movq 0x40(%rsp), %rdx
leaq 0x12a761(%rip), %rsi # 0x14d2cb
leaq 0x108(%rsp), %rdi
callq 0x1bd40
jmp 0x22b79
leaq 0x150(%rsp), %rdi
leaq 0x130(%rsp), %rsi
leaq 0x108(%rsp), %rdx
callq 0x1c330
jmp 0x22b98
movl $0xd8, 0x100(%rsp)
movq 0x3b0(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
callq 0x1c1a0
jmp 0x22bba
movq 0x170(%rsp), %rdi
movq 0x178(%rsp), %rsi
leaq 0x150(%rsp), %rdx
leaq 0x100(%rsp), %rcx
leaq 0xe0(%rsp), %r8
callq 0x230e0
jmp 0x22be9
leaq 0xe0(%rsp), %rdi
callq 0x1c160
leaq 0x150(%rsp), %rdi
callq 0x1c160
leaq 0x108(%rsp), %rdi
callq 0x1c160
leaq 0x107(%rsp), %rdi
callq 0x157f0
leaq 0x130(%rsp), %rdi
callq 0x1c160
leaq 0x12f(%rsp), %rdi
callq 0x157f0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x15920
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0x2307a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0x22d0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0x22cf0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0x22ce3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0x22cd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x1c160
leaq 0x150(%rsp), %rdi
callq 0x1c160
leaq 0x108(%rsp), %rdi
callq 0x1c160
leaq 0x107(%rsp), %rdi
callq 0x157f0
leaq 0x130(%rsp), %rdi
callq 0x1c160
leaq 0x12f(%rsp), %rdi
callq 0x157f0
jmp 0x2307a
movq 0x398(%rsp), %rsi
leaq 0x190(%rsp), %rdi
movl $0x4, %edx
callq 0x159b0
jmp 0x22d38
movq 0x190(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x190(%rsp,%rax), %rdi
callq 0x15040
movb %al, 0x3f(%rsp)
jmp 0x22d57
movb 0x3f(%rsp), %al
testb $0x1, %al
jne 0x22d64
jmp 0x22df6
movq 0x1ad275(%rip), %rdi # 0x1cffe0
leaq 0x12aa31(%rip), %rsi # 0x14d7a3
callq 0x15740
movq %rax, 0x30(%rsp)
jmp 0x22d7e
movq 0x3b0(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x1c1a0
jmp 0x22d95
movq 0x30(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x15680
movq %rax, 0x28(%rsp)
jmp 0x22dae
movq 0x28(%rsp), %rdi
movq 0x1ad166(%rip), %rsi # 0x1cff20
callq 0x157c0
jmp 0x22dc1
leaq 0xc0(%rsp), %rdi
callq 0x1c160
jmp 0x22df6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x1c160
jmp 0x2307a
xorl %eax, %eax
movl %eax, %esi
leaq 0x190(%rsp), %rdi
movl $0x2, %edx
callq 0x15aa0
jmp 0x22e0e
leaq 0x190(%rsp), %rdi
callq 0x15da0
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
jmp 0x22e27
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
movq %rax, 0xb0(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x26b90
movq %rax, 0x10(%rsp)
jmp 0x22e55
movq 0x10(%rsp), %rax
movq %rax, 0xb8(%rsp)
xorl %edx, %edx
movl %edx, %esi
leaq 0x190(%rsp), %rdi
callq 0x15aa0
jmp 0x22e75
movq 0xb8(%rsp), %rax
movq 0x398(%rsp), %rcx
movl (%rcx), %ecx
leaq 0x4(,%rcx,4), %rcx
xorl %edx, %edx
divq %rcx
movl %eax, %ecx
movq 0x3a0(%rsp), %rax
movl %ecx, (%rax)
movq 0x3a8(%rsp), %rdi
movq 0x3a0(%rsp), %rax
movl (%rax), %eax
movq 0x398(%rsp), %rcx
movl (%rcx), %ecx
imull %ecx, %eax
movl %eax, %esi
callq 0x26ba0
jmp 0x22ec8
movl $0x0, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
movq 0x3a0(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x23065
movq 0x398(%rsp), %rsi
leaq 0x190(%rsp), %rdi
movl $0x4, %edx
callq 0x159b0
jmp 0x22f06
movq 0x3a8(%rsp), %rdi
callq 0x26c40
movl 0xa4(%rsp), %ecx
movq 0x398(%rsp), %rdx
movl (%rdx), %edx
movl %edx, %esi
imull %esi, %ecx
leaq (%rax,%rcx,4), %rsi
shlq $0x2, %rdx
leaq 0x190(%rsp), %rdi
callq 0x159b0
jmp 0x22f40
movq 0x190(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x190(%rsp,%rax), %rdi
callq 0x15040
movb %al, 0xf(%rsp)
jmp 0x22f5f
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x22f6c
jmp 0x2304d
movb $0x1, 0x5f(%rsp)
movl $0x10, %edi
callq 0x15360
movq %rax, (%rsp)
movq 0x3b0(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x1c1a0
jmp 0x22f93
leaq 0x12a82e(%rip), %rsi # 0x14d7c8
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x26c60
jmp 0x22fae
movq (%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x15cc0
jmp 0x22fc1
movq (%rsp), %rdi
movb $0x0, 0x5f(%rsp)
movq 0x1ad01f(%rip), %rsi # 0x1cfff0
movq 0x1acf78(%rip), %rdx # 0x1cff50
callq 0x15d70
jmp 0x23094
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0x23039
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0x2302f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1c160
leaq 0x60(%rsp), %rdi
callq 0x1c160
testb $0x1, 0x5f(%rsp)
jne 0x23042
jmp 0x2304b
movq (%rsp), %rdi
callq 0x15520
jmp 0x2307a
jmp 0x2304f
movl 0xa4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa4(%rsp)
jmp 0x22ed3
leaq 0x190(%rsp), %rdi
callq 0x15190
addq $0x3b8, %rsp # imm = 0x3B8
retq
leaq 0x190(%rsp), %rdi
callq 0x15190
movq 0x188(%rsp), %rdi
callq 0x15dd0
nopw %cs:(%rax,%rax)
nop
| _ZN5alaya10load_ivecsIjEEvRKNSt10filesystem7__cxx114pathERSt6vectorIT_SaIS7_EERjSB_:
sub rsp, 3B8h
mov [rsp+3B8h+var_8], rdi
mov [rsp+3B8h+var_10], rsi
mov [rsp+3B8h+var_18], rdx
mov [rsp+3B8h+var_20], rcx
mov rsi, [rsp+3B8h+var_8]
lea rdi, [rsp+3B8h+var_228]
mov qword ptr [rsp+3B8h+var_368], rdi; int
mov edx, 4
call _ZNSt14basic_ifstreamIcSt11char_traitsIcEEC1INSt10filesystem7__cxx114pathES6_EERKT_St13_Ios_Openmode; std::ifstream::basic_ifstream<std::filesystem::__cxx11::path,std::filesystem::__cxx11::path>(std::filesystem::__cxx11::path const&,std::_Ios_Openmode)
mov rdi, qword ptr [rsp+3B8h+var_368]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEE7is_openEv; std::ifstream::is_open(void)
mov [rsp+3B8h+var_35A], al
jmp short $+2
loc_22AF6:
mov al, [rsp+3B8h+var_35A]
test al, 1
jnz loc_22D1C
jmp short $+2
loc_22B04:
lea rax, aAlayaOpenFvecs; "[Alaya] [{}:{}] Open fvecs file error {"...
mov [rsp+3B8h+var_248], rax
mov [rsp+3B8h+var_240], 29h ; ')'
lea rdi, [rsp+3B8h+var_289]
mov qword ptr [rsp+3B8h+var_370], rdi; char
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, qword ptr [rsp+3B8h+var_370]
lea rsi, aWorkspaceLlm4b_8; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+3B8h+var_288]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_22B4C:
lea rdi, [rsp+3B8h+var_2B1]
mov [rsp+3B8h+var_378], rdi; __int64
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rsp+3B8h+var_378]
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+3B8h+var_2B1+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_22B79:
lea rdi, [rsp+3B8h+var_268]; std::filesystem::__cxx11::path::_List *
lea rsi, [rsp+3B8h+var_288]
lea rdx, [rsp+3B8h+var_2B1+1]
call _Z17get_relative_pathRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_; get_relative_path(std::string const&,std::string const&)
jmp short $+2
loc_22B98:
mov [rsp+3B8h+var_2B8], 0D8h
mov rsi, [rsp+3B8h+var_8]
lea rdi, [rsp+3B8h+var_2D8]; this
call _ZNKSt10filesystem7__cxx114path6stringEv; std::filesystem::__cxx11::path::string(void)
jmp short $+2
loc_22BBA:
mov rdi, [rsp+3B8h+var_248]
mov rsi, [rsp+3B8h+var_240]
lea rdx, [rsp+3B8h+var_268]
lea rcx, [rsp+3B8h+var_2B8]
lea r8, [rsp+3B8h+var_2D8]
call _ZN6spdlog8criticalIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiS6_EEEvN3fmt3v1019basic_format_stringIcJDpNS8_13type_identityIT_E4typeEEEEDpOSB_; spdlog::critical<std::string,int,std::string>(fmt::v10::basic_format_string<char,fmt::v10::type_identity<std::string,int,std::string>::type>,std::string,int,std::string&&)
jmp short $+2
loc_22BE9:
lea rdi, [rsp+3B8h+var_2D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+3B8h+var_268]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+3B8h+var_2B1+1]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+3B8h+var_2B1]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+3B8h+var_288]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+3B8h+var_289]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov edi, 0FFFFFFFFh
call _exit
mov rcx, rax
mov eax, edx
mov [rsp+3B8h+var_230], rcx
mov [rsp+3B8h+var_234], eax
jmp loc_2307A
mov rcx, rax
mov eax, edx
mov [rsp+3B8h+var_230], rcx
mov [rsp+3B8h+var_234], eax
jmp loc_22D0A
mov rcx, rax
mov eax, edx
mov [rsp+3B8h+var_230], rcx
mov [rsp+3B8h+var_234], eax
jmp short loc_22CF0
mov rcx, rax
mov eax, edx
mov [rsp+3B8h+var_230], rcx
mov [rsp+3B8h+var_234], eax
jmp short loc_22CE3
mov rcx, rax
mov eax, edx
mov [rsp+3B8h+var_230], rcx
mov [rsp+3B8h+var_234], eax
jmp short loc_22CD6
mov rcx, rax
mov eax, edx
mov [rsp+3B8h+var_230], rcx
mov [rsp+3B8h+var_234], eax
lea rdi, [rsp+3B8h+var_2D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_22CD6:
lea rdi, [rsp+3B8h+var_268]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_22CE3:
lea rdi, [rsp+3B8h+var_2B1+1]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_22CF0:
lea rdi, [rsp+3B8h+var_2B1]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+3B8h+var_288]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_22D0A:
lea rdi, [rsp+3B8h+var_289]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_2307A
loc_22D1C:
mov rsi, [rsp+3B8h+var_20]; char *
lea rdi, [rsp+3B8h+var_228]; this
mov edx, 4; __int64
call __ZNSi4readEPcl; std::istream::read(char *,long)
jmp short $+2
loc_22D38:
mov rax, qword ptr [rsp+3B8h+var_228]
mov rax, [rax-18h]
lea rdi, [rsp+rax+3B8h+var_228]
call __ZNKSt9basic_iosIcSt11char_traitsIcEE4failEv; std::ios::fail(void)
mov [rsp+3B8h+var_379], al
jmp short $+2
loc_22D57:
mov al, [rsp+3B8h+var_379]
test al, 1
jnz short loc_22D64
jmp loc_22DF6
loc_22D64:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aFailedToReadDi; "Failed to read dimension from file: "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+3B8h+var_388], rax
jmp short $+2
loc_22D7E:
mov rsi, [rsp+3B8h+var_8]
lea rdi, [rsp+3B8h+var_2F8]; this
call _ZNKSt10filesystem7__cxx114path6stringEv; std::filesystem::__cxx11::path::string(void)
jmp short $+2
loc_22D95:
mov rdi, [rsp+3B8h+var_388]
lea rsi, [rsp+3B8h+var_2F8]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+3B8h+var_390], rax
jmp short $+2
loc_22DAE:
mov rdi, [rsp+3B8h+var_390]
mov rsi, cs:_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ptr
call __ZNSolsEPFRSoS_E; std::ostream::operator<<(std::ostream & (*)(std::ostream &))
jmp short $+2
loc_22DC1:
lea rdi, [rsp+3B8h+var_2F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_22DF6
mov rcx, rax
mov eax, edx
mov [rsp+3B8h+var_230], rcx
mov [rsp+3B8h+var_234], eax
lea rdi, [rsp+3B8h+var_2F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_2307A
loc_22DF6:
xor eax, eax
mov esi, eax
lea rdi, [rsp+3B8h+var_228]
mov edx, 2
call __ZNSi5seekgElSt12_Ios_Seekdir; std::istream::seekg(long,std::_Ios_Seekdir)
jmp short $+2
loc_22E0E:
lea rdi, [rsp+3B8h+var_228]; this
call __ZNSi5tellgEv; std::istream::tellg(void)
mov [rsp+3B8h+var_3A0], rdx
mov [rsp+3B8h+var_398], rax
jmp short $+2
loc_22E27:
mov rax, [rsp+3B8h+var_3A0]
mov rcx, [rsp+3B8h+var_398]
mov [rsp+3B8h+var_310], rcx
mov [rsp+3B8h+var_308], rax
lea rdi, [rsp+3B8h+var_310]
call _ZNKSt4fposI11__mbstate_tEcvlEv; std::fpos<__mbstate_t>::operator long(void)
mov [rsp+3B8h+var_3A8], rax
jmp short $+2
loc_22E55:
mov rax, [rsp+3B8h+var_3A8]
mov [rsp+3B8h+var_300], rax
xor edx, edx
mov esi, edx
lea rdi, [rsp+3B8h+var_228]
call __ZNSi5seekgElSt12_Ios_Seekdir; std::istream::seekg(long,std::_Ios_Seekdir)
jmp short $+2
loc_22E75:
mov rax, [rsp+3B8h+var_300]
mov rcx, [rsp+3B8h+var_20]
mov ecx, [rcx]
lea rcx, ds:4[rcx*4]
xor edx, edx
div rcx
mov ecx, eax
mov rax, [rsp+3B8h+var_18]
mov [rax], ecx
mov rdi, [rsp+3B8h+var_10]
mov rax, [rsp+3B8h+var_18]
mov eax, [rax]
mov rcx, [rsp+3B8h+var_20]
mov ecx, [rcx]
imul eax, ecx
mov esi, eax
call _ZNSt6vectorIjSaIjEE6resizeEm; std::vector<uint>::resize(ulong)
jmp short $+2
loc_22EC8:
mov [rsp+3B8h+var_314], 0
loc_22ED3:
mov eax, [rsp+3B8h+var_314]
mov rcx, [rsp+3B8h+var_18]
cmp eax, [rcx]
jnb loc_23065
mov rsi, [rsp+3B8h+var_20]; char *
lea rdi, [rsp+3B8h+var_228]; this
mov edx, 4; __int64
call __ZNSi4readEPcl; std::istream::read(char *,long)
jmp short $+2
loc_22F06:
mov rdi, [rsp+3B8h+var_10]
call _ZNSt6vectorIjSaIjEE4dataEv; std::vector<uint>::data(void)
mov ecx, [rsp+3B8h+var_314]
mov rdx, [rsp+3B8h+var_20]
mov edx, [rdx]
mov esi, edx
imul ecx, esi
lea rsi, [rax+rcx*4]; char *
shl rdx, 2; __int64
lea rdi, [rsp+3B8h+var_228]; this
call __ZNSi4readEPcl; std::istream::read(char *,long)
jmp short $+2
loc_22F40:
mov rax, qword ptr [rsp+3B8h+var_228]
mov rax, [rax-18h]
lea rdi, [rsp+rax+3B8h+var_228]
call __ZNKSt9basic_iosIcSt11char_traitsIcEE4failEv; std::ios::fail(void)
mov [rsp+3B8h+var_3A9], al
jmp short $+2
loc_22F5F:
mov al, [rsp+3B8h+var_3A9]
test al, 1
jnz short loc_22F6C
jmp loc_2304D
loc_22F6C:
mov [rsp+3B8h+var_359], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov [rsp+3B8h+var_3B8], rax
mov rsi, [rsp+3B8h+var_8]
lea rdi, [rsp+3B8h+var_358]; this
call _ZNKSt10filesystem7__cxx114path6stringEv; std::filesystem::__cxx11::path::string(void)
jmp short $+2
loc_22F93:
lea rsi, aFailedToReadDa; "Failed to read data from file: "
lea rdi, [rsp+3B8h+var_338]
lea rdx, [rsp+3B8h+var_358]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_22FAE:
mov rdi, [rsp+3B8h+var_3B8]
lea rsi, [rsp+3B8h+var_338]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_22FC1:
mov rdi, [rsp+3B8h+var_3B8]; void *
mov [rsp+3B8h+var_359], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_23094
mov rcx, rax
mov eax, edx
mov [rsp+3B8h+var_230], rcx
mov [rsp+3B8h+var_234], eax
jmp short loc_23039
mov rcx, rax
mov eax, edx
mov [rsp+3B8h+var_230], rcx
mov [rsp+3B8h+var_234], eax
jmp short loc_2302F
mov rcx, rax
mov eax, edx
mov [rsp+3B8h+var_230], rcx
mov [rsp+3B8h+var_234], eax
lea rdi, [rsp+3B8h+var_338]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_2302F:
lea rdi, [rsp+3B8h+var_358]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_23039:
test [rsp+3B8h+var_359], 1
jnz short loc_23042
jmp short loc_2304B
loc_23042:
mov rdi, [rsp+3B8h+var_3B8]; void *
call ___cxa_free_exception
loc_2304B:
jmp short loc_2307A
loc_2304D:
jmp short $+2
loc_2304F:
mov eax, [rsp+3B8h+var_314]
add eax, 1
mov [rsp+3B8h+var_314], eax
jmp loc_22ED3
loc_23065:
lea rdi, [rsp+3B8h+var_228]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
add rsp, 3B8h
retn
loc_2307A:
lea rdi, [rsp+3B8h+var_228]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
mov rdi, [rsp+3B8h+var_230]
call __Unwind_Resume
loc_23094:
nop word ptr [rax+rax+00000000h]
xchg ax, ax
| long long alaya::load_ivecs<unsigned int>(long long a1, long long a2, unsigned int *a3, char *a4)
{
int v4; // ecx
int v5; // r8d
int v6; // r9d
long long v7; // rsi
long long v8; // rdx
long long v9; // rax
void *exception; // [rsp+0h] [rbp-3B8h]
long long v12; // [rsp+28h] [rbp-390h]
long long v13; // [rsp+30h] [rbp-388h]
_BYTE v14[32]; // [rsp+60h] [rbp-358h] BYREF
_BYTE v15[36]; // [rsp+80h] [rbp-338h] BYREF
unsigned int i; // [rsp+A4h] [rbp-314h]
_QWORD v17[2]; // [rsp+A8h] [rbp-310h] BYREF
unsigned long long v18; // [rsp+B8h] [rbp-300h]
_BYTE v19[32]; // [rsp+C0h] [rbp-2F8h] BYREF
_BYTE v20[32]; // [rsp+E0h] [rbp-2D8h] BYREF
int v21; // [rsp+100h] [rbp-2B8h] BYREF
long long v22[5]; // [rsp+107h] [rbp-2B1h] BYREF
char v23; // [rsp+12Fh] [rbp-289h] BYREF
_BYTE v24[32]; // [rsp+130h] [rbp-288h] BYREF
_BYTE v25[32]; // [rsp+150h] [rbp-268h] BYREF
const char *v26; // [rsp+170h] [rbp-248h]
long long v27; // [rsp+178h] [rbp-240h]
int v28[2]; // [rsp+190h] [rbp-228h] BYREF
char *v29; // [rsp+398h] [rbp-20h]
unsigned int *v30; // [rsp+3A0h] [rbp-18h]
long long v31; // [rsp+3A8h] [rbp-10h]
long long v32; // [rsp+3B0h] [rbp-8h]
v32 = a1;
v31 = a2;
v30 = a3;
v29 = a4;
std::ifstream::basic_ifstream<std::filesystem::__cxx11::path,std::filesystem::__cxx11::path>(v28, a1, 4LL);
if ( (std::ifstream::is_open(v28) & 1) == 0 )
{
v26 = "[Alaya] [{}:{}] Open fvecs file error {}.";
v27 = 41LL;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(
(long long)v24,
(long long)"/workspace/llm4binary/github2025/AlayaLite/include/utils/io_utils.hpp",
(long long)&v23);
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(
(long long)v22 + 1,
(long long)"/workspace/llm4binary/github2025/AlayaLite",
(long long)v22);
get_relative_path((std::filesystem::__cxx11::path::_List *)v25, (long long)v24, (long long)v22 + 1, v4, v5, v6);
v21 = 216;
std::filesystem::__cxx11::path::string((std::filesystem::__cxx11::path *)v20, v32);
v7 = v27;
spdlog::critical<std::string,int,std::string>(v26, v27, v25, &v21, v20);
std::string::~string(v20);
std::string::~string(v25);
std::string::~string((char *)v22 + 1);
std::allocator<char>::~allocator(v22, v7);
std::string::~string(v24);
std::allocator<char>::~allocator(&v23, v7);
exit(0xFFFFFFFFLL);
}
std::istream::read((std::istream *)v28, v29, 4LL);
if ( (std::ios::fail((char *)v28 + *(_QWORD *)(*(_QWORD *)v28 - 24LL)) & 1) != 0 )
{
v13 = std::operator<<<std::char_traits<char>>(&std::cerr, "Failed to read dimension from file: ");
std::filesystem::__cxx11::path::string((std::filesystem::__cxx11::path *)v19, v32);
v12 = std::operator<<<char>(v13, v19);
std::ostream::operator<<(v12, &std::endl<char,std::char_traits<char>>);
std::string::~string(v19);
}
std::istream::seekg(v28, 0LL, 2LL);
v17[0] = std::istream::tellg((std::istream *)v28);
v17[1] = v8;
v18 = std::fpos<__mbstate_t>::operator long(v17);
std::istream::seekg(v28, 0LL, 0LL);
*v30 = v18 / (4 * (unsigned long long)*(unsigned int *)v29 + 4);
std::vector<unsigned int>::resize(v31, *(_DWORD *)v29 * *v30);
for ( i = 0; i < *v30; ++i )
{
std::istream::read((std::istream *)v28, v29, 4LL);
v9 = std::vector<unsigned int>::data(v31);
std::istream::read((std::istream *)v28, (char *)(v9 + 4LL * *(_DWORD *)v29 * i), 4LL * *(unsigned int *)v29);
if ( (std::ios::fail((char *)v28 + *(_QWORD *)(*(_QWORD *)v28 - 24LL)) & 1) != 0 )
{
exception = __cxa_allocate_exception(0x10uLL);
std::filesystem::__cxx11::path::string((std::filesystem::__cxx11::path *)v14, v32);
std::operator+<char>(v15, "Failed to read data from file: ", v14);
std::runtime_error::runtime_error(exception, v15);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
return std::ifstream::~ifstream(v28);
}
| load_ivecs<unsigned_int>:
SUB RSP,0x3b8
MOV qword ptr [RSP + 0x3b0],RDI
MOV qword ptr [RSP + 0x3a8],RSI
MOV qword ptr [RSP + 0x3a0],RDX
MOV qword ptr [RSP + 0x398],RCX
MOV RSI,qword ptr [RSP + 0x3b0]
LEA RDI,[RSP + 0x190]
MOV qword ptr [RSP + 0x50],RDI
MOV EDX,0x4
CALL 0x001230a0
MOV RDI,qword ptr [RSP + 0x50]
LAB_00122aeb:
CALL 0x00115cb0
MOV byte ptr [RSP + 0x5e],AL
JMP 0x00122af6
LAB_00122af6:
MOV AL,byte ptr [RSP + 0x5e]
TEST AL,0x1
JNZ 0x00122d1c
JMP 0x00122b04
LAB_00122b04:
LEA RAX,[0x24d66f]
MOV qword ptr [RSP + 0x170],RAX
MOV qword ptr [RSP + 0x178],0x29
LEA RDI,[RSP + 0x12f]
MOV qword ptr [RSP + 0x48],RDI
CALL 0x00115de0
MOV RDX,qword ptr [RSP + 0x48]
LAB_00122b36:
LEA RSI,[0x24d699]
LEA RDI,[RSP + 0x130]
CALL 0x0011bd40
JMP 0x00122b4c
LAB_00122b4c:
LEA RDI,[RSP + 0x107]
MOV qword ptr [RSP + 0x40],RDI
CALL 0x00115de0
MOV RDX,qword ptr [RSP + 0x40]
LAB_00122b63:
LEA RSI,[0x24d2cb]
LEA RDI,[RSP + 0x108]
CALL 0x0011bd40
JMP 0x00122b79
LAB_00122b79:
LEA RDI,[RSP + 0x150]
LEA RSI,[RSP + 0x130]
LEA RDX,[RSP + 0x108]
CALL 0x0011c330
JMP 0x00122b98
LAB_00122b98:
MOV dword ptr [RSP + 0x100],0xd8
MOV RSI,qword ptr [RSP + 0x3b0]
LAB_00122bab:
LEA RDI,[RSP + 0xe0]
CALL 0x0011c1a0
JMP 0x00122bba
LAB_00122bba:
MOV RDI,qword ptr [RSP + 0x170]
MOV RSI,qword ptr [RSP + 0x178]
LAB_00122bca:
LEA RDX,[RSP + 0x150]
LEA RCX,[RSP + 0x100]
LEA R8,[RSP + 0xe0]
CALL 0x001230e0
JMP 0x00122be9
LAB_00122be9:
LEA RDI,[RSP + 0xe0]
CALL 0x0011c160
LEA RDI,[RSP + 0x150]
CALL 0x0011c160
LEA RDI,[RSP + 0x108]
CALL 0x0011c160
LEA RDI,[RSP + 0x107]
CALL 0x001157f0
LEA RDI,[RSP + 0x130]
CALL 0x0011c160
LEA RDI,[RSP + 0x12f]
CALL 0x001157f0
MOV EDI,0xffffffff
CALL 0x00115920
LAB_00122d1c:
MOV RSI,qword ptr [RSP + 0x398]
LAB_00122d24:
LEA RDI,[RSP + 0x190]
MOV EDX,0x4
CALL 0x001159b0
JMP 0x00122d38
LAB_00122d38:
MOV RAX,qword ptr [RSP + 0x190]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[RSP + RAX*0x1 + 0x190]
CALL 0x00115040
MOV byte ptr [RSP + 0x3f],AL
JMP 0x00122d57
LAB_00122d57:
MOV AL,byte ptr [RSP + 0x3f]
TEST AL,0x1
JNZ 0x00122d64
JMP 0x00122df6
LAB_00122d64:
MOV RDI,qword ptr [0x002cffe0]
LEA RSI,[0x24d7a3]
CALL 0x00115740
MOV qword ptr [RSP + 0x30],RAX
JMP 0x00122d7e
LAB_00122d7e:
MOV RSI,qword ptr [RSP + 0x3b0]
LEA RDI,[RSP + 0xc0]
CALL 0x0011c1a0
JMP 0x00122d95
LAB_00122d95:
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[RSP + 0xc0]
CALL 0x00115680
MOV qword ptr [RSP + 0x28],RAX
JMP 0x00122dae
LAB_00122dae:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [0x002cff20]
CALL 0x001157c0
JMP 0x00122dc1
LAB_00122dc1:
LEA RDI,[RSP + 0xc0]
CALL 0x0011c160
JMP 0x00122df6
LAB_00122df6:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RSP + 0x190]
MOV EDX,0x2
CALL 0x00115aa0
JMP 0x00122e0e
LAB_00122e0e:
LEA RDI,[RSP + 0x190]
CALL 0x00115da0
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RSP + 0x20],RAX
JMP 0x00122e27
LAB_00122e27:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0xa8],RCX
MOV qword ptr [RSP + 0xb0],RAX
LEA RDI,[RSP + 0xa8]
CALL 0x00126b90
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00122e55
LAB_00122e55:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0xb8],RAX
XOR EDX,EDX
MOV ESI,EDX
LEA RDI,[RSP + 0x190]
CALL 0x00115aa0
JMP 0x00122e75
LAB_00122e75:
MOV RAX,qword ptr [RSP + 0xb8]
MOV RCX,qword ptr [RSP + 0x398]
MOV ECX,dword ptr [RCX]
LEA RCX,[0x4 + RCX*0x4]
XOR EDX,EDX
DIV RCX
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x3a0]
MOV dword ptr [RAX],ECX
MOV RDI,qword ptr [RSP + 0x3a8]
MOV RAX,qword ptr [RSP + 0x3a0]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x398]
MOV ECX,dword ptr [RCX]
IMUL EAX,ECX
MOV ESI,EAX
CALL 0x00126ba0
JMP 0x00122ec8
LAB_00122ec8:
MOV dword ptr [RSP + 0xa4],0x0
LAB_00122ed3:
MOV EAX,dword ptr [RSP + 0xa4]
MOV RCX,qword ptr [RSP + 0x3a0]
CMP EAX,dword ptr [RCX]
JNC 0x00123065
MOV RSI,qword ptr [RSP + 0x398]
LEA RDI,[RSP + 0x190]
MOV EDX,0x4
CALL 0x001159b0
JMP 0x00122f06
LAB_00122f06:
MOV RDI,qword ptr [RSP + 0x3a8]
CALL 0x00126c40
MOV ECX,dword ptr [RSP + 0xa4]
MOV RDX,qword ptr [RSP + 0x398]
MOV EDX,dword ptr [RDX]
MOV ESI,EDX
IMUL ECX,ESI
LEA RSI,[RAX + RCX*0x4]
SHL RDX,0x2
LEA RDI,[RSP + 0x190]
CALL 0x001159b0
JMP 0x00122f40
LAB_00122f40:
MOV RAX,qword ptr [RSP + 0x190]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[RSP + RAX*0x1 + 0x190]
CALL 0x00115040
LAB_00122f59:
MOV byte ptr [RSP + 0xf],AL
JMP 0x00122f5f
LAB_00122f5f:
MOV AL,byte ptr [RSP + 0xf]
TEST AL,0x1
JNZ 0x00122f6c
JMP 0x0012304d
LAB_00122f6c:
MOV byte ptr [RSP + 0x5f],0x1
MOV EDI,0x10
CALL 0x00115360
MOV qword ptr [RSP],RAX
MOV RSI,qword ptr [RSP + 0x3b0]
LAB_00122f87:
LEA RDI,[RSP + 0x60]
CALL 0x0011c1a0
JMP 0x00122f93
LAB_00122f93:
LEA RSI,[0x24d7c8]
LEA RDI,[RSP + 0x80]
LEA RDX,[RSP + 0x60]
CALL 0x00126c60
JMP 0x00122fae
LAB_00122fae:
MOV RDI,qword ptr [RSP]
LEA RSI,[RSP + 0x80]
CALL 0x00115cc0
JMP 0x00122fc1
LAB_00122fc1:
MOV RDI,qword ptr [RSP]
MOV byte ptr [RSP + 0x5f],0x0
MOV RSI,qword ptr [0x002cfff0]
MOV RDX,qword ptr [0x002cff50]
CALL 0x00115d70
LAB_0012304d:
JMP 0x0012304f
LAB_0012304f:
MOV EAX,dword ptr [RSP + 0xa4]
ADD EAX,0x1
MOV dword ptr [RSP + 0xa4],EAX
JMP 0x00122ed3
LAB_00123065:
LEA RDI,[RSP + 0x190]
CALL 0x00115190
ADD RSP,0x3b8
RET
|
/* void alaya::load_ivecs<unsigned int>(std::filesystem::__cxx11::path const&, std::vector<unsigned
int, std::allocator<unsigned int> >&, unsigned int&, unsigned int&) */
void alaya::load_ivecs<unsigned_int>(path *param_1,vector *param_2,uint *param_3,uint *param_4)
{
byte bVar1;
ostream *poVar2;
long lVar3;
runtime_error *this;
string local_338 [36];
uint local_314;
fpos local_310 [16];
ulong local_300;
string local_2f8 [32];
string local_2d8 [32];
int4 local_2b8;
allocator local_2b1;
string local_2b0 [39];
allocator local_289;
string local_288 [32];
string local_268 [32];
spdlog *local_248;
int8 local_240;
ifstream local_228 [520];
uint *local_20;
uint *local_18;
vector *local_10;
path *local_8;
local_20 = param_4;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
std::ifstream::ifstream<std::filesystem::__cxx11::path,std::filesystem::__cxx11::path>
(local_228,param_1,4);
/* try { // try from 00122aeb to 00122aef has its CatchHandler @ 00122c41 */
bVar1 = std::ifstream::is_open();
if ((bVar1 & 1) == 0) {
local_248 = (spdlog *)0x24d66f;
local_240 = 0x29;
std::allocator<char>::allocator();
/* try { // try from 00122b36 to 00122b49 has its CatchHandler @ 00122c5a */
std::__cxx11::string::string<std::allocator<char>>
(local_288,"/workspace/llm4binary/github2025/AlayaLite/include/utils/io_utils.hpp",
&local_289);
std::allocator<char>::allocator();
/* try { // try from 00122b63 to 00122b76 has its CatchHandler @ 00122c73 */
std::__cxx11::string::string<std::allocator<char>>
(local_2b0,"/workspace/llm4binary/github2025/AlayaLite",&local_2b1);
/* try { // try from 00122b79 to 00122b95 has its CatchHandler @ 00122c89 */
get_relative_path(local_268,local_288);
local_2b8 = 0xd8;
/* try { // try from 00122bab to 00122bb7 has its CatchHandler @ 00122c9f */
std::filesystem::__cxx11::path::string();
/* try { // try from 00122bca to 00122be6 has its CatchHandler @ 00122cb5 */
spdlog::critical<std::__cxx11::string,int,std::__cxx11::string>
(local_248,local_240,local_268,&local_2b8,local_2d8);
std::__cxx11::string::~string(local_2d8);
std::__cxx11::string::~string(local_268);
std::__cxx11::string::~string(local_2b0);
std::allocator<char>::~allocator((allocator<char> *)&local_2b1);
std::__cxx11::string::~string(local_288);
std::allocator<char>::~allocator((allocator<char> *)&local_289);
/* WARNING: Subroutine does not return */
exit(-1);
}
/* try { // try from 00122d24 to 00122d92 has its CatchHandler @ 00122c41 */
std::istream::read((char *)local_228,(long)local_20);
bVar1 = std::ios::fail();
if ((bVar1 & 1) != 0) {
poVar2 = std::operator<<((ostream *)PTR_cerr_002cffe0,"Failed to read dimension from file: ");
std::filesystem::__cxx11::path::string();
/* try { // try from 00122d95 to 00122dbe has its CatchHandler @ 00122dd0 */
poVar2 = std::operator<<(poVar2,local_2f8);
std::ostream::operator<<
(poVar2,(_func_ostream_ptr_ostream_ptr *)PTR_endl<char,std_char_traits<char>>_002cff20
);
std::__cxx11::string::~string(local_2f8);
}
/* try { // try from 00122df6 to 00122f58 has its CatchHandler @ 00122c41 */
std::istream::seekg(local_228,0,2);
local_310 = (fpos [16])std::istream::tellg();
local_300 = std::fpos::operator_cast_to_long(local_310);
std::istream::seekg(local_228,0);
*local_18 = (uint)(local_300 / ((ulong)*local_20 * 4 + 4));
std::vector<unsigned_int,std::allocator<unsigned_int>>::resize
((vector<unsigned_int,std::allocator<unsigned_int>> *)local_10,
(ulong)(*local_18 * *local_20));
local_314 = 0;
while( true ) {
if (*local_18 <= local_314) {
std::ifstream::~ifstream(local_228);
return;
}
std::istream::read((char *)local_228,(long)local_20);
lVar3 = std::vector<unsigned_int,std::allocator<unsigned_int>>::data
((vector<unsigned_int,std::allocator<unsigned_int>> *)local_10);
std::istream::read((char *)local_228,lVar3 + (ulong)(local_314 * *local_20) * 4);
bVar1 = std::ios::fail();
if ((bVar1 & 1) != 0) break;
local_314 = local_314 + 1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00122f87 to 00122f90 has its CatchHandler @ 00122fe2 */
std::filesystem::__cxx11::path::string();
/* try { // try from 00122f93 to 00122fab has its CatchHandler @ 00122ff8 */
std::operator+((char *)local_338,(string *)"Failed to read data from file: ");
/* try { // try from 00122fae to 00122fdc has its CatchHandler @ 0012300e */
std::runtime_error::runtime_error(this,local_338);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_002cfff0,PTR__runtime_error_002cff50);
}
| |
25,990 | void alaya::load_ivecs<unsigned int>(std::filesystem::__cxx11::path const&, std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned int&, unsigned int&) | AlayaLite/include/utils/io_utils.hpp | inline void load_ivecs(const std::filesystem::path &filepath, std::vector<T> &data, uint32_t &num,
uint32_t &dim) {
std::ifstream file(filepath, std::ios::binary);
if (!file.is_open()) {
LOG_CRITICAL("Open fvecs file error {}.", filepath.string());
exit(-1);
}
file.read(reinterpret_cast<char *>(&dim), sizeof(uint32_t));
if (file.fail()) {
std::cerr << "Failed to read dimension from file: " << filepath.string() << std::endl;
}
file.seekg(0, std::ios::end);
size_t file_size = file.tellg();
file.seekg(0, std::ios::beg);
num = file_size / (sizeof(uint32_t) + dim * sizeof(float));
data.resize(num * dim);
for (uint32_t i = 0; i < num; ++i) {
file.read(reinterpret_cast<char *>(&dim), sizeof(uint32_t));
file.read(reinterpret_cast<char *>(data.data() + i * dim), dim * sizeof(float));
if (file.fail()) {
throw std::runtime_error("Failed to read data from file: " + filepath.string());
}
}
} | O3 | cpp | void alaya::load_ivecs<unsigned int>(std::filesystem::__cxx11::path const&, std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned int&, unsigned int&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x90(%rsp), %rdi
movl $0x4, %edx
callq 0x11050
leaq 0x108(%rsp), %rdi
callq 0x11c40
testb %al, %al
je 0x19a65
leaq 0x90(%rsp), %rdi
movl $0x4, %edx
movq %r14, %rsi
callq 0x115c0
movq 0x90(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0xb0(%rsp,%rax)
je 0x1992b
movq 0x9a732(%rip), %rdi # 0xb3fd8
leaq 0x65e86(%rip), %rsi # 0x7f733
movl $0x24, %edx
callq 0x11b90
movq (%rbx), %rsi
leaq 0x18(%rsp), %rbp
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rbp, -0x10(%rbp)
leaq 0x8(%rsp), %rdi
callq 0x19014
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x9a6f3(%rip), %rdi # 0xb3fd8
callq 0x11b90
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x11c80
movsbl %al, %esi
movq %r13, %rdi
callq 0x11670
movq %rax, %rdi
callq 0x11600
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1992b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11120
leaq 0x90(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x113e0
leaq 0x90(%rsp), %rdi
callq 0x11150
movq %rax, %r13
leaq 0x90(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x113e0
movl (%r14), %eax
leaq 0x4(,%rax,4), %rcx
movq %r13, %rax
xorl %edx, %edx
divq %rcx
movl %eax, (%r15)
imull (%r14), %eax
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a45c
cmpl $0x0, (%r15)
je 0x199de
xorl %ebp, %ebp
leaq 0x90(%rsp), %r13
movl $0x4, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x115c0
movl (%r14), %edx
movl %edx, %esi
imull %ebp, %esi
shlq $0x2, %rsi
addq (%r12), %rsi
shlq $0x2, %rdx
movq %r13, %rdi
callq 0x115c0
movq 0x90(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0xb0(%rsp,%rax)
jne 0x199fd
incl %ebp
cmpl (%r15), %ebp
jb 0x19995
leaq 0x90(%rsp), %rdi
callq 0x11030
addq $0x298, %rsp # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x114c0
movq %rax, %r14
movq (%rbx), %rsi
leaq 0x40(%rsp), %r15
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, -0x10(%r15)
leaq 0x30(%rsp), %rdi
callq 0x19014
leaq 0x65d2a(%rip), %rsi # 0x7f758
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x1a48d
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x11340
xorl %ebp, %ebp
movq 0x9a572(%rip), %rsi # 0xb3fc8
movq 0x9a543(%rip), %rdx # 0xb3fa0
movq %r14, %rdi
callq 0x11720
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x65bb4(%rip), %rsi # 0x7f629
leaq 0x65bf2(%rip), %rdx # 0x7f66e
leaq 0x30(%rsp), %rdi
callq 0x19014
leaq 0x80(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x657c2(%rip), %rsi # 0x7f25b
leaq 0x657e5(%rip), %rdx # 0x7f285
leaq 0x70(%rsp), %rdi
callq 0x19014
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x16f8a
movl $0xd8, 0x2c(%rsp)
movq (%rbx), %rsi
leaq 0x60(%rsp), %r12
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r12, -0x10(%r12)
leaq 0x50(%rsp), %rdi
callq 0x19014
leaq 0x65b14(%rip), %rdi # 0x7f5ff
leaq 0x8(%rsp), %rdx
leaq 0x2c(%rsp), %rcx
leaq 0x50(%rsp), %r8
movl $0x29, %esi
callq 0x19c58
leaq 0x50(%rsp), %rdi
callq 0x16eca
leaq 0x8(%rsp), %rdi
callq 0x16eca
leaq 0x70(%rsp), %rdi
callq 0x16eca
leaq 0x30(%rsp), %rdi
callq 0x16eca
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x11770
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x19b55
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x19b55
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19b75
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x19b75
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r15, %rdi
je 0x19b94
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x19b94
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x19c43
movq 0x40(%rsp), %rsi
jmp 0x19bcf
jmp 0x19c40
jmp 0x19c40
jmp 0x19c40
jmp 0x19c40
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x19c43
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x19c43
jmp 0x19c40
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19bf9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11120
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x19c10
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x11120
testb %bpl, %bpl
jne 0x19c36
jmp 0x19c43
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x19c36
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x19c36
movq %rax, %rbx
movq %r14, %rdi
callq 0x11a50
jmp 0x19c43
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x11030
movq %rbx, %rdi
callq 0x11760
| _ZN5alaya10load_ivecsIjEEvRKNSt10filesystem7__cxx114pathERSt6vectorIT_SaIS7_EERjSB_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 298h
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov rsi, [rdi]
lea rdi, [rsp+2C8h+var_238]
mov edx, 4
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEEC1EPKcSt13_Ios_Openmode; std::ifstream::basic_ifstream(char const*,std::_Ios_Openmode)
lea rdi, [rsp+2C8h+var_1C0]
call __ZNKSt12__basic_fileIcE7is_openEv; std::__basic_file<char>::is_open(void)
test al, al
jz loc_19A65
lea rdi, [rsp+2C8h+var_238]; this
mov edx, 4; __int64
mov rsi, r14; char *
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov rax, [rsp+2C8h+var_238]
mov rax, [rax-18h]
test [rsp+rax+2C8h+var_218], 5
jz loc_1992B
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aFailedToReadDi; "Failed to read dimension from file: "
mov edx, 24h ; '$'
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, [rbx]
lea rbp, [rsp+2C8h+var_2B0]
mov rdx, [rbx+8]
add rdx, rsi
mov [rbp-10h], rbp
lea rdi, [rsp+2C8h+var_2C0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [rsp+2C8h+var_2C0]
mov rdx, [rsp+2C8h+var_2B8]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r13, rax
mov rax, [rax]
mov rdi, [rax-18h]
add rdi, r13
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, r13; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
mov rdi, [rsp+2C8h+var_2C0]; void *
cmp rdi, rbp
jz short loc_1992B
mov rsi, [rsp+2C8h+var_2B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1992B:
lea rdi, [rsp+2C8h+var_238]
xor esi, esi
mov edx, 2
call __ZNSi5seekgElSt12_Ios_Seekdir; std::istream::seekg(long,std::_Ios_Seekdir)
lea rdi, [rsp+2C8h+var_238]; this
call __ZNSi5tellgEv; std::istream::tellg(void)
mov r13, rax
lea rdi, [rsp+2C8h+var_238]
xor esi, esi
xor edx, edx
call __ZNSi5seekgElSt12_Ios_Seekdir; std::istream::seekg(long,std::_Ios_Seekdir)
mov eax, [r14]
lea rcx, ds:4[rax*4]
mov rax, r13
xor edx, edx
div rcx
mov [r15], eax
imul eax, [r14]
mov rdi, r12
mov rsi, rax
call _ZNSt6vectorIjSaIjEE6resizeEm; std::vector<uint>::resize(ulong)
cmp dword ptr [r15], 0
jz short loc_199DE
xor ebp, ebp
lea r13, [rsp+2C8h+var_238]
loc_19995:
mov edx, 4; __int64
mov rdi, r13; this
mov rsi, r14; char *
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov edx, [r14]
mov esi, edx
imul esi, ebp
shl rsi, 2
add rsi, [r12]; char *
shl rdx, 2; __int64
mov rdi, r13; this
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov rax, [rsp+2C8h+var_238]
mov rax, [rax-18h]
test [rsp+rax+2C8h+var_218], 5
jnz short loc_199FD
inc ebp
cmp ebp, [r15]
jb short loc_19995
loc_199DE:
lea rdi, [rsp+2C8h+var_238]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
add rsp, 298h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_199FD:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rsi, [rbx]
lea r15, [rsp+2C8h+var_288]
mov rdx, [rbx+8]
add rdx, rsi
mov [r15-10h], r15
lea rdi, [rsp+2C8h+var_298]
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, aFailedToReadDa; "Failed to read data from file: "
lea rdi, [rsp+2C8h+var_2C0]
lea rdx, [rsp+2C8h+var_298]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+2C8h+var_2C0]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_19A65:
lea r14, [rsp+2C8h+var_288]
mov [r14-10h], r14
lea rsi, aWorkspaceLlm4b_8; "/workspace/llm4binary/github2025/AlayaL"...
lea rdx, aWorkspaceLlm4b_8+45h; ""
lea rdi, [rsp+2C8h+var_298]
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 r15, [rsp+2C8h+var_248]
mov [r15-10h], r15
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/AlayaL"...
lea rdx, aWorkspaceLlm4b_4+2Ah; ""
lea rdi, [rsp+2C8h+var_258]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+2C8h+var_2C0]
lea rsi, [rsp+2C8h+var_298]
lea rdx, [rsp+2C8h+var_258]
call _Z17get_relative_pathRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_; get_relative_path(std::string const&,std::string const&)
mov [rsp+2C8h+var_29C], 0D8h
mov rsi, [rbx]
lea r12, [rsp+2C8h+var_268]
mov rdx, [rbx+8]
add rdx, rsi
mov [r12-10h], r12
lea rdi, [rsp+2C8h+var_278]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, aAlayaOpenFvecs; "[Alaya] [{}:{}] Open fvecs file error {"...
lea rdx, [rsp+2C8h+var_2C0]
lea rcx, [rsp+2C8h+var_29C]
lea r8, [rsp+2C8h+var_278]
mov esi, 29h ; ')'
call _ZN6spdlog8criticalIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiS6_EEEvN3fmt3v1019basic_format_stringIcJDpNS8_13type_identityIT_E4typeEEEEDpOSB_; spdlog::critical<std::string,int,std::string>(fmt::v10::basic_format_string<char,fmt::v10::type_identity<std::string,int,std::string>::type>,std::string,int,std::string&&)
lea rdi, [rsp+2C8h+var_278]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+2C8h+var_2C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+2C8h+var_258]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+2C8h+var_298]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov edi, 0FFFFFFFFh
call _exit
mov rbx, rax
mov rdi, [rsp+2C8h+var_278]; void *
cmp rdi, r12
jz short loc_19B55
mov rsi, [rsp+2C8h+var_268]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_19B55
mov rbx, rax
loc_19B55:
lea rax, [rsp+2C8h+var_2B0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_19B75
mov rsi, [rsp+2C8h+var_2B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_19B75
mov rbx, rax
loc_19B75:
mov rdi, [rsp+2C8h+var_258]; void *
cmp rdi, r15
jz short loc_19B94
mov rsi, [rsp+2C8h+var_248]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_19B94
mov rbx, rax
loc_19B94:
mov rdi, [rsp+2C8h+var_298]
cmp rdi, r14
jz loc_19C43
mov rsi, [rsp+2C8h+var_288]
jmp short loc_19BCF
jmp loc_19C40
jmp loc_19C40
jmp loc_19C40
jmp loc_19C40
mov rbx, rax
mov rdi, [rsp+2C8h+var_2C0]; void *
cmp rdi, rbp
jz short loc_19C43
mov rsi, [rsp+2C8h+var_2B0]
loc_19BCF:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_19C43
jmp short loc_19C40
mov rbx, rax
lea rax, [rsp+2C8h+var_2B0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_19BF9
mov rsi, [rsp+2C8h+var_2B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_19BF9:
mov rdi, [rsp+2C8h+var_298]; void *
cmp rdi, r15
jz short loc_19C10
mov rsi, [rsp+2C8h+var_288]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_19C10:
test bpl, bpl
jnz short loc_19C36
jmp short loc_19C43
mov rbx, rax
mov rdi, [rsp+2C8h+var_298]; void *
cmp rdi, r15
jz short loc_19C36
mov rsi, [rsp+2C8h+var_288]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_19C36
mov rbx, rax
loc_19C36:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_19C43
loc_19C40:
mov rbx, rax
loc_19C43:
lea rdi, [rsp+2C8h+var_238]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
mov rdi, rbx
call __Unwind_Resume
| long long alaya::load_ivecs<unsigned int>(_QWORD *a1, _QWORD *a2, unsigned int *a3, char *a4)
{
_BYTE *v7; // rsi
long long v8; // rdx
std::ostream *v9; // r13
char v10; // al
std::ostream *v11; // rax
unsigned long long v12; // r13
unsigned int v13; // eax
unsigned int v14; // ebp
void *exception; // r14
_BYTE *v17; // rsi
long long v18; // rdx
_BYTE *v19; // rsi
long long v20; // rdx
void *v21[2]; // [rsp+8h] [rbp-2C0h] BYREF
_QWORD v22[2]; // [rsp+18h] [rbp-2B0h] BYREF
int v23; // [rsp+2Ch] [rbp-29Ch] BYREF
void *v24[2]; // [rsp+30h] [rbp-298h] BYREF
void *v25[2]; // [rsp+40h] [rbp-288h] BYREF
void *v26[2]; // [rsp+50h] [rbp-278h] BYREF
long long v27; // [rsp+60h] [rbp-268h] BYREF
void *v28[2]; // [rsp+70h] [rbp-258h] BYREF
long long v29; // [rsp+80h] [rbp-248h] BYREF
_QWORD v30[15]; // [rsp+90h] [rbp-238h] BYREF
_BYTE v31[448]; // [rsp+108h] [rbp-1C0h] BYREF
std::ifstream::basic_ifstream(v30, *a1, 4LL);
if ( !(unsigned __int8)std::__basic_file<char>::is_open(v31) )
{
v24[0] = v25;
std::string::_M_construct<char const*>(
v24,
"/workspace/llm4binary/github2025/AlayaLite/include/utils/io_utils.hpp",
(long long)"");
v28[0] = &v29;
std::string::_M_construct<char const*>(v28, "/workspace/llm4binary/github2025/AlayaLite", (long long)"");
get_relative_path(v21);
v23 = 216;
v19 = (_BYTE *)*a1;
v20 = *a1 + a1[1];
v26[0] = &v27;
std::string::_M_construct<char const*>(v26, v19, v20);
spdlog::critical<std::string,int,std::string>("[Alaya] [{}:{}] Open fvecs file error {}.", 41LL, v21, &v23, v26);
std::string::~string(v26);
std::string::~string(v21);
std::string::~string(v28);
std::string::~string(v24);
exit(0xFFFFFFFFLL);
}
std::istream::read((std::istream *)v30, a4, 4LL);
if ( (*((_BYTE *)&v30[4] + *(_QWORD *)(v30[0] - 24LL)) & 5) != 0 )
{
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "Failed to read dimension from file: ", 36LL);
v7 = (_BYTE *)*a1;
v8 = *a1 + a1[1];
v21[0] = v22;
std::string::_M_construct<char const*>(v21, v7, v8);
v9 = (std::ostream *)std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v21[0], v21[1]);
v10 = std::ios::widen((char *)v9 + *(_QWORD *)(*(_QWORD *)v9 - 24LL), 10LL);
v11 = (std::ostream *)std::ostream::put(v9, v10);
std::ostream::flush(v11);
if ( v21[0] != v22 )
operator delete(v21[0], v22[0] + 1LL);
}
std::istream::seekg(v30, 0LL, 2LL);
v12 = std::istream::tellg((std::istream *)v30);
std::istream::seekg(v30, 0LL, 0LL);
v13 = v12 / (4 * (unsigned long long)*(unsigned int *)a4 + 4);
*a3 = v13;
std::vector<unsigned int>::resize(a2, *(_DWORD *)a4 * v13);
if ( *a3 )
{
v14 = 0;
do
{
std::istream::read((std::istream *)v30, a4, 4LL);
std::istream::read((std::istream *)v30, (char *)(*a2 + 4LL * v14 * *(_DWORD *)a4), 4LL * *(unsigned int *)a4);
if ( (*((_BYTE *)&v30[4] + *(_QWORD *)(v30[0] - 24LL)) & 5) != 0 )
{
exception = __cxa_allocate_exception(0x10uLL);
v17 = (_BYTE *)*a1;
v18 = *a1 + a1[1];
v24[0] = v25;
std::string::_M_construct<char const*>(v24, v17, v18);
std::operator+<char>(v21, "Failed to read data from file: ", v24);
std::runtime_error::runtime_error(exception, v21);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
++v14;
}
while ( v14 < *a3 );
}
return std::ifstream::~ifstream(v30);
}
| load_ivecs<unsigned_int>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x298
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RDI]
LEA RDI,[RSP + 0x90]
MOV EDX,0x4
CALL 0x00111050
LEA RDI,[RSP + 0x108]
CALL 0x00111c40
TEST AL,AL
JZ 0x00119a65
LAB_00119870:
LEA RDI,[RSP + 0x90]
MOV EDX,0x4
MOV RSI,R14
CALL 0x001115c0
MOV RAX,qword ptr [RSP + 0x90]
MOV RAX,qword ptr [RAX + -0x18]
TEST byte ptr [RSP + RAX*0x1 + 0xb0],0x5
JZ 0x0011992b
MOV RDI,qword ptr [0x001b3fd8]
LEA RSI,[0x17f733]
MOV EDX,0x24
CALL 0x00111b90
MOV RSI,qword ptr [RBX]
LEA RBP,[RSP + 0x18]
MOV RDX,qword ptr [RBX + 0x8]
ADD RDX,RSI
MOV qword ptr [RBP + -0x10],RBP
LAB_001198ca:
LEA RDI,[RSP + 0x8]
CALL 0x00119014
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001198de:
MOV RDI,qword ptr [0x001b3fd8]
CALL 0x00111b90
MOV R13,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,R13
MOV ESI,0xa
CALL 0x00111c80
MOVSX ESI,AL
MOV RDI,R13
CALL 0x00111670
MOV RDI,RAX
CALL 0x00111600
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x0011992b
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00111120
LAB_0011992b:
LEA RDI,[RSP + 0x90]
XOR ESI,ESI
MOV EDX,0x2
CALL 0x001113e0
LAB_0011993f:
LEA RDI,[RSP + 0x90]
CALL 0x00111150
LAB_0011994c:
MOV R13,RAX
LEA RDI,[RSP + 0x90]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001113e0
MOV EAX,dword ptr [R14]
LEA RCX,[0x4 + RAX*0x4]
MOV RAX,R13
XOR EDX,EDX
DIV RCX
MOV dword ptr [R15],EAX
IMUL EAX,dword ptr [R14]
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011a45c
CMP dword ptr [R15],0x0
JZ 0x001199de
XOR EBP,EBP
LEA R13,[RSP + 0x90]
LAB_00119995:
MOV EDX,0x4
MOV RDI,R13
MOV RSI,R14
CALL 0x001115c0
MOV EDX,dword ptr [R14]
MOV ESI,EDX
IMUL ESI,EBP
SHL RSI,0x2
ADD RSI,qword ptr [R12]
SHL RDX,0x2
MOV RDI,R13
CALL 0x001115c0
LAB_001199c1:
MOV RAX,qword ptr [RSP + 0x90]
MOV RAX,qword ptr [RAX + -0x18]
TEST byte ptr [RSP + RAX*0x1 + 0xb0],0x5
JNZ 0x001199fd
INC EBP
CMP EBP,dword ptr [R15]
JC 0x00119995
LAB_001199de:
LEA RDI,[RSP + 0x90]
CALL 0x00111030
ADD RSP,0x298
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001199fd:
MOV EDI,0x10
CALL 0x001114c0
MOV R14,RAX
MOV RSI,qword ptr [RBX]
LEA R15,[RSP + 0x40]
MOV RDX,qword ptr [RBX + 0x8]
ADD RDX,RSI
MOV qword ptr [R15 + -0x10],R15
LAB_00119a1d:
LEA RDI,[RSP + 0x30]
CALL 0x00119014
LAB_00119a27:
LEA RSI,[0x17f758]
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x30]
CALL 0x0011a48d
MOV BPL,0x1
LAB_00119a40:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x00111340
XOR EBP,EBP
MOV RSI,qword ptr [0x001b3fc8]
MOV RDX,qword ptr [0x001b3fa0]
MOV RDI,R14
CALL 0x00111720
LAB_00119a65:
LEA R14,[RSP + 0x40]
MOV qword ptr [R14 + -0x10],R14
LAB_00119a6e:
LEA RSI,[0x17f629]
LEA RDX,[0x17f66e]
LEA RDI,[RSP + 0x30]
CALL 0x00119014
LEA R15,[RSP + 0x80]
MOV qword ptr [R15 + -0x10],R15
LAB_00119a92:
LEA RSI,[0x17f25b]
LEA RDX,[0x17f285]
LEA RDI,[RSP + 0x70]
CALL 0x00119014
LAB_00119aaa:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x30]
LEA RDX,[RSP + 0x70]
CALL 0x00116f8a
MOV dword ptr [RSP + 0x2c],0xd8
MOV RSI,qword ptr [RBX]
LEA R12,[RSP + 0x60]
MOV RDX,qword ptr [RBX + 0x8]
ADD RDX,RSI
MOV qword ptr [R12 + -0x10],R12
LAB_00119ada:
LEA RDI,[RSP + 0x50]
CALL 0x00119014
LAB_00119ae4:
LEA RDI,[0x17f5ff]
LEA RDX,[RSP + 0x8]
LEA RCX,[RSP + 0x2c]
LEA R8,[RSP + 0x50]
MOV ESI,0x29
CALL 0x00119c58
LAB_00119b04:
LEA RDI,[RSP + 0x50]
CALL 0x00116eca
LEA RDI,[RSP + 0x8]
CALL 0x00116eca
LEA RDI,[RSP + 0x70]
CALL 0x00116eca
LEA RDI,[RSP + 0x30]
CALL 0x00116eca
MOV EDI,0xffffffff
CALL 0x00111770
|
/* void alaya::load_ivecs<unsigned int>(std::filesystem::__cxx11::path const&, std::vector<unsigned
int, std::allocator<unsigned int> >&, unsigned int&, unsigned int&) */
void alaya::load_ivecs<unsigned_int>(path *param_1,vector *param_2,uint *param_3,uint *param_4)
{
char cVar1;
ostream *poVar2;
ulong uVar3;
runtime_error *this;
uint uVar4;
long *local_2c0;
long local_2b8;
long local_2b0 [2];
int4 local_29c;
int1 *local_298 [2];
int1 local_288 [16];
int1 *local_278 [2];
int1 local_268 [16];
int1 *local_258 [2];
int1 local_248 [16];
long local_238 [4];
byte abStack_218 [488];
std::ifstream::ifstream((ifstream *)local_238,*(int8 *)param_1,4);
cVar1 = std::__basic_file<char>::is_open();
if (cVar1 == '\0') {
local_298[0] = local_288;
/* try { // try from 00119a6e to 00119a85 has its CatchHandler @ 00119ba9 */
std::__cxx11::string::_M_construct<char_const*>
(local_298,"/workspace/llm4binary/github2025/AlayaLite/include/utils/io_utils.hpp","")
;
local_258[0] = local_248;
/* try { // try from 00119a92 to 00119aa9 has its CatchHandler @ 00119b91 */
std::__cxx11::string::_M_construct<char_const*>
(local_258,"/workspace/llm4binary/github2025/AlayaLite","");
/* try { // try from 00119aaa to 00119abd has its CatchHandler @ 00119b72 */
get_relative_path((string *)&local_2c0,(string *)local_298);
local_29c = 0xd8;
local_278[0] = local_268;
/* try { // try from 00119ada to 00119ae3 has its CatchHandler @ 00119b52 */
std::__cxx11::string::_M_construct<char_const*>
(local_278,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
/* try { // try from 00119ae4 to 00119b03 has its CatchHandler @ 00119b36 */
spdlog::critical<std::__cxx11::string,int,std::__cxx11::string>
((spdlog *)"[Alaya] [{}:{}] Open fvecs file error {}.",0x29,&local_2c0,&local_29c,
local_278);
std::__cxx11::string::~string((string *)local_278);
std::__cxx11::string::~string((string *)&local_2c0);
std::__cxx11::string::~string((string *)local_258);
std::__cxx11::string::~string((string *)local_298);
/* WARNING: Subroutine does not return */
exit(-1);
}
/* try { // try from 00119870 to 001198b6 has its CatchHandler @ 00119bd9 */
std::istream::read((char *)local_238,(long)param_4);
if ((abStack_218[*(long *)(local_238[0] + -0x18)] & 5) != 0) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_001b3fd8,"Failed to read dimension from file: ",0x24);
/* try { // try from 001198ca to 001198d3 has its CatchHandler @ 00119bae */
local_2c0 = local_2b0;
std::__cxx11::string::_M_construct<char_const*>
(&local_2c0,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
/* try { // try from 001198de to 00119913 has its CatchHandler @ 00119bbd */
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_001b3fd8,(char *)local_2c0,local_2b8);
std::ios::widen((char)*(int8 *)(*(long *)poVar2 + -0x18) + (char)poVar2);
std::ostream::put((char)poVar2);
std::ostream::flush();
if (local_2c0 != local_2b0) {
operator_delete(local_2c0,local_2b0[0] + 1);
}
}
/* try { // try from 0011992b to 0011993e has its CatchHandler @ 00119bd9 */
std::istream::seekg(local_238,0,2);
/* try { // try from 0011993f to 0011994b has its CatchHandler @ 00119bb3 */
uVar3 = std::istream::tellg();
/* try { // try from 0011994c to 00119984 has its CatchHandler @ 00119bb8 */
std::istream::seekg(local_238,0,0);
uVar4 = (uint)(uVar3 / ((ulong)*param_4 * 4 + 4));
*param_3 = uVar4;
std::vector<unsigned_int,std::allocator<unsigned_int>>::resize
((vector<unsigned_int,std::allocator<unsigned_int>> *)param_2,(ulong)(uVar4 * *param_4))
;
if (*param_3 != 0) {
uVar4 = 0;
do {
/* try { // try from 00119995 to 001199c0 has its CatchHandler @ 00119c40 */
std::istream::read((char *)local_238,(long)param_4);
std::istream::read((char *)local_238,(ulong)(*param_4 * uVar4) * 4 + *(long *)param_2);
if ((abStack_218[*(long *)(local_238[0] + -0x18)] & 5) != 0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
local_298[0] = local_288;
/* try { // try from 00119a1d to 00119a26 has its CatchHandler @ 00119c33 */
std::__cxx11::string::_M_construct<char_const*>
(local_298,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
/* try { // try from 00119a27 to 00119a3c has its CatchHandler @ 00119c17 */
std::operator+((char *)&local_2c0,(string *)"Failed to read data from file: ");
/* try { // try from 00119a40 to 00119a64 has its CatchHandler @ 00119bdb */
std::runtime_error::runtime_error(this,(string *)&local_2c0);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001b3fc8,PTR__runtime_error_001b3fa0);
}
uVar4 = uVar4 + 1;
} while (uVar4 < *param_3);
}
std::ifstream::~ifstream((ifstream *)local_238);
return;
}
| |
25,991 | ft_free_stopwords | eloqsql/storage/myisam/ft_stopwords.c | void ft_free_stopwords()
{
DBUG_ENTER("ft_free_stopwords");
if (stopwords3)
{
delete_tree(stopwords3, 0); /* purecov: inspected */
my_free(stopwords3);
stopwords3=0;
}
ft_stopword_file= 0;
DBUG_VOID_RETURN;
} | O0 | c | ft_free_stopwords:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0xbdc4a4(%rip) # 0xc7a540
je 0x9e0c3
movq 0xbdc49b(%rip), %rdi # 0xc7a540
xorl %esi, %esi
callq 0xfa5c0
movq 0xbdc48d(%rip), %rdi # 0xc7a540
callq 0xf3be0
movq $0x0, 0xbdc47d(%rip) # 0xc7a540
leaq 0xbdc46e(%rip), %rax # 0xc7a538
movq $0x0, (%rax)
jmp 0x9e0d3
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| ft_free_stopwords:
push rbp
mov rbp, rsp
cmp cs:stopwords3, 0
jz short loc_9E0C3
mov rdi, cs:stopwords3
xor esi, esi
call delete_tree
mov rdi, cs:stopwords3
call my_free
mov cs:stopwords3, 0
loc_9E0C3:
lea rax, ft_stopword_file
mov qword ptr [rax], 0
jmp short $+2
loc_9E0D3:
pop rbp
retn
| _BYTE **ft_free_stopwords()
{
_BYTE **result; // rax
if ( stopwords3 )
{
delete_tree(stopwords3, 0LL);
my_free(stopwords3);
stopwords3 = 0LL;
}
result = &ft_stopword_file;
ft_stopword_file = 0LL;
return result;
}
| ft_free_stopwords:
PUSH RBP
MOV RBP,RSP
CMP qword ptr [0x00d7a540],0x0
JZ 0x0019e0c3
MOV RDI,qword ptr [0x00d7a540]
XOR ESI,ESI
CALL 0x001fa5c0
MOV RDI,qword ptr [0x00d7a540]
CALL 0x001f3be0
MOV qword ptr [0x00d7a540],0x0
LAB_0019e0c3:
LEA RAX,[0xd7a538]
MOV qword ptr [RAX],0x0
JMP 0x0019e0d3
LAB_0019e0d3:
POP RBP
RET
|
void ft_free_stopwords(void)
{
if (stopwords3 != 0) {
delete_tree(stopwords3,0);
my_free(stopwords3);
stopwords3 = 0;
}
ft_stopword_file = 0;
return;
}
| |
25,992 | find_collation_data_inheritance_source | eloqsql/mysys/charset.c | static CHARSET_INFO *find_collation_data_inheritance_source(CHARSET_INFO *cs, myf flags)
{
const char *beg, *end;
if (cs->tailoring &&
!strncmp(cs->tailoring, "[import ", 8) &&
(end= strchr(cs->tailoring + 8, ']')) &&
(beg= cs->tailoring + 8) + MY_CS_NAME_SIZE > end)
{
char name[MY_CS_NAME_SIZE + 1];
memcpy(name, beg, end - beg);
name[end - beg]= '\0';
return inheritance_source_by_id(cs, get_collation_number(name,MYF(flags)));
}
return NULL;
} | O0 | c | find_collation_data_inheritance_source:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xddbc6
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x76431(%rip), %rsi # 0x153f5c
movl $0x8, %edx
callq 0x2a1e0
cmpl $0x0, %eax
jne 0xddbc6
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x8, %rdi
movl $0x5d, %esi
callq 0x2a410
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xddbc6
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
addq $0x20, %rax
cmpq -0x58(%rbp), %rax
jbe 0xddbc6
leaq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rax
subq %rax, %rdx
callq 0x2a090
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
movb $0x0, -0x30(%rbp,%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xdb900
movq -0x60(%rbp), %rdi
movl %eax, %esi
callq 0xddd40
movq %rax, -0x38(%rbp)
jmp 0xddbce
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xddbf2
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
callq 0x2a270
nopw (%rax,%rax)
| find_collation_data_inheritance_source:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_40], rdi
mov [rbp+var_48], rsi
mov rax, [rbp+var_40]
cmp qword ptr [rax+38h], 0
jz loc_DDBC6
mov rax, [rbp+var_40]
mov rdi, [rax+38h]
lea rsi, aImport; "[import "
mov edx, 8
call _strncmp
cmp eax, 0
jnz loc_DDBC6
mov rax, [rbp+var_40]
mov rdi, [rax+38h]
add rdi, 8
mov esi, 5Dh ; ']'
call _strchr
mov [rbp+var_58], rax
cmp rax, 0
jz short loc_DDBC6
mov rax, [rbp+var_40]
mov rax, [rax+38h]
add rax, 8
mov [rbp+var_50], rax
add rax, 20h ; ' '
cmp rax, [rbp+var_58]
jbe short loc_DDBC6
lea rdi, [rbp+var_30]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_58]
mov rax, [rbp+var_50]
sub rdx, rax
call _memcpy
mov rax, [rbp+var_58]
mov rcx, [rbp+var_50]
sub rax, rcx
mov [rbp+rax+var_30], 0
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
lea rdi, [rbp+var_30]
mov rsi, [rbp+var_48]
call get_collation_number
mov rdi, [rbp+var_60]
mov esi, eax
call inheritance_source_by_id
mov [rbp+var_38], rax
jmp short loc_DDBCE
loc_DDBC6:
mov [rbp+var_38], 0
loc_DDBCE:
mov rax, [rbp+var_38]
mov [rbp+var_68], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_DDBF2
mov rax, [rbp+var_68]
add rsp, 70h
pop rbp
retn
loc_DDBF2:
call ___stack_chk_fail
| long long find_collation_data_inheritance_source(long long a1, long long a2)
{
unsigned int collation_number; // eax
unsigned long long v4; // [rsp+18h] [rbp-58h]
long long v5; // [rsp+20h] [rbp-50h]
_BYTE v7[40]; // [rsp+40h] [rbp-30h] BYREF
unsigned long long v8; // [rsp+68h] [rbp-8h]
v8 = __readfsqword(0x28u);
if ( !*(_QWORD *)(a1 + 56) )
return 0LL;
if ( (unsigned int)strncmp(*(_QWORD *)(a1 + 56), "[import ", 8LL) )
return 0LL;
v4 = strchr(*(_QWORD *)(a1 + 56) + 8LL, 93LL);
if ( !v4 )
return 0LL;
v5 = *(_QWORD *)(a1 + 56) + 8LL;
if ( *(_QWORD *)(a1 + 56) + 40LL <= v4 )
return 0LL;
memcpy(v7, v5, v4 - v5);
v7[v4 - v5] = 0;
collation_number = get_collation_number((long long)v7, a2);
return inheritance_source_by_id(a1, collation_number);
}
| find_collation_data_inheritance_source:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x40],RDI
MOV qword ptr [RBP + -0x48],RSI
MOV RAX,qword ptr [RBP + -0x40]
CMP qword ptr [RAX + 0x38],0x0
JZ 0x001ddbc6
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0x38]
LEA RSI,[0x253f5c]
MOV EDX,0x8
CALL 0x0012a1e0
CMP EAX,0x0
JNZ 0x001ddbc6
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x8
MOV ESI,0x5d
CALL 0x0012a410
MOV qword ptr [RBP + -0x58],RAX
CMP RAX,0x0
JZ 0x001ddbc6
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x38]
ADD RAX,0x8
MOV qword ptr [RBP + -0x50],RAX
ADD RAX,0x20
CMP RAX,qword ptr [RBP + -0x58]
JBE 0x001ddbc6
LEA RDI,[RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x50]
SUB RDX,RAX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
MOV byte ptr [RBP + RAX*0x1 + -0x30],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
LEA RDI,[RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x001db900
MOV RDI,qword ptr [RBP + -0x60]
MOV ESI,EAX
CALL 0x001ddd40
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001ddbce
LAB_001ddbc6:
MOV qword ptr [RBP + -0x38],0x0
LAB_001ddbce:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001ddbf2
MOV RAX,qword ptr [RBP + -0x68]
ADD RSP,0x70
POP RBP
RET
LAB_001ddbf2:
CALL 0x0012a270
|
int8 find_collation_data_inheritance_source(long param_1,int8 param_2)
{
int iVar1;
int4 uVar2;
char *pcVar3;
void *__src;
long in_FS_OFFSET;
int8 local_40;
char local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (*(long *)(param_1 + 0x38) != 0) {
iVar1 = strncmp(*(char **)(param_1 + 0x38),"[import ",8);
if (iVar1 == 0) {
pcVar3 = strchr((char *)(*(long *)(param_1 + 0x38) + 8),0x5d);
if ((pcVar3 != (char *)0x0) &&
(__src = (void *)(*(long *)(param_1 + 0x38) + 8),
pcVar3 < (char *)(*(long *)(param_1 + 0x38) + 0x28))) {
memcpy(local_38,__src,(long)pcVar3 - (long)__src);
pcVar3[(long)(local_38 + -(long)__src)] = '\0';
uVar2 = get_collation_number(local_38,param_2);
local_40 = inheritance_source_by_id(param_1,uVar2);
goto LAB_001ddbce;
}
}
}
local_40 = 0;
LAB_001ddbce:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_40;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
25,993 | translog_relative_LSN_decode | eloqsql/storage/maria/ma_loghandler.c | static uchar *translog_relative_LSN_decode(LSN base_lsn,
uchar *src, uchar *dst, uint lsns)
{
uint i;
for (i= 0; i < lsns; i++, dst+= LSN_STORE_SIZE)
{
src= translog_get_LSN_from_diff(base_lsn, src, dst);
}
return src;
} | O3 | c | translog_relative_LSN_decode:
movq %rsi, %rax
testl %ecx, %ecx
je 0x6d027
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rsi
shrq $0x20, %rsi
movl %edi, %r8d
leaq 0x767d1(%rip), %r9 # 0xe3750
movzbl (%rax), %r11d
movl %r11d, %r10d
shrl $0x6, %r10d
andl $0x3f, %r11d
leaq 0x1(%rax), %r14
movslq (%r9,%r10,4), %rbx
addq %r9, %rbx
jmpq *%rbx
movb (%r14), %bl
movl %ebx, %r15d
xorb $0x1, %r15b
orb %r11b, %r15b
jne 0x6cfed
movl 0x2(%rax), %r10d
movl 0x5(%rax), %r11d
movl %r11d, 0x3(%rdx)
movl %r10d, (%rdx)
addq $0x9, %rax
jmp 0x6d015
movzwl 0x1(%rax), %ebx
movzbl 0x3(%rax), %eax
shll $0x18, %r11d
orl %ebx, %r11d
shll $0x10, %eax
jmp 0x6cff4
movl (%r14), %eax
cmpl %eax, %r8d
movl %esi, %ebx
sbbl %r11d, %ebx
movl %eax, %r11d
jmp 0x6cff9
movzwl (%r14), %eax
shll $0x10, %r11d
jmp 0x6cff4
movzbl %bl, %eax
shll $0x8, %r11d
orl %eax, %r11d
movl %esi, %ebx
movl %edi, %r15d
subl %r11d, %r15d
leaq (%r14,%r10), %rax
incq %rax
movb %bl, (%rdx)
movb %bh, 0x1(%rdx)
shrl $0x10, %ebx
movb %bl, 0x2(%rdx)
movl %r15d, 0x3(%rdx)
addq $0x7, %rdx
decl %ecx
jne 0x6cf7f
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| translog_relative_LSN_decode:
mov rax, rsi
test ecx, ecx
jz locret_6D027
push rbp
mov rbp, rsp
push r15
push r14
push rbx
mov rsi, rdi
shr rsi, 20h
mov r8d, edi
lea r9, jpt_6CF99
loc_6CF7F:
movzx r11d, byte ptr [rax]
mov r10d, r11d
shr r10d, 6
and r11d, 3Fh
lea r14, [rax+1]
movsxd rbx, ds:(jpt_6CF99 - 0E3750h)[r9+r10*4]; switch 4 cases
add rbx, r9
jmp rbx; switch jump
loc_6CF9B:
mov bl, [r14]; jumptable 000000000006CF99 case 0
mov r15d, ebx
xor r15b, 1
or r15b, r11b
jnz short loc_6CFED
mov r10d, [rax+2]
mov r11d, [rax+5]
mov [rdx+3], r11d
mov [rdx], r10d
add rax, 9
jmp short loc_6D015
loc_6CFBF:
movzx ebx, word ptr [rax+1]; jumptable 000000000006CF99 case 2
movzx eax, byte ptr [rax+3]
shl r11d, 18h
or r11d, ebx
shl eax, 10h
jmp short loc_6CFF4
loc_6CFD3:
mov eax, [r14]; jumptable 000000000006CF99 case 3
cmp r8d, eax
mov ebx, esi
sbb ebx, r11d
mov r11d, eax
jmp short loc_6CFF9
loc_6CFE3:
movzx eax, word ptr [r14]; jumptable 000000000006CF99 case 1
shl r11d, 10h
jmp short loc_6CFF4
loc_6CFED:
movzx eax, bl
shl r11d, 8
loc_6CFF4:
or r11d, eax
mov ebx, esi
loc_6CFF9:
mov r15d, edi
sub r15d, r11d
lea rax, [r14+r10]
inc rax
mov [rdx], bl
mov [rdx+1], bh
shr ebx, 10h
mov [rdx+2], bl
mov [rdx+3], r15d
loc_6D015:
add rdx, 7
dec ecx
jnz loc_6CF7F
pop rbx
pop r14
pop r15
pop rbp
locret_6D027:
retn
| unsigned __int8 * translog_relative_LSN_decode(long long a1, unsigned __int8 *a2, long long a3, int a4)
{
unsigned __int8 *result; // rax
long long v5; // r10
int v6; // r11d
int *v7; // r14
int v8; // r10d
int v9; // r11d
int v10; // eax
int v11; // ebx
int v12; // r11d
result = a2;
if ( a4 )
{
while ( 2 )
{
v5 = *result >> 6;
v6 = *result & 0x3F;
v7 = (int *)(result + 1);
switch ( *result >> 6 )
{
case 0:
if ( (unsigned __int8)v6 | *(_BYTE *)v7 ^ 1 )
{
v10 = *(unsigned __int8 *)v7;
v9 = v6 << 8;
goto LABEL_9;
}
v8 = *(_DWORD *)(result + 2);
*(_DWORD *)(a3 + 3) = *(_DWORD *)(result + 5);
*(_DWORD *)a3 = v8;
result += 9;
goto LABEL_11;
case 1:
v10 = *(unsigned __int16 *)v7;
v9 = v6 << 16;
goto LABEL_9;
case 2:
v9 = *(unsigned __int16 *)(result + 1) | (v6 << 24);
v10 = result[3] << 16;
LABEL_9:
v12 = v10 | v9;
v11 = HIDWORD(a1);
goto LABEL_10;
case 3:
v11 = (a1 - __PAIR64__(v6, *v7)) >> 32;
v12 = *v7;
LABEL_10:
result = (unsigned __int8 *)v7 + v5 + 1;
*(_WORD *)a3 = v11;
*(_BYTE *)(a3 + 2) = BYTE2(v11);
*(_DWORD *)(a3 + 3) = a1 - v12;
LABEL_11:
a3 += 7LL;
if ( !--a4 )
return result;
continue;
}
}
}
return result;
}
| translog_relative_LSN_decode:
MOV RAX,RSI
TEST ECX,ECX
JZ 0x0016d027
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
MOV RSI,RDI
SHR RSI,0x20
MOV R8D,EDI
LEA R9,[0x1e3750]
MOVZX R11D,byte ptr [RAX]
MOV R10D,R11D
SHR R10D,0x6
AND R11D,0x3f
LEA R14,[RAX + 0x1]
MOVSXD RBX,dword ptr [R9 + R10*0x4]
ADD RBX,R9
JMP RBX
LAB_0016d027:
RET
|
void translog_relative_LSN_decode(int8 param_1,byte *param_2,int8 param_3,int param_4)
{
if (param_4 != 0) {
/* WARNING: Could not recover jumptable at 0x0016cf99. Too many branches */
/* WARNING: Treating indirect jump as call */
(*(code *)(&DAT_001e3750 + *(int *)(&DAT_001e3750 + (ulong)(*param_2 >> 6) * 4)))
((int)param_1,(int)((ulong)param_1 >> 0x20),param_3,param_4,(int)param_1);
return;
}
return;
}
| |
25,994 | maria_ftparser_call_initializer | eloqsql/storage/maria/ma_ft_parser.c | MYSQL_FTPARSER_PARAM *maria_ftparser_call_initializer(MARIA_HA *info,
uint keynr, uint paramnr)
{
uint32 ftparser_nr;
struct st_mysql_ftparser *parser;
if (!maria_ftparser_alloc_param(info))
return 0;
if (keynr == NO_SUCH_KEY)
{
ftparser_nr= 0;
parser= &ft_default_parser;
}
else
{
ftparser_nr= info->s->keyinfo[keynr].ftkey_nr;
parser= info->s->keyinfo[keynr].parser;
}
DBUG_ASSERT(paramnr < MAX_PARAM_NR);
ftparser_nr= ftparser_nr*MAX_PARAM_NR + paramnr;
if (! info->ftparser_param[ftparser_nr].mysql_add_word)
{
/* Note, that mysql_add_word is used here as a flag:
mysql_add_word == 0 - parser is not initialized
mysql_add_word != 0 - parser is initialized, or no
initialization needed. */
info->ftparser_param[ftparser_nr].mysql_add_word=
(int (*)(struct st_mysql_ftparser_param *, const char *,
int, MYSQL_FTPARSER_BOOLEAN_INFO *)) 1;
if (parser->init && parser->init(&info->ftparser_param[ftparser_nr]))
return 0;
}
return &info->ftparser_param[ftparser_nr];
} | O3 | c | maria_ftparser_call_initializer:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x47681
xorl %r12d, %r12d
testq %rax, %rax
je 0x47779
cmpl $-0x1, %r15d
je 0x4772d
movq (%rbx), %rax
movq 0x570(%rax), %rax
movl %r15d, %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
movl 0xbc(%rax,%rcx), %r12d
movq 0xd0(%rax,%rcx), %rcx
addl %r12d, %r12d
jmp 0x47734
leaq 0x33fc7c(%rip), %rcx # 0x3873b0
addl %r14d, %r12d
movq 0x368(%rbx), %rax
shlq $0x6, %r12
cmpq $0x0, 0x8(%rax,%r12)
je 0x4774f
addq %r12, %rax
jmp 0x4777b
addq %r12, %rax
addq $0x8, %rax
movq $0x1, (%rax)
movq 0x10(%rcx), %rcx
movq 0x368(%rbx), %rax
testq %rcx, %rcx
je 0x4774a
addq %r12, %rax
movq %rax, %rdi
callq *%rcx
testl %eax, %eax
je 0x47784
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x368(%rbx), %rax
jmp 0x4774a
| maria_ftparser_call_initializer:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14d, edx
mov r15d, esi
mov rbx, rdi
call maria_ftparser_alloc_param
xor r12d, r12d
test rax, rax
jz short loc_47779
cmp r15d, 0FFFFFFFFh
jz short loc_4772D
mov rax, [rbx]
mov rax, [rax+570h]
mov ecx, r15d
imul rcx, 118h
mov r12d, [rax+rcx+0BCh]
mov rcx, [rax+rcx+0D0h]
add r12d, r12d
jmp short loc_47734
loc_4772D:
lea rcx, ft_default_parser
loc_47734:
add r12d, r14d
mov rax, [rbx+368h]
shl r12, 6
cmp qword ptr [rax+r12+8], 0
jz short loc_4774F
loc_4774A:
add rax, r12
jmp short loc_4777B
loc_4774F:
add rax, r12
add rax, 8
mov qword ptr [rax], 1
mov rcx, [rcx+10h]
mov rax, [rbx+368h]
test rcx, rcx
jz short loc_4774A
add rax, r12
mov rdi, rax
call rcx
test eax, eax
jz short loc_47784
loc_47779:
xor eax, eax
loc_4777B:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_47784:
mov rax, [rbx+368h]
jmp short loc_4774A
| long long maria_ftparser_call_initializer(_QWORD *a1, unsigned int a2, int a3)
{
int v4; // r12d
long long v5; // rax
long long v6; // rcx
int v7; // r12d
_QWORD *v8; // rcx
long long v9; // rax
unsigned long long v10; // r12
unsigned int ( *v12)(unsigned long long); // rcx
v4 = 0;
if ( !maria_ftparser_alloc_param(a1) )
return 0LL;
if ( a2 == -1 )
{
v8 = &ft_default_parser;
}
else
{
v5 = *(_QWORD *)(*a1 + 1392LL);
v6 = 280LL * a2;
v7 = *(_DWORD *)(v5 + v6 + 188);
v8 = *(_QWORD **)(v5 + v6 + 208);
v4 = 2 * v7;
}
v9 = a1[109];
v10 = (unsigned long long)(unsigned int)(a3 + v4) << 6;
if ( *(_QWORD *)(v9 + v10 + 8) )
return v10 + v9;
*(_QWORD *)(v10 + v9 + 8) = 1LL;
v12 = (unsigned int ( *)(unsigned long long))v8[2];
v9 = a1[109];
if ( !v12 )
return v10 + v9;
if ( !v12(v10 + v9) )
{
v9 = a1[109];
return v10 + v9;
}
return 0LL;
}
| maria_ftparser_call_initializer:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14D,EDX
MOV R15D,ESI
MOV RBX,RDI
CALL 0x00147681
XOR R12D,R12D
TEST RAX,RAX
JZ 0x00147779
CMP R15D,-0x1
JZ 0x0014772d
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,R15D
IMUL RCX,RCX,0x118
MOV R12D,dword ptr [RAX + RCX*0x1 + 0xbc]
MOV RCX,qword ptr [RAX + RCX*0x1 + 0xd0]
ADD R12D,R12D
JMP 0x00147734
LAB_0014772d:
LEA RCX,[0x4873b0]
LAB_00147734:
ADD R12D,R14D
MOV RAX,qword ptr [RBX + 0x368]
SHL R12,0x6
CMP qword ptr [RAX + R12*0x1 + 0x8],0x0
JZ 0x0014774f
LAB_0014774a:
ADD RAX,R12
JMP 0x0014777b
LAB_0014774f:
ADD RAX,R12
ADD RAX,0x8
MOV qword ptr [RAX],0x1
MOV RCX,qword ptr [RCX + 0x10]
MOV RAX,qword ptr [RBX + 0x368]
TEST RCX,RCX
JZ 0x0014774a
ADD RAX,R12
MOV RDI,RAX
CALL RCX
TEST EAX,EAX
JZ 0x00147784
LAB_00147779:
XOR EAX,EAX
LAB_0014777b:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00147784:
MOV RAX,qword ptr [RBX + 0x368]
JMP 0x0014774a
|
long maria_ftparser_call_initializer(long *param_1,uint param_2,int param_3)
{
int iVar1;
long lVar2;
int1 *puVar3;
long lVar4;
lVar2 = maria_ftparser_alloc_param();
iVar1 = 0;
if (lVar2 == 0) {
LAB_00147779:
lVar2 = 0;
}
else {
if (param_2 == 0xffffffff) {
puVar3 = ft_default_parser;
}
else {
puVar3 = *(int1 **)(*(long *)(*param_1 + 0x570) + 0xd0 + (ulong)param_2 * 0x118);
iVar1 = *(int *)(*(long *)(*param_1 + 0x570) + 0xbc + (ulong)param_2 * 0x118) * 2;
}
lVar2 = param_1[0x6d];
lVar4 = (ulong)(uint)(iVar1 + param_3) * 0x40;
if (*(long *)(lVar2 + 8 + lVar4) == 0) {
*(int8 *)(lVar2 + lVar4 + 8) = 1;
lVar2 = param_1[0x6d];
if (*(code **)(puVar3 + 0x10) != (code *)0x0) {
iVar1 = (**(code **)(puVar3 + 0x10))(lVar2 + lVar4);
if (iVar1 != 0) goto LAB_00147779;
lVar2 = param_1[0x6d];
}
}
lVar2 = lVar2 + lVar4;
}
return lVar2;
}
| |
25,995 | PVG_FT_Sin | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-math.c | PVG_FT_Fixed PVG_FT_Sin(PVG_FT_Angle angle)
{
return PVG_FT_Cos(PVG_FT_ANGLE_PI2 - angle);
} | O1 | c | PVG_FT_Sin:
pushq %rbx
subq $0x10, %rsp
movl $0x5a0000, %esi # imm = 0x5A0000
subq %rdi, %rsi
movq %rsp, %rbx
movq $0xdbd95b, (%rbx) # imm = 0xDBD95B
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x4221b
movq (%rbx), %rax
subq $-0x80, %rax
sarq $0x8, %rax
addq $0x10, %rsp
popq %rbx
retq
| PVG_FT_Sin:
push rbx
sub rsp, 10h
mov esi, 5A0000h
sub rsi, rdi
mov rbx, rsp
mov qword ptr [rbx], 0DBD95Bh
mov qword ptr [rbx+8], 0
mov rdi, rbx
call ft_trig_pseudo_rotate
mov rax, [rbx]
sub rax, 0FFFFFFFFFFFFFF80h
sar rax, 8
add rsp, 10h
pop rbx
retn
| long long PVG_FT_Sin(long long a1)
{
long long v2[3]; // [rsp+0h] [rbp-18h] BYREF
v2[0] = 14408027LL;
v2[1] = 0LL;
ft_trig_pseudo_rotate(v2, 5898240 - a1);
return (v2[0] + 128) >> 8;
}
| PVG_FT_Sin:
PUSH RBX
SUB RSP,0x10
MOV ESI,0x5a0000
SUB RSI,RDI
MOV RBX,RSP
MOV qword ptr [RBX],0xdbd95b
MOV qword ptr [RBX + 0x8],0x0
MOV RDI,RBX
CALL 0x0014221b
MOV RAX,qword ptr [RBX]
SUB RAX,-0x80
SAR RAX,0x8
ADD RSP,0x10
POP RBX
RET
|
long PVG_FT_Sin(long param_1)
{
long local_18 [2];
local_18[0] = 0xdbd95b;
local_18[1] = 0;
ft_trig_pseudo_rotate(local_18,0x5a0000 - param_1);
return local_18[0] + 0x80 >> 8;
}
| |
25,996 | MemoryManager::setByte(unsigned int, unsigned char, unsigned int*) | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp | bool MemoryManager::setByte(uint32_t addr, uint8_t val, uint32_t *cycles) {
if (!this->isAddrExist(addr)) {
dbgprintf("Byte write to invalid addr 0x%x!\n", addr);
return false;
}
if (this->cache != nullptr) {
this->cache->setByte(addr, val, cycles);
return true;
}
uint32_t i = this->getFirstEntryId(addr);
uint32_t j = this->getSecondEntryId(addr);
uint32_t k = this->getPageOffset(addr);
this->memory[i][j][k] = val;
return true;
} | O0 | cpp | MemoryManager::setByte(unsigned int, unsigned char, unsigned int*):
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movb %al, 0x23(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x24(%rsp), %esi
callq 0x3430
testb $0x1, %al
jne 0x35aa
movl 0x24(%rsp), %esi
leaq 0x4bc3(%rip), %rdi # 0x815c
movb $0x0, %al
callq 0x2f60
movb $0x0, 0x37(%rsp)
jmp 0x3638
movq (%rsp), %rax
cmpq $0x0, 0x2000(%rax)
je 0x35df
movq (%rsp), %rax
movq 0x2000(%rax), %rdi
movl 0x24(%rsp), %esi
movb 0x23(%rsp), %al
movq 0x18(%rsp), %rcx
movzbl %al, %edx
callq 0x4d50
movb $0x1, 0x37(%rsp)
jmp 0x3638
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x33c0
movq (%rsp), %rdi
movl %eax, 0x14(%rsp)
movl 0x24(%rsp), %esi
callq 0x33e0
movq (%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x24(%rsp), %esi
callq 0x3650
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rsp)
movb 0x23(%rsp), %dl
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x10(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0xc(%rsp), %ecx
movb %dl, (%rax,%rcx)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN13MemoryManager7setByteEjhPj:
sub rsp, 38h
mov al, dl
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_14], esi
mov [rsp+38h+var_15], al
mov [rsp+38h+var_20], rcx
mov rdi, [rsp+38h+var_10]; this
mov [rsp+38h+var_38], rdi
mov esi, [rsp+38h+var_14]; unsigned int
call _ZN13MemoryManager11isAddrExistEj; MemoryManager::isAddrExist(uint)
test al, 1
jnz short loc_35AA
mov esi, [rsp+38h+var_14]
lea rdi, aByteWriteToInv; "Byte write to invalid addr 0x%x!\n"
mov al, 0
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
mov [rsp+38h+var_1], 0
jmp loc_3638
loc_35AA:
mov rax, [rsp+38h+var_38]
cmp qword ptr [rax+2000h], 0
jz short loc_35DF
mov rax, [rsp+38h+var_38]
mov rdi, [rax+2000h]; this
mov esi, [rsp+38h+var_14]; unsigned int
mov al, [rsp+38h+var_15]
mov rcx, [rsp+38h+var_20]; unsigned int *
movzx edx, al; unsigned __int8
call _ZN5Cache7setByteEjhPj; Cache::setByte(uint,uchar,uint *)
mov [rsp+38h+var_1], 1
jmp short loc_3638
loc_35DF:
mov rdi, [rsp+38h+var_38]; this
mov esi, [rsp+38h+var_14]; unsigned int
call _ZN13MemoryManager15getFirstEntryIdEj; MemoryManager::getFirstEntryId(uint)
mov rdi, [rsp+38h+var_38]; this
mov [rsp+38h+var_24], eax
mov esi, [rsp+38h+var_14]; unsigned int
call _ZN13MemoryManager16getSecondEntryIdEj; MemoryManager::getSecondEntryId(uint)
mov rdi, [rsp+38h+var_38]; this
mov [rsp+38h+var_28], eax
mov esi, [rsp+38h+var_14]; unsigned int
call _ZN13MemoryManager13getPageOffsetEj; MemoryManager::getPageOffset(uint)
mov ecx, eax
mov rax, [rsp+38h+var_38]
mov [rsp+38h+var_2C], ecx
mov dl, [rsp+38h+var_15]
mov ecx, [rsp+38h+var_24]
mov rax, [rax+rcx*8]
mov ecx, [rsp+38h+var_28]
mov rax, [rax+rcx*8]
mov ecx, [rsp+38h+var_2C]
mov [rax+rcx], dl
mov [rsp+38h+var_1], 1
loc_3638:
mov al, [rsp+38h+var_1]
and al, 1
add rsp, 38h
retn
| char MemoryManager::setByte(
Cache **this,
unsigned int a2,
unsigned __int8 a3,
unsigned int *a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
unsigned int SecondEntryId; // [rsp+10h] [rbp-28h]
int FirstEntryId; // [rsp+14h] [rbp-24h]
if ( MemoryManager::isAddrExist((MemoryManager *)this, a2) )
{
if ( this[1024] )
{
Cache::setByte(this[1024], a2, a3, a4);
}
else
{
FirstEntryId = MemoryManager::getFirstEntryId((MemoryManager *)this, a2);
SecondEntryId = MemoryManager::getSecondEntryId((MemoryManager *)this, a2);
*(_BYTE *)(*((_QWORD *)this[FirstEntryId] + SecondEntryId)
+ (unsigned int)MemoryManager::getPageOffset((MemoryManager *)this, a2)) = a3;
}
return 1;
}
else
{
dbgprintf(
"Byte write to invalid addr 0x%x!\n",
a2,
v12,
v13,
v14,
v15,
a5,
a6,
a7,
a8,
v16,
v17,
a11,
a12,
(char)this);
return 0;
}
}
| setByte:
SUB RSP,0x38
MOV AL,DL
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x24],ESI
MOV byte ptr [RSP + 0x23],AL
MOV qword ptr [RSP + 0x18],RCX
MOV RDI,qword ptr [RSP + 0x28]
MOV qword ptr [RSP],RDI
MOV ESI,dword ptr [RSP + 0x24]
CALL 0x00103430
TEST AL,0x1
JNZ 0x001035aa
MOV ESI,dword ptr [RSP + 0x24]
LEA RDI,[0x10815c]
MOV AL,0x0
CALL 0x00102f60
MOV byte ptr [RSP + 0x37],0x0
JMP 0x00103638
LAB_001035aa:
MOV RAX,qword ptr [RSP]
CMP qword ptr [RAX + 0x2000],0x0
JZ 0x001035df
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0x2000]
MOV ESI,dword ptr [RSP + 0x24]
MOV AL,byte ptr [RSP + 0x23]
MOV RCX,qword ptr [RSP + 0x18]
MOVZX EDX,AL
CALL 0x00104d50
MOV byte ptr [RSP + 0x37],0x1
JMP 0x00103638
LAB_001035df:
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [RSP + 0x24]
CALL 0x001033c0
MOV RDI,qword ptr [RSP]
MOV dword ptr [RSP + 0x14],EAX
MOV ESI,dword ptr [RSP + 0x24]
CALL 0x001033e0
MOV RDI,qword ptr [RSP]
MOV dword ptr [RSP + 0x10],EAX
MOV ESI,dword ptr [RSP + 0x24]
CALL 0x00103650
MOV ECX,EAX
MOV RAX,qword ptr [RSP]
MOV dword ptr [RSP + 0xc],ECX
MOV DL,byte ptr [RSP + 0x23]
MOV ECX,dword ptr [RSP + 0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV ECX,dword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV ECX,dword ptr [RSP + 0xc]
MOV byte ptr [RAX + RCX*0x1],DL
MOV byte ptr [RSP + 0x37],0x1
LAB_00103638:
MOV AL,byte ptr [RSP + 0x37]
AND AL,0x1
ADD RSP,0x38
RET
|
/* MemoryManager::setByte(unsigned int, unsigned char, unsigned int*) */
int1 __thiscall
MemoryManager::setByte(MemoryManager *this,uint param_1,uchar param_2,uint *param_3)
{
uint uVar1;
uint uVar2;
uint uVar3;
ulong uVar4;
int1 local_1;
uVar4 = isAddrExist(this,param_1);
if ((uVar4 & 1) == 0) {
dbgprintf("Byte write to invalid addr 0x%x!\n",(ulong)param_1);
local_1 = 0;
}
else if (*(long *)(this + 0x2000) == 0) {
uVar1 = getFirstEntryId(this,param_1);
uVar2 = getSecondEntryId(this,param_1);
uVar3 = getPageOffset(this,param_1);
*(uchar *)(*(long *)(*(long *)(this + (ulong)uVar1 * 8) + (ulong)uVar2 * 8) + (ulong)uVar3) =
param_2;
local_1 = 1;
}
else {
Cache::setByte(*(Cache **)(this + 0x2000),param_1,param_2,param_3);
local_1 = 1;
}
return local_1;
}
| |
25,997 | MemoryManager::setByte(unsigned int, unsigned char, unsigned int*) | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp | bool MemoryManager::setByte(uint32_t addr, uint8_t val, uint32_t *cycles) {
if (!this->isAddrExist(addr)) {
dbgprintf("Byte write to invalid addr 0x%x!\n", addr);
return false;
}
if (this->cache != nullptr) {
this->cache->setByte(addr, val, cycles);
return true;
}
uint32_t i = this->getFirstEntryId(addr);
uint32_t j = this->getSecondEntryId(addr);
uint32_t k = this->getPageOffset(addr);
this->memory[i][j][k] = val;
return true;
} | O1 | cpp | MemoryManager::setByte(unsigned int, unsigned char, unsigned int*):
pushq %rbx
movl %esi, %eax
shrl $0x16, %eax
movq (%rdi,%rax,8), %rax
testq %rax, %rax
je 0x2eac
movl %esi, %r8d
shrl $0x9, %r8d
andl $0x1ff8, %r8d # imm = 0x1FF8
movb $0x1, %bl
cmpq $0x0, (%rax,%r8)
jne 0x2eae
xorl %ebx, %ebx
testb %bl, %bl
je 0x2ee4
movq 0x2000(%rdi), %rdi
testq %rdi, %rdi
je 0x2ec8
movzbl %dl, %edx
callq 0x3d16
jmp 0x2ee0
movl %esi, %ecx
andl $0xfff, %ecx # imm = 0xFFF
shrl $0x9, %esi
andl $0x1ff8, %esi # imm = 0x1FF8
movq (%rax,%rsi), %rax
movb %dl, (%rax,%rcx)
movl %ebx, %eax
popq %rbx
retq
leaq 0x226c(%rip), %rdi # 0x5157
xorl %eax, %eax
callq 0x22c0
jmp 0x2ee0
| _ZN13MemoryManager7setByteEjhPj:
push rbx
mov eax, esi
shr eax, 16h
mov rax, [rdi+rax*8]
test rax, rax
jz short loc_2EAC
mov r8d, esi
shr r8d, 9
and r8d, 1FF8h
mov bl, 1
cmp qword ptr [rax+r8], 0
jnz short loc_2EAE
loc_2EAC:
xor ebx, ebx
loc_2EAE:
test bl, bl
jz short loc_2EE4
mov rdi, [rdi+2000h]; this
test rdi, rdi
jz short loc_2EC8
movzx edx, dl; unsigned __int8
call _ZN5Cache7setByteEjhPj; Cache::setByte(uint,uchar,uint *)
jmp short loc_2EE0
loc_2EC8:
mov ecx, esi
and ecx, 0FFFh
shr esi, 9
and esi, 1FF8h
mov rax, [rax+rsi]
mov [rax+rcx], dl
loc_2EE0:
mov eax, ebx
pop rbx
retn
loc_2EE4:
lea rdi, aByteWriteToInv; "Byte write to invalid addr 0x%x!\n"
xor eax, eax
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
jmp short loc_2EE0
| long long MemoryManager::setByte(
MemoryManager *this,
long long a2,
long long a3,
unsigned int *a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned int v14; // ebx
long long v15; // rax
Cache *v16; // rdi
char v18; // [rsp+0h] [rbp-8h]
v15 = *((_QWORD *)this + ((unsigned int)a2 >> 22));
if ( !v15 || (a5 = ((unsigned int)a2 >> 9) & 0x1FF8, LOBYTE(v14) = 1, !*(_QWORD *)(v15 + a5)) )
v14 = 0;
if ( (_BYTE)v14 )
{
v16 = (Cache *)*((_QWORD *)this + 1024);
if ( v16 )
Cache::setByte(v16, a2, a3, a4);
else
*(_BYTE *)(*(_QWORD *)(v15 + (((unsigned int)a2 >> 9) & 0x1FF8)) + (a2 & 0xFFF)) = a3;
}
else
{
dbgprintf(
"Byte write to invalid addr 0x%x!\n",
a2,
a3,
(long long)a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v18);
}
return v14;
}
| setByte:
PUSH RBX
MOV EAX,ESI
SHR EAX,0x16
MOV RAX,qword ptr [RDI + RAX*0x8]
TEST RAX,RAX
JZ 0x00102eac
MOV R8D,ESI
SHR R8D,0x9
AND R8D,0x1ff8
MOV BL,0x1
CMP qword ptr [RAX + R8*0x1],0x0
JNZ 0x00102eae
LAB_00102eac:
XOR EBX,EBX
LAB_00102eae:
TEST BL,BL
JZ 0x00102ee4
MOV RDI,qword ptr [RDI + 0x2000]
TEST RDI,RDI
JZ 0x00102ec8
MOVZX EDX,DL
CALL 0x00103d16
JMP 0x00102ee0
LAB_00102ec8:
MOV ECX,ESI
AND ECX,0xfff
SHR ESI,0x9
AND ESI,0x1ff8
MOV RAX,qword ptr [RAX + RSI*0x1]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_00102ee0:
MOV EAX,EBX
POP RBX
RET
LAB_00102ee4:
LEA RDI,[0x105157]
XOR EAX,EAX
CALL 0x001022c0
JMP 0x00102ee0
|
/* MemoryManager::setByte(unsigned int, unsigned char, unsigned int*) */
int4 __thiscall
MemoryManager::setByte(MemoryManager *this,uint param_1,uchar param_2,uint *param_3)
{
long lVar1;
int4 uVar2;
int8 unaff_RBX;
lVar1 = *(long *)(this + (ulong)(param_1 >> 0x16) * 8);
if ((lVar1 == 0) ||
(uVar2 = (int4)CONCAT71((int7)((ulong)unaff_RBX >> 8),1),
*(long *)(lVar1 + (ulong)(param_1 >> 9 & 0x1ff8)) == 0)) {
uVar2 = 0;
}
if ((char)uVar2 == '\0') {
dbgprintf("Byte write to invalid addr 0x%x!\n");
}
else if (*(Cache **)(this + 0x2000) == (Cache *)0x0) {
*(uchar *)(*(long *)(lVar1 + (ulong)(param_1 >> 9 & 0x1ff8)) + (ulong)(param_1 & 0xfff)) =
param_2;
}
else {
Cache::setByte(*(Cache **)(this + 0x2000),param_1,param_2,param_3);
}
return uVar2;
}
| |
25,998 | free_root | eloqsql/mysys/my_alloc.c | void free_root(MEM_ROOT *root, myf MyFlags)
{
reg1 USED_MEM *next,*old;
DBUG_ENTER("free_root");
DBUG_PRINT("enter",("root: %p flags: %lu", root, MyFlags));
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
/*
There is no point in using mark_blocks_free when using valgrind as
it will not reclaim any memory
*/
if (MyFlags & MY_MARK_BLOCKS_FREE)
{
mark_blocks_free(root);
DBUG_VOID_RETURN;
}
#endif
if (!(MyFlags & MY_KEEP_PREALLOC))
root->pre_alloc=0;
for (next=root->used; next ;)
{
old=next; next= next->next ;
if (old != root->pre_alloc)
my_free(old);
}
for (next=root->free ; next ;)
{
old=next; next= next->next;
if (old != root->pre_alloc)
my_free(old);
}
root->used=root->free=0;
if (root->pre_alloc)
{
root->free=root->pre_alloc;
root->free->left=root->pre_alloc->size-ALIGN_SIZE(sizeof(USED_MEM));
TRASH_MEM(root->pre_alloc);
root->free->next=0;
}
root->block_num= 4;
root->first_block_usage= 0;
DBUG_VOID_RETURN;
} | O0 | c | free_root:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x3b9d2
movq -0x10(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x3b9ee
movq -0x8(%rbp), %rdi
callq 0x3bb10
jmp 0x3bafd
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x3ba08
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3ba47
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x3ba45
movq -0x20(%rbp), %rdi
callq 0x2e3e0
jmp 0x3ba14
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3ba85
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x3ba83
movq -0x20(%rbp), %rdi
callq 0x2e3e0
jmp 0x3ba52
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3bae5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
subq $0x18, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bad3
jmp 0x3bad5
jmp 0x3bad7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
jmp 0x3bafd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| free_root:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_3B9D2:
mov rax, [rbp+var_10]
and rax, 2
cmp rax, 0
jz short loc_3B9EE
mov rdi, [rbp+var_8]
call mark_blocks_free
jmp loc_3BAFD
loc_3B9EE:
mov rax, [rbp+var_10]
and rax, 1
cmp rax, 0
jnz short loc_3BA08
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
loc_3BA08:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
loc_3BA14:
cmp [rbp+var_18], 0
jz short loc_3BA47
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jz short loc_3BA45
mov rdi, [rbp+var_20]
call my_free
loc_3BA45:
jmp short loc_3BA14
loc_3BA47:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
loc_3BA52:
cmp [rbp+var_18], 0
jz short loc_3BA85
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jz short loc_3BA83
mov rdi, [rbp+var_20]
call my_free
loc_3BA83:
jmp short loc_3BA52
loc_3BA85:
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_8]
cmp qword ptr [rax+10h], 0
jz short loc_3BAE5
mov rax, [rbp+var_8]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rcx, [rax+10h]
sub rcx, 18h
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+8], rcx
jmp short $+2
loc_3BAD3:
jmp short $+2
loc_3BAD5:
jmp short $+2
loc_3BAD7:
mov rax, [rbp+var_8]
mov rax, [rax]
mov qword ptr [rax], 0
loc_3BAE5:
mov rax, [rbp+var_8]
mov dword ptr [rax+28h], 4
mov rax, [rbp+var_8]
mov dword ptr [rax+2Ch], 0
jmp short $+2
loc_3BAFD:
add rsp, 20h
pop rbp
retn
| long long free_root(long long a1, char a2)
{
long long result; // rax
long long v3; // [rsp+0h] [rbp-20h]
long long v4; // [rsp+0h] [rbp-20h]
_QWORD *v5; // [rsp+8h] [rbp-18h]
_QWORD *v6; // [rsp+8h] [rbp-18h]
if ( (a2 & 2) != 0 )
return mark_blocks_free(a1);
if ( (a2 & 1) == 0 )
*(_QWORD *)(a1 + 16) = 0LL;
v5 = *(_QWORD **)(a1 + 8);
while ( v5 )
{
v3 = (long long)v5;
v5 = (_QWORD *)*v5;
if ( v3 != *(_QWORD *)(a1 + 16) )
my_free(v3);
}
v6 = *(_QWORD **)a1;
while ( v6 )
{
v4 = (long long)v6;
v6 = (_QWORD *)*v6;
if ( v4 != *(_QWORD *)(a1 + 16) )
my_free(v4);
}
*(_QWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 8) = 0LL;
if ( *(_QWORD *)(a1 + 16) )
{
*(_QWORD *)a1 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(*(_QWORD *)a1 + 8LL) = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 16LL) - 24LL;
**(_QWORD **)a1 = 0LL;
}
*(_DWORD *)(a1 + 40) = 4;
result = a1;
*(_DWORD *)(a1 + 44) = 0;
return result;
}
| free_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x0013b9d2
LAB_0013b9d2:
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x2
CMP RAX,0x0
JZ 0x0013b9ee
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013bb10
JMP 0x0013bafd
LAB_0013b9ee:
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x1
CMP RAX,0x0
JNZ 0x0013ba08
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x0
LAB_0013ba08:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
LAB_0013ba14:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0013ba47
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JZ 0x0013ba45
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0012e3e0
LAB_0013ba45:
JMP 0x0013ba14
LAB_0013ba47:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_0013ba52:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0013ba85
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JZ 0x0013ba83
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0012e3e0
LAB_0013ba83:
JMP 0x0013ba52
LAB_0013ba85:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x0013bae5
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0013bad3
LAB_0013bad3:
JMP 0x0013bad5
LAB_0013bad5:
JMP 0x0013bad7
LAB_0013bad7:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],0x0
LAB_0013bae5:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],0x4
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c],0x0
JMP 0x0013bafd
LAB_0013bafd:
ADD RSP,0x20
POP RBP
RET
|
void free_root(long *param_1,ulong param_2)
{
int8 *puVar1;
int8 *local_20;
if ((param_2 & 2) == 0) {
if ((param_2 & 1) == 0) {
param_1[2] = 0;
}
puVar1 = (int8 *)param_1[1];
while (local_20 = puVar1, local_20 != (int8 *)0x0) {
puVar1 = (int8 *)*local_20;
if (local_20 != (int8 *)param_1[2]) {
my_free(local_20);
}
}
puVar1 = (int8 *)*param_1;
while (local_20 = puVar1, local_20 != (int8 *)0x0) {
puVar1 = (int8 *)*local_20;
if (local_20 != (int8 *)param_1[2]) {
my_free(local_20);
}
}
*param_1 = 0;
param_1[1] = 0;
if (param_1[2] != 0) {
*param_1 = param_1[2];
*(long *)(*param_1 + 8) = *(long *)(param_1[2] + 0x10) + -0x18;
*(int8 *)*param_1 = 0;
}
*(int4 *)(param_1 + 5) = 4;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
else {
mark_blocks_free(param_1);
}
return;
}
| |
25,999 | ntt_conv | bluesky950520[P]quickjs/libbf.c | static int ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
int k, int k_tot, limb_t m_idx)
{
limb_t n1, n2, i;
int k1, k2;
if (k <= NTT_TRIG_K_MAX) {
k1 = k;
} else {
/* recursive split of the FFT */
k1 = bf_min(k / 2, NTT_TRIG_K_MAX);
}
k2 = k - k1;
n1 = (limb_t)1 << k1;
n2 = (limb_t)1 << k2;
if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 0, m_idx))
return -1;
if (ntt_fft_partial(s, buf2, k1, k2, n1, n2, 0, m_idx))
return -1;
if (k2 == 0) {
ntt_vec_mul(s, buf1, buf2, k, k_tot, m_idx);
} else {
for(i = 0; i < n1; i++) {
ntt_conv(s, buf1 + i * n2, buf2 + i * n2, k2, k_tot, m_idx);
}
}
if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 1, m_idx))
return -1;
return 0;
} | O0 | c | ntt_conv:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movl %r8d, 0x40(%rsp)
movq %r9, 0x38(%rsp)
cmpl $0x13, 0x44(%rsp)
jg 0xfb4d2
movl 0x44(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0xfb4ef
movl 0x44(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movslq %eax, %rdi
movl $0x13, %esi
callq 0xe7680
movl %eax, 0x1c(%rsp)
movl 0x44(%rsp), %eax
subl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x30(%rsp)
movl 0x18(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x38(%rsp), %rax
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xfbf40
cmpl $0x0, %eax
je 0xfb568
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0xfb693
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x38(%rsp), %rax
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xfbf40
cmpl $0x0, %eax
je 0xfb5af
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0xfb693
cmpl $0x0, 0x18(%rsp)
jne 0xfb5dd
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movl 0x44(%rsp), %ecx
movl 0x40(%rsp), %r8d
movq 0x38(%rsp), %rax
movl %eax, %r9d
callq 0xfc360
jmp 0xfb64a
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0xfb648
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x20(%rsp), %rax
imulq 0x28(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x48(%rsp), %rdx
movq 0x20(%rsp), %rax
imulq 0x28(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movl 0x18(%rsp), %ecx
movl 0x40(%rsp), %r8d
movq 0x38(%rsp), %r9
callq 0xfb4a0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xfb5e6
jmp 0xfb64a
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x38(%rsp), %rax
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xfbf40
cmpl $0x0, %eax
je 0xfb68b
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0xfb693
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
| ntt_conv:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_18], rsi
mov [rsp+68h+var_20], rdx
mov [rsp+68h+var_24], ecx
mov [rsp+68h+var_28], r8d
mov [rsp+68h+var_30], r9
cmp [rsp+68h+var_24], 13h
jg short loc_FB4D2
mov eax, [rsp+68h+var_24]
mov [rsp+68h+var_4C], eax
jmp short loc_FB4EF
loc_FB4D2:
mov eax, [rsp+68h+var_24]
mov ecx, 2
cdq
idiv ecx
movsxd rdi, eax
mov esi, 13h
call bf_min
mov [rsp+68h+var_4C], eax
loc_FB4EF:
mov eax, [rsp+68h+var_24]
sub eax, [rsp+68h+var_4C]
mov [rsp+68h+var_50], eax
mov eax, [rsp+68h+var_4C]
mov ecx, eax
mov eax, 1
shl rax, cl
mov [rsp+68h+var_38], rax
mov eax, [rsp+68h+var_50]
mov ecx, eax
mov eax, 1
shl rax, cl
mov [rsp+68h+var_40], rax
mov rdi, [rsp+68h+var_10]
mov rsi, [rsp+68h+var_18]
mov edx, [rsp+68h+var_4C]
mov ecx, [rsp+68h+var_50]
mov r8, [rsp+68h+var_38]
mov r9, [rsp+68h+var_40]
mov rax, [rsp+68h+var_30]
xor r10d, r10d
mov [rsp+68h+var_68], 0
mov [rsp+68h+var_60], rax
call ntt_fft_partial
cmp eax, 0
jz short loc_FB568
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp loc_FB693
loc_FB568:
mov rdi, [rsp+68h+var_10]
mov rsi, [rsp+68h+var_20]
mov edx, [rsp+68h+var_4C]
mov ecx, [rsp+68h+var_50]
mov r8, [rsp+68h+var_38]
mov r9, [rsp+68h+var_40]
mov rax, [rsp+68h+var_30]
xor r10d, r10d
mov [rsp+68h+var_68], 0
mov [rsp+68h+var_60], rax
call ntt_fft_partial
cmp eax, 0
jz short loc_FB5AF
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp loc_FB693
loc_FB5AF:
cmp [rsp+68h+var_50], 0
jnz short loc_FB5DD
mov rdi, [rsp+68h+var_10]
mov rsi, [rsp+68h+var_18]
mov rdx, [rsp+68h+var_20]
mov ecx, [rsp+68h+var_24]
mov r8d, [rsp+68h+var_28]
mov rax, [rsp+68h+var_30]
mov r9d, eax
call ntt_vec_mul
jmp short loc_FB64A
loc_FB5DD:
mov [rsp+68h+var_48], 0
loc_FB5E6:
mov rax, [rsp+68h+var_48]
cmp rax, [rsp+68h+var_38]
jnb short loc_FB648
mov rdi, [rsp+68h+var_10]
mov rsi, [rsp+68h+var_18]
mov rax, [rsp+68h+var_48]
imul rax, [rsp+68h+var_40]
shl rax, 3
add rsi, rax
mov rdx, [rsp+68h+var_20]
mov rax, [rsp+68h+var_48]
imul rax, [rsp+68h+var_40]
shl rax, 3
add rdx, rax
mov ecx, [rsp+68h+var_50]
mov r8d, [rsp+68h+var_28]
mov r9, [rsp+68h+var_30]
call ntt_conv
mov rax, [rsp+68h+var_48]
add rax, 1
mov [rsp+68h+var_48], rax
jmp short loc_FB5E6
loc_FB648:
jmp short $+2
loc_FB64A:
mov rdi, [rsp+68h+var_10]
mov rsi, [rsp+68h+var_18]
mov edx, [rsp+68h+var_4C]
mov ecx, [rsp+68h+var_50]
mov r8, [rsp+68h+var_38]
mov r9, [rsp+68h+var_40]
mov rax, [rsp+68h+var_30]
mov [rsp+68h+var_68], 1
mov [rsp+68h+var_60], rax
call ntt_fft_partial
cmp eax, 0
jz short loc_FB68B
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp short loc_FB693
loc_FB68B:
mov [rsp+68h+var_4], 0
loc_FB693:
mov eax, [rsp+68h+var_4]
add rsp, 68h
retn
| long long ntt_conv(long long a1, long long a2, long long a3, int a4, unsigned int a5, long long a6)
{
unsigned int v7; // [rsp+18h] [rbp-50h]
int v8; // [rsp+1Ch] [rbp-4Ch]
unsigned long long i; // [rsp+20h] [rbp-48h]
long long v10; // [rsp+28h] [rbp-40h]
unsigned long long v11; // [rsp+30h] [rbp-38h]
if ( a4 > 19 )
v8 = bf_min(a4 / 2, 19LL);
else
v8 = a4;
v7 = a4 - v8;
v11 = 1LL << v8;
v10 = 1LL << ((unsigned __int8)a4 - (unsigned __int8)v8);
if ( (unsigned int)ntt_fft_partial(a1, a2, v8, a4 - v8, 1LL << v8, v10, 0, a6) )
{
return (unsigned int)-1;
}
else if ( (unsigned int)ntt_fft_partial(a1, a3, v8, v7, v11, v10, 0, a6) )
{
return (unsigned int)-1;
}
else
{
if ( v7 )
{
for ( i = 0LL; i < v11; ++i )
ntt_conv(a1, 8 * v10 * i + a2, 8 * v10 * i + a3, v7, a5, a6);
}
else
{
ntt_vec_mul(a1, a2, a3, (unsigned int)a4, a5, (unsigned int)a6);
}
if ( (unsigned int)ntt_fft_partial(a1, a2, v8, v7, v11, v10, 1, a6) )
return (unsigned int)-1;
else
return 0;
}
}
| ntt_conv:
SUB RSP,0x68
MOV qword ptr [RSP + 0x58],RDI
MOV qword ptr [RSP + 0x50],RSI
MOV qword ptr [RSP + 0x48],RDX
MOV dword ptr [RSP + 0x44],ECX
MOV dword ptr [RSP + 0x40],R8D
MOV qword ptr [RSP + 0x38],R9
CMP dword ptr [RSP + 0x44],0x13
JG 0x001fb4d2
MOV EAX,dword ptr [RSP + 0x44]
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x001fb4ef
LAB_001fb4d2:
MOV EAX,dword ptr [RSP + 0x44]
MOV ECX,0x2
CDQ
IDIV ECX
MOVSXD RDI,EAX
MOV ESI,0x13
CALL 0x001e7680
MOV dword ptr [RSP + 0x1c],EAX
LAB_001fb4ef:
MOV EAX,dword ptr [RSP + 0x44]
SUB EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x18],EAX
MOV EAX,dword ptr [RSP + 0x1c]
MOV ECX,EAX
MOV EAX,0x1
SHL RAX,CL
MOV qword ptr [RSP + 0x30],RAX
MOV EAX,dword ptr [RSP + 0x18]
MOV ECX,EAX
MOV EAX,0x1
SHL RAX,CL
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x50]
MOV EDX,dword ptr [RSP + 0x1c]
MOV ECX,dword ptr [RSP + 0x18]
MOV R8,qword ptr [RSP + 0x30]
MOV R9,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x38]
XOR R10D,R10D
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001fbf40
CMP EAX,0x0
JZ 0x001fb568
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x001fb693
LAB_001fb568:
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x48]
MOV EDX,dword ptr [RSP + 0x1c]
MOV ECX,dword ptr [RSP + 0x18]
MOV R8,qword ptr [RSP + 0x30]
MOV R9,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x38]
XOR R10D,R10D
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001fbf40
CMP EAX,0x0
JZ 0x001fb5af
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x001fb693
LAB_001fb5af:
CMP dword ptr [RSP + 0x18],0x0
JNZ 0x001fb5dd
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x48]
MOV ECX,dword ptr [RSP + 0x44]
MOV R8D,dword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x38]
MOV R9D,EAX
CALL 0x001fc360
JMP 0x001fb64a
LAB_001fb5dd:
MOV qword ptr [RSP + 0x20],0x0
LAB_001fb5e6:
MOV RAX,qword ptr [RSP + 0x20]
CMP RAX,qword ptr [RSP + 0x30]
JNC 0x001fb648
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x20]
IMUL RAX,qword ptr [RSP + 0x28]
SHL RAX,0x3
ADD RSI,RAX
MOV RDX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RSP + 0x20]
IMUL RAX,qword ptr [RSP + 0x28]
SHL RAX,0x3
ADD RDX,RAX
MOV ECX,dword ptr [RSP + 0x18]
MOV R8D,dword ptr [RSP + 0x40]
MOV R9,qword ptr [RSP + 0x38]
CALL 0x001fb4a0
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x1
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001fb5e6
LAB_001fb648:
JMP 0x001fb64a
LAB_001fb64a:
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x50]
MOV EDX,dword ptr [RSP + 0x1c]
MOV ECX,dword ptr [RSP + 0x18]
MOV R8,qword ptr [RSP + 0x30]
MOV R9,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x38]
MOV dword ptr [RSP],0x1
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001fbf40
CMP EAX,0x0
JZ 0x001fb68b
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x001fb693
LAB_001fb68b:
MOV dword ptr [RSP + 0x64],0x0
LAB_001fb693:
MOV EAX,dword ptr [RSP + 0x64]
ADD RSP,0x68
RET
|
int4
ntt_conv(int8 param_1,long param_2,long param_3,int param_4,int4 param_5,ulong param_6)
{
int iVar1;
int iVar2;
ulong uVar3;
long lVar4;
int4 local_4c;
int8 local_48;
int4 local_4;
local_4c = param_4;
if (0x13 < param_4) {
local_4c = bf_min((long)(param_4 / 2),0x13,(long)param_4 % 2 & 0xffffffff);
}
iVar1 = param_4 - local_4c;
uVar3 = 1L << ((byte)local_4c & 0x3f);
lVar4 = 1L << ((byte)iVar1 & 0x3f);
iVar2 = ntt_fft_partial(param_1,param_2,local_4c,iVar1,uVar3,lVar4,0,param_6);
if (iVar2 == 0) {
iVar2 = ntt_fft_partial(param_1,param_3,local_4c,iVar1,uVar3,lVar4,0,param_6);
if (iVar2 == 0) {
if (iVar1 == 0) {
ntt_vec_mul(param_1,param_2,param_3,param_4,param_5,param_6 & 0xffffffff);
}
else {
for (local_48 = 0; local_48 < uVar3; local_48 = local_48 + 1) {
ntt_conv(param_1,param_2 + local_48 * lVar4 * 8,param_3 + local_48 * lVar4 * 8,iVar1,
param_5,param_6);
}
}
iVar1 = ntt_fft_partial(param_1,param_2,local_4c,iVar1,uVar3,lVar4,1,param_6);
if (iVar1 == 0) {
local_4 = 0;
}
else {
local_4 = 0xffffffff;
}
}
else {
local_4 = 0xffffffff;
}
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.