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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
66,400 |
start_dbl_n
|
corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/pairing.c
|
static void start_dbl_n(vec384fp12 ret, POINTonE2 T[],
const POINTonE1_affine Px2[], size_t n)
{
size_t i;
vec384fp6 line; /* it's not actual fp6, but 3 packed fp2, "xy00z0" */
/* first step is ret = 1^2*line, which is replaced with ret = line */
line_dbl(line, T+0, T+0); line_by_Px2(line, Px2+0);
vec_zero(ret, sizeof(vec384fp12));
vec_copy(ret[0][0], line[0], 2*sizeof(vec384fp2));
vec_copy(ret[1][1], line[2], sizeof(vec384fp2));
for (i = 1; i < n; i++) {
line_dbl(line, T+i, T+i); line_by_Px2(line, Px2+i);
mul_by_xy00z0_fp12(ret, ret, line);
}
}
|
O1
|
c
|
start_dbl_n:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x150(%rbp), %r13
movq %r13, %rdi
movq %rsi, %rdx
callq 0x28668
movq %r13, %rdi
movq %r14, %rsi
callq 0x2895f
xorl %eax, %eax
movq $0x0, (%r12,%rax,8)
incq %rax
cmpq $0x48, %rax
jne 0x2092b
leaq -0x150(%rbp), %rsi
movl $0xc0, %edx
movq %r12, %rdi
callq 0x5060
leaq 0x180(%r12), %rdi
leaq -0x90(%rbp), %rsi
movl $0xc, %ecx
rep movsq (%rsi), %es:(%rdi)
cmpq $0x2, %rbx
jb 0x209b9
decq %rbx
addq $0x60, %r14
addq $0x120, %r15 # imm = 0x120
leaq -0x150(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x28668
movq %r13, %rdi
movq %r14, %rsi
callq 0x2895f
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1fa62
addq $0x60, %r14
addq $0x120, %r15 # imm = 0x120
decq %rbx
jne 0x20982
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
start_dbl_n:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
lea r13, [rbp+var_150]
mov rdi, r13
mov rdx, rsi
call line_dbl
mov rdi, r13
mov rsi, r14
call line_by_Px2
xor eax, eax
loc_2092B:
mov qword ptr [r12+rax*8], 0
inc rax
cmp rax, 48h ; 'H'
jnz short loc_2092B
lea rsi, [rbp+var_150]
mov edx, 0C0h
mov rdi, r12
call _memcpy
lea rdi, [r12+180h]
lea rsi, [rbp+var_90]
mov ecx, 0Ch
rep movsq
cmp rbx, 2
jb short loc_209B9
dec rbx
add r14, 60h ; '`'
add r15, 120h
lea r13, [rbp+var_150]
loc_20982:
mov rdi, r13
mov rsi, r15
mov rdx, r15
call line_dbl
mov rdi, r13
mov rsi, r14
call line_by_Px2
mov rdi, r12
mov rsi, r12
mov rdx, r13
call mul_by_xy00z0_fp12
add r14, 60h ; '`'
add r15, 120h
dec rbx
jnz short loc_20982
loc_209B9:
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long start_dbl_n(long long a1, long long a2, long long a3, unsigned long long a4)
{
long long i; // rax
long long result; // rax
unsigned long long v8; // rbx
long long v9; // r14
long long v10; // r15
char v11[192]; // [rsp+0h] [rbp-150h] BYREF
_BYTE v12[96]; // [rsp+C0h] [rbp-90h] BYREF
line_dbl(v11, a2, a2);
line_by_Px2(v11, a3);
for ( i = 0LL; i != 72; ++i )
*(_QWORD *)(a1 + 8 * i) = 0LL;
result = memcpy(a1, v11, 192LL);
qmemcpy((void *)(a1 + 384), v12, 0x60uLL);
if ( a4 >= 2 )
{
v8 = a4 - 1;
v9 = a3 + 96;
v10 = a2 + 288;
do
{
line_dbl(v11, v10, v10);
line_by_Px2(v11, v9);
result = mul_by_xy00z0_fp12(a1, a1, v11);
v9 += 96LL;
v10 += 288LL;
--v8;
}
while ( v8 );
}
return result;
}
|
start_dbl_n:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
LEA R13,[RBP + -0x150]
MOV RDI,R13
MOV RDX,RSI
CALL 0x00128668
MOV RDI,R13
MOV RSI,R14
CALL 0x0012895f
XOR EAX,EAX
LAB_0012092b:
MOV qword ptr [R12 + RAX*0x8],0x0
INC RAX
CMP RAX,0x48
JNZ 0x0012092b
LEA RSI,[RBP + -0x150]
MOV EDX,0xc0
MOV RDI,R12
CALL 0x00105060
LEA RDI,[R12 + 0x180]
LEA RSI,[RBP + -0x90]
MOV ECX,0xc
MOVSQ.REP RDI,RSI
CMP RBX,0x2
JC 0x001209b9
DEC RBX
ADD R14,0x60
ADD R15,0x120
LEA R13,[RBP + -0x150]
LAB_00120982:
MOV RDI,R13
MOV RSI,R15
MOV RDX,R15
CALL 0x00128668
MOV RDI,R13
MOV RSI,R14
CALL 0x0012895f
MOV RDI,R12
MOV RSI,R12
MOV RDX,R13
CALL 0x0011fa62
ADD R14,0x60
ADD R15,0x120
DEC RBX
JNZ 0x00120982
LAB_001209b9:
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void start_dbl_n(void *param_1,long param_2,long param_3,ulong param_4)
{
long lVar1;
int8 *puVar2;
int8 *puVar3;
byte bVar4;
int1 local_158 [192];
int8 local_98 [13];
bVar4 = 0;
line_dbl(local_158,param_2,param_2);
line_by_Px2(local_158,param_3);
lVar1 = 0;
do {
*(int8 *)((long)param_1 + lVar1 * 8) = 0;
lVar1 = lVar1 + 1;
} while (lVar1 != 0x48);
memcpy(param_1,local_158,0xc0);
puVar2 = local_98;
puVar3 = (int8 *)((long)param_1 + 0x180);
for (lVar1 = 0xc; lVar1 != 0; lVar1 = lVar1 + -1) {
*puVar3 = *puVar2;
puVar2 = puVar2 + (ulong)bVar4 * -2 + 1;
puVar3 = puVar3 + (ulong)bVar4 * -2 + 1;
}
if (1 < param_4) {
lVar1 = param_4 - 1;
param_3 = param_3 + 0x60;
param_2 = param_2 + 0x120;
do {
line_dbl(local_158,param_2,param_2);
line_by_Px2(local_158,param_3);
mul_by_xy00z0_fp12(param_1,param_1,local_158);
param_3 = param_3 + 0x60;
param_2 = param_2 + 0x120;
lVar1 = lVar1 + -1;
} while (lVar1 != 0);
}
return;
}
|
|
66,401 |
GGUFMeta::GKV<float>::set(gguf_context const*, int, float&, llama_model_kv_override const*)
|
monkey531[P]llama/src/llama-model-loader.cpp
|
static bool set(const gguf_context * ctx, const int k, T & target, const struct llama_model_kv_override * ovrd = nullptr) {
if (try_override<T>(target, ovrd)) {
return true;
}
if (k < 0) { return false; }
target = get_kv(ctx, k);
return true;
}
|
O1
|
cpp
|
GGUFMeta::GKV<float>::set(gguf_context const*, int, float&, llama_model_kv_override const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %edi, %edi
movq %rcx, %rsi
callq 0x6b9f0
testb %al, %al
je 0xb7608
movzwl 0x88(%r15), %eax
jmp 0xb7616
testl %ebp, %ebp
js 0xb7626
movq %r14, %rdi
movl %ebp, %esi
callq 0x69ea0
movw %ax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xb761b
|
_ZN8GGUFMeta3GKVItE3setEPK12gguf_contextiRtPK23llama_model_kv_override:
push rbp
push r15
push r14
push rbx
push rax
mov r15, rcx
mov rbx, rdx
mov ebp, esi
mov r14, rdi
xor edi, edi
mov rsi, rcx
call __ZN8GGUFMeta3GKVItE17validate_overrideE28llama_model_kv_override_typePK23llama_model_kv_override; GGUFMeta::GKV<ushort>::validate_override(llama_model_kv_override_type,llama_model_kv_override const*)
test al, al
jz short loc_B7608
movzx eax, word ptr [r15+88h]
jmp short loc_B7616
loc_B7608:
test ebp, ebp
js short loc_B7626
mov rdi, r14
mov esi, ebp
call __ZN8GGUFMeta3GKVItE6get_kvEPK12gguf_contexti; GGUFMeta::GKV<ushort>::get_kv(gguf_context const*,int)
loc_B7616:
mov [rbx], ax
mov al, 1
loc_B761B:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_B7626:
xor eax, eax
jmp short loc_B761B
|
char GGUFMeta::GKV<unsigned short>::set(long long a1, int a2, _WORD *a3, long long a4)
{
__int16 kv; // ax
if ( (unsigned __int8)GGUFMeta::GKV<unsigned short>::validate_override(0LL, a4) )
{
kv = *(_WORD *)(a4 + 136);
}
else
{
if ( a2 < 0 )
return 0;
kv = GGUFMeta::GKV<unsigned short>::get_kv(a1, (unsigned int)a2);
}
*a3 = kv;
return 1;
}
|
set:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R15,RCX
MOV RBX,RDX
MOV EBP,ESI
MOV R14,RDI
XOR EDI,EDI
MOV RSI,RCX
CALL 0x0016b9f0
TEST AL,AL
JZ 0x001b7608
MOVZX EAX,word ptr [R15 + 0x88]
JMP 0x001b7616
LAB_001b7608:
TEST EBP,EBP
JS 0x001b7626
MOV RDI,R14
MOV ESI,EBP
CALL 0x00169ea0
LAB_001b7616:
MOV word ptr [RBX],AX
MOV AL,0x1
LAB_001b761b:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001b7626:
XOR EAX,EAX
JMP 0x001b761b
|
/* GGUFMeta::GKV<unsigned short>::set(gguf_context const*, int, unsigned short&,
llama_model_kv_override const*) */
int8
GGUFMeta::GKV<unsigned_short>::set
(gguf_context *param_1,int param_2,ushort *param_3,llama_model_kv_override *param_4)
{
char cVar1;
ushort uVar2;
cVar1 = validate_override(0,param_4);
if (cVar1 == '\0') {
if (param_2 < 0) {
return 0;
}
uVar2 = get_kv(param_1,param_2);
}
else {
uVar2 = *(ushort *)(param_4 + 0x88);
}
*param_3 = uVar2;
return 1;
}
|
|
66,402 |
GGUFMeta::GKV<float>::set(gguf_context const*, int, float&, llama_model_kv_override const*)
|
monkey531[P]llama/src/llama-model-loader.cpp
|
static bool set(const gguf_context * ctx, const int k, T & target, const struct llama_model_kv_override * ovrd = nullptr) {
if (try_override<T>(target, ovrd)) {
return true;
}
if (k < 0) { return false; }
target = get_kv(ctx, k);
return true;
}
|
O3
|
cpp
|
GGUFMeta::GKV<float>::set(gguf_context const*, int, float&, llama_model_kv_override const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x67ff0
movb $0x1, %bl
testb %al, %al
jne 0xb4067
testl %ebp, %ebp
js 0xb4065
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x6b470
movq %r14, %rdi
movq %r12, %rsi
callq 0x68ef0
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xb4067
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x681a0
jmp 0xb4067
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_ZN8GGUFMeta3GKVINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE3setEPK12gguf_contextiRS6_PK23llama_model_kv_override:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r14, rdx
mov ebp, esi
mov r15, rdi
mov rdi, rdx
mov rsi, rcx
call __ZN8GGUFMeta3GKVINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE12try_overrideIS6_EENSt9enable_ifIXsr3std7is_sameIT_S6_EE5valueEbE4typeERS6_PK23llama_model_kv_override
mov bl, 1
test al, al
jnz short loc_B4067
test ebp, ebp
js short loc_B4065
mov r12, rsp
mov rdi, r12
mov rsi, r15
mov edx, ebp
call __ZN8GGUFMeta3GKVINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE6get_kvEPK12gguf_contexti; GGUFMeta::GKV<std::string>::get_kv(gguf_context const*,int)
mov rdi, r14
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r12]; void *
lea rax, [rsp+48h+var_38]
cmp rdi, rax
jz short loc_B4067
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B4067
loc_B4065:
xor ebx, ebx
loc_B4067:
mov eax, ebx
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long GGUFMeta::GKV<std::string>::set(long long a1, int a2, long long a3, long long a4)
{
unsigned int v4; // ebx
void *v7[2]; // [rsp+0h] [rbp-48h] BYREF
long long v8; // [rsp+10h] [rbp-38h] BYREF
LOBYTE(v4) = 1;
if ( !(unsigned __int8)GGUFMeta::GKV<std::string>::try_override<std::string>(a3, a4) )
{
if ( a2 < 0 )
{
return 0;
}
else
{
GGUFMeta::GKV<std::string>::get_kv(v7, a1, (unsigned int)a2);
std::string::operator=(a3, v7);
if ( v7[0] != &v8 )
operator delete(v7[0], v8 + 1);
}
}
return v4;
}
|
set:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R14,RDX
MOV EBP,ESI
MOV R15,RDI
MOV RDI,RDX
MOV RSI,RCX
CALL 0x00167ff0
MOV BL,0x1
TEST AL,AL
JNZ 0x001b4067
TEST EBP,EBP
JS 0x001b4065
MOV R12,RSP
MOV RDI,R12
MOV RSI,R15
MOV EDX,EBP
CALL 0x0016b470
MOV RDI,R14
MOV RSI,R12
CALL 0x00168ef0
MOV RDI,qword ptr [R12]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x001b4067
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001681a0
JMP 0x001b4067
LAB_001b4065:
XOR EBX,EBX
LAB_001b4067:
MOV EAX,EBX
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* GGUFMeta::GKV<std::__cxx11::string >::set(gguf_context const*, int, std::__cxx11::string&,
llama_model_kv_override const*) */
ulong GGUFMeta::GKV<std::__cxx11::string>::set
(gguf_context *param_1,int param_2,string *param_3,llama_model_kv_override *param_4)
{
char cVar1;
int8 unaff_RBX;
ulong uVar2;
long *local_48 [2];
long local_38 [2];
cVar1 = try_override<std::__cxx11::string>(param_3,param_4);
uVar2 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (cVar1 == '\0') {
if (param_2 < 0) {
uVar2 = 0;
}
else {
get_kv((GKV<std::__cxx11::string> *)local_48,param_1,param_2);
std::__cxx11::string::operator=(param_3,(string *)local_48);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
}
}
return uVar2 & 0xffffffff;
}
|
|
66,403 |
antennaCB(LefDefParser::lefrCallbackType_e, double, void*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lefdiff/diffLefRW.cpp
|
int antennaCB(lefrCallbackType_e c, double value, lefiUserData ud) {
checkType(c);
if (ud != userData) dataError();
switch (c) {
case lefrAntennaInputCbkType:
fprintf(fout, "ANTINPUTGATEAREA %g\n", chkNum(value));
break;
case lefrAntennaInoutCbkType:
fprintf(fout, "ANTINOUTDIFFAREA %g\n", chkNum(value));
break;
case lefrAntennaOutputCbkType:
fprintf(fout, "ANTOUTPUTDIFFAREA %g\n", chkNum(value));
break;
case lefrInputAntennaCbkType:
fprintf(fout, "INPUTPINANTENNASIZE %g\n", chkNum(value));
break;
case lefrOutputAntennaCbkType:
fprintf(fout, "OUTPUTPINANTENNASIZE %g\n", chkNum(value));
break;
case lefrInoutAntennaCbkType:
fprintf(fout, "INOUTPINANTENNASIZE %g\n", chkNum(value));
break;
default:
break;
}
return 0;
}
|
O3
|
cpp
|
antennaCB(LefDefParser::lefrCallbackType_e, double, void*):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %ebx
cmpl $0x39, %edi
movapd %xmm0, (%rsp)
jb 0x476f
movq 0x72c9c(%rip), %rcx # 0x773f0
leaq 0x46a9c(%rip), %rdi # 0x4b1f7
movl $0x27, %esi
movl $0x1, %edx
callq 0x23b0
movapd (%rsp), %xmm0
cmpq %r14, 0x72c8a(%rip) # 0x77400
je 0x479a
movq 0x72c71(%rip), %rcx # 0x773f0
leaq 0x46a46(%rip), %rdi # 0x4b1cc
movl $0x2a, %esi
movl $0x1, %edx
callq 0x23b0
movapd (%rsp), %xmm0
addl $-0x25, %ebx
cmpl $0x5, %ebx
ja 0x49f5
leaq 0x46983(%rip), %rax # 0x4b130
movslq (%rax,%rbx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x72c33(%rip), %rdi # 0x773f0
movapd 0x4684b(%rip), %xmm1 # 0x4b010
andpd %xmm0, %xmm1
ucomisd 0x468bf(%rip), %xmm1 # 0x4b090
jbe 0x480a
cvttsd2si %xmm0, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movabsq $0x1999999999999999, %rax # imm = 0x1999999999999999
addq %rcx, %rax
movabsq $0x3333333333333332, %rcx # imm = 0x3333333333333332
cmpq %rcx, %rax
ja 0x480a
addsd 0x4688e(%rip), %xmm0 # 0x4b098
leaq 0x46e05(%rip), %rsi # 0x4b616
jmp 0x49ee
movq 0x72bd3(%rip), %rdi # 0x773f0
movapd 0x467eb(%rip), %xmm1 # 0x4b010
andpd %xmm0, %xmm1
ucomisd 0x4685f(%rip), %xmm1 # 0x4b090
jbe 0x486a
cvttsd2si %xmm0, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movabsq $0x1999999999999999, %rax # imm = 0x1999999999999999
addq %rcx, %rax
movabsq $0x3333333333333332, %rcx # imm = 0x3333333333333332
cmpq %rcx, %rax
ja 0x486a
addsd 0x4682e(%rip), %xmm0 # 0x4b098
leaq 0x46d7a(%rip), %rsi # 0x4b5eb
jmp 0x49ee
movq 0x72b73(%rip), %rdi # 0x773f0
movapd 0x4678b(%rip), %xmm1 # 0x4b010
andpd %xmm0, %xmm1
ucomisd 0x467ff(%rip), %xmm1 # 0x4b090
jbe 0x48ca
cvttsd2si %xmm0, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movabsq $0x1999999999999999, %rax # imm = 0x1999999999999999
addq %rcx, %rax
movabsq $0x3333333333333332, %rcx # imm = 0x3333333333333332
cmpq %rcx, %rax
ja 0x48ca
addsd 0x467ce(%rip), %xmm0 # 0x4b098
leaq 0x46d76(%rip), %rsi # 0x4b647
jmp 0x49ee
movq 0x72b13(%rip), %rdi # 0x773f0
movapd 0x4672b(%rip), %xmm1 # 0x4b010
andpd %xmm0, %xmm1
ucomisd 0x4679f(%rip), %xmm1 # 0x4b090
jbe 0x492a
cvttsd2si %xmm0, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movabsq $0x1999999999999999, %rax # imm = 0x1999999999999999
addq %rcx, %rax
movabsq $0x3333333333333332, %rcx # imm = 0x3333333333333332
cmpq %rcx, %rax
ja 0x492a
addsd 0x4676e(%rip), %xmm0 # 0x4b098
leaq 0x46ca5(%rip), %rsi # 0x4b5d6
jmp 0x49ee
movq 0x72ab3(%rip), %rdi # 0x773f0
movapd 0x466cb(%rip), %xmm1 # 0x4b010
andpd %xmm0, %xmm1
ucomisd 0x4673f(%rip), %xmm1 # 0x4b090
jbe 0x498a
cvttsd2si %xmm0, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movabsq $0x1999999999999999, %rax # imm = 0x1999999999999999
addq %rcx, %rax
movabsq $0x3333333333333332, %rcx # imm = 0x3333333333333332
cmpq %rcx, %rax
ja 0x498a
addsd 0x4670e(%rip), %xmm0 # 0x4b098
leaq 0x46c9d(%rip), %rsi # 0x4b62e
jmp 0x49ee
movq 0x72a56(%rip), %rdi # 0x773f0
movapd 0x4666e(%rip), %xmm1 # 0x4b010
andpd %xmm0, %xmm1
ucomisd 0x466e2(%rip), %xmm1 # 0x4b090
jbe 0x49e7
cvttsd2si %xmm0, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movabsq $0x1999999999999999, %rax # imm = 0x1999999999999999
addq %rcx, %rax
movabsq $0x3333333333333332, %rcx # imm = 0x3333333333333332
cmpq %rcx, %rax
ja 0x49e7
addsd 0x466b1(%rip), %xmm0 # 0x4b098
leaq 0x46c12(%rip), %rsi # 0x4b600
movb $0x1, %al
callq 0x22c0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
_Z9antennaCBN12LefDefParser18lefrCallbackType_eEdPv:
push r14
push rbx
sub rsp, 18h
mov r14, rsi
mov ebx, edi
cmp edi, 39h ; '9'
movapd [rsp+28h+var_28], xmm0
jb short loc_476F
mov rcx, cs:fout
lea rdi, aErrorCallbackT; "ERROR: callback type is out of bounds!"...
mov esi, 27h ; '''
mov edx, 1
call _fwrite
movapd xmm0, [rsp+28h+var_28]
loc_476F:
cmp cs:userData, r14
jz short loc_479A
mov rcx, cs:fout
lea rdi, aErrorReturnedU; "ERROR: returned user data is not correc"...
mov esi, 2Ah ; '*'
mov edx, 1
call _fwrite
movapd xmm0, [rsp+28h+var_28]
loc_479A:
add ebx, 0FFFFFFDBh; switch 6 cases
cmp ebx, 5
ja def_47B4; jumptable 00000000000047B4 default case
lea rax, jpt_47B4
movsxd rcx, ds:(jpt_47B4 - 4B130h)[rax+rbx*4]
add rcx, rax
jmp rcx; switch jump
loc_47B6:
mov rdi, cs:fout; jumptable 00000000000047B4 case 37
movapd xmm1, cs:xmmword_4B010
andpd xmm1, xmm0
ucomisd xmm1, cs:qword_4B090
jbe short loc_480A
cvttsd2si rax, xmm0
mov rcx, 0CCCCCCCCCCCCCCCDh
imul rcx, rax
mov rax, 1999999999999999h
add rax, rcx
mov rcx, 3333333333333332h
cmp rax, rcx
ja short loc_480A
addsd xmm0, cs:qword_4B098
loc_480A:
lea rsi, aInputpinantenn; "INPUTPINANTENNASIZE %g\n"
jmp loc_49EE
loc_4816:
mov rdi, cs:fout; jumptable 00000000000047B4 case 41
movapd xmm1, cs:xmmword_4B010
andpd xmm1, xmm0
ucomisd xmm1, cs:qword_4B090
jbe short loc_486A
cvttsd2si rax, xmm0
mov rcx, 0CCCCCCCCCCCCCCCDh
imul rcx, rax
mov rax, 1999999999999999h
add rax, rcx
mov rcx, 3333333333333332h
cmp rax, rcx
ja short loc_486A
addsd xmm0, cs:qword_4B098
loc_486A:
lea rsi, aAntinoutdiffar; "ANTINOUTDIFFAREA %g\n"
jmp loc_49EE
loc_4876:
mov rdi, cs:fout; jumptable 00000000000047B4 case 39
movapd xmm1, cs:xmmword_4B010
andpd xmm1, xmm0
ucomisd xmm1, cs:qword_4B090
jbe short loc_48CA
cvttsd2si rax, xmm0
mov rcx, 0CCCCCCCCCCCCCCCDh
imul rcx, rax
mov rax, 1999999999999999h
add rax, rcx
mov rcx, 3333333333333332h
cmp rax, rcx
ja short loc_48CA
addsd xmm0, cs:qword_4B098
loc_48CA:
lea rsi, aInoutpinantenn; "INOUTPINANTENNASIZE %g\n"
jmp loc_49EE
loc_48D6:
mov rdi, cs:fout; jumptable 00000000000047B4 case 40
movapd xmm1, cs:xmmword_4B010
andpd xmm1, xmm0
ucomisd xmm1, cs:qword_4B090
jbe short loc_492A
cvttsd2si rax, xmm0
mov rcx, 0CCCCCCCCCCCCCCCDh
imul rcx, rax
mov rax, 1999999999999999h
add rax, rcx
mov rcx, 3333333333333332h
cmp rax, rcx
ja short loc_492A
addsd xmm0, cs:qword_4B098
loc_492A:
lea rsi, aAntinputgatear; "ANTINPUTGATEAREA %g\n"
jmp loc_49EE
loc_4936:
mov rdi, cs:fout; jumptable 00000000000047B4 case 38
movapd xmm1, cs:xmmword_4B010
andpd xmm1, xmm0
ucomisd xmm1, cs:qword_4B090
jbe short loc_498A
cvttsd2si rax, xmm0
mov rcx, 0CCCCCCCCCCCCCCCDh
imul rcx, rax
mov rax, 1999999999999999h
add rax, rcx
mov rcx, 3333333333333332h
cmp rax, rcx
ja short loc_498A
addsd xmm0, cs:qword_4B098
loc_498A:
lea rsi, aOutputpinanten; "OUTPUTPINANTENNASIZE %g\n"
jmp short loc_49EE
loc_4993:
mov rdi, cs:fout; jumptable 00000000000047B4 case 42
movapd xmm1, cs:xmmword_4B010
andpd xmm1, xmm0
ucomisd xmm1, cs:qword_4B090
jbe short loc_49E7
cvttsd2si rax, xmm0
mov rcx, 0CCCCCCCCCCCCCCCDh
imul rcx, rax
mov rax, 1999999999999999h
add rax, rcx
mov rcx, 3333333333333332h
cmp rax, rcx
ja short loc_49E7
addsd xmm0, cs:qword_4B098
loc_49E7:
lea rsi, aAntoutputdiffa; "ANTOUTPUTDIFFAREA %g\n"
loc_49EE:
mov al, 1
call _fprintf
def_47B4:
xor eax, eax; jumptable 00000000000047B4 default case
add rsp, 18h
pop rbx
pop r14
retn
|
long long antennaCB(unsigned int a1, long long a2, double a3)
{
if ( a1 >= 0x39 )
fwrite("ERROR: callback type is out of bounds!\n", 39LL, 1LL, fout);
if ( userData != a2 )
fwrite("ERROR: returned user data is not correct!\n", 42LL, 1LL, fout);
switch ( a1 )
{
case '%':
if ( fabs(a3) > 1000004.0
&& 0xCCCCCCCCCCCCCCCDLL * (unsigned int)(int)a3 + 0x1999999999999999LL <= 0x3333333333333332LL )
{
a3 = a3 + 3.0;
}
fprintf(fout, "INPUTPINANTENNASIZE %g\n", a3);
break;
case '&':
if ( fabs(a3) > 1000004.0
&& 0xCCCCCCCCCCCCCCCDLL * (unsigned int)(int)a3 + 0x1999999999999999LL <= 0x3333333333333332LL )
{
a3 = a3 + 3.0;
}
fprintf(fout, "OUTPUTPINANTENNASIZE %g\n", a3);
break;
case '\'':
if ( fabs(a3) > 1000004.0
&& 0xCCCCCCCCCCCCCCCDLL * (unsigned int)(int)a3 + 0x1999999999999999LL <= 0x3333333333333332LL )
{
a3 = a3 + 3.0;
}
fprintf(fout, "INOUTPINANTENNASIZE %g\n", a3);
break;
case '(':
if ( fabs(a3) > 1000004.0
&& 0xCCCCCCCCCCCCCCCDLL * (unsigned int)(int)a3 + 0x1999999999999999LL <= 0x3333333333333332LL )
{
a3 = a3 + 3.0;
}
fprintf(fout, "ANTINPUTGATEAREA %g\n", a3);
break;
case ')':
if ( fabs(a3) > 1000004.0
&& 0xCCCCCCCCCCCCCCCDLL * (unsigned int)(int)a3 + 0x1999999999999999LL <= 0x3333333333333332LL )
{
a3 = a3 + 3.0;
}
fprintf(fout, "ANTINOUTDIFFAREA %g\n", a3);
break;
case '*':
if ( fabs(a3) > 1000004.0
&& 0xCCCCCCCCCCCCCCCDLL * (unsigned int)(int)a3 + 0x1999999999999999LL <= 0x3333333333333332LL )
{
a3 = a3 + 3.0;
}
fprintf(fout, "ANTOUTPUTDIFFAREA %g\n", a3);
break;
default:
return 0LL;
}
return 0LL;
}
|
antennaCB:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV EBX,EDI
CMP EDI,0x39
MOVAPD xmmword ptr [RSP],XMM0
JC 0x0010476f
MOV RCX,qword ptr [0x001773f0]
LEA RDI,[0x14b1f7]
MOV ESI,0x27
MOV EDX,0x1
CALL 0x001023b0
MOVAPD XMM0,xmmword ptr [RSP]
LAB_0010476f:
CMP qword ptr [0x00177400],R14
JZ 0x0010479a
MOV RCX,qword ptr [0x001773f0]
LEA RDI,[0x14b1cc]
MOV ESI,0x2a
MOV EDX,0x1
CALL 0x001023b0
MOVAPD XMM0,xmmword ptr [RSP]
LAB_0010479a:
ADD EBX,-0x25
CMP EBX,0x5
JA 0x001049f5
LEA RAX,[0x14b130]
MOVSXD RCX,dword ptr [RAX + RBX*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_25:
MOV RDI,qword ptr [0x001773f0]
MOVAPD XMM1,xmmword ptr [0x0014b010]
ANDPD XMM1,XMM0
UCOMISD XMM1,qword ptr [0x0014b090]
JBE 0x0010480a
CVTTSD2SI RAX,XMM0
MOV RCX,-0x3333333333333333
IMUL RCX,RAX
MOV RAX,0x1999999999999999
ADD RAX,RCX
MOV RCX,0x3333333333333332
CMP RAX,RCX
JA 0x0010480a
ADDSD XMM0,qword ptr [0x0014b098]
LAB_0010480a:
LEA RSI,[0x14b616]
JMP 0x001049ee
caseD_29:
MOV RDI,qword ptr [0x001773f0]
MOVAPD XMM1,xmmword ptr [0x0014b010]
ANDPD XMM1,XMM0
UCOMISD XMM1,qword ptr [0x0014b090]
JBE 0x0010486a
CVTTSD2SI RAX,XMM0
MOV RCX,-0x3333333333333333
IMUL RCX,RAX
MOV RAX,0x1999999999999999
ADD RAX,RCX
MOV RCX,0x3333333333333332
CMP RAX,RCX
JA 0x0010486a
ADDSD XMM0,qword ptr [0x0014b098]
LAB_0010486a:
LEA RSI,[0x14b5eb]
JMP 0x001049ee
caseD_27:
MOV RDI,qword ptr [0x001773f0]
MOVAPD XMM1,xmmword ptr [0x0014b010]
ANDPD XMM1,XMM0
UCOMISD XMM1,qword ptr [0x0014b090]
JBE 0x001048ca
CVTTSD2SI RAX,XMM0
MOV RCX,-0x3333333333333333
IMUL RCX,RAX
MOV RAX,0x1999999999999999
ADD RAX,RCX
MOV RCX,0x3333333333333332
CMP RAX,RCX
JA 0x001048ca
ADDSD XMM0,qword ptr [0x0014b098]
LAB_001048ca:
LEA RSI,[0x14b647]
JMP 0x001049ee
caseD_28:
MOV RDI,qword ptr [0x001773f0]
MOVAPD XMM1,xmmword ptr [0x0014b010]
ANDPD XMM1,XMM0
UCOMISD XMM1,qword ptr [0x0014b090]
JBE 0x0010492a
CVTTSD2SI RAX,XMM0
MOV RCX,-0x3333333333333333
IMUL RCX,RAX
MOV RAX,0x1999999999999999
ADD RAX,RCX
MOV RCX,0x3333333333333332
CMP RAX,RCX
JA 0x0010492a
ADDSD XMM0,qword ptr [0x0014b098]
LAB_0010492a:
LEA RSI,[0x14b5d6]
JMP 0x001049ee
caseD_26:
MOV RDI,qword ptr [0x001773f0]
MOVAPD XMM1,xmmword ptr [0x0014b010]
ANDPD XMM1,XMM0
UCOMISD XMM1,qword ptr [0x0014b090]
JBE 0x0010498a
CVTTSD2SI RAX,XMM0
MOV RCX,-0x3333333333333333
IMUL RCX,RAX
MOV RAX,0x1999999999999999
ADD RAX,RCX
MOV RCX,0x3333333333333332
CMP RAX,RCX
JA 0x0010498a
ADDSD XMM0,qword ptr [0x0014b098]
LAB_0010498a:
LEA RSI,[0x14b62e]
JMP 0x001049ee
caseD_2a:
MOV RDI,qword ptr [0x001773f0]
MOVAPD XMM1,xmmword ptr [0x0014b010]
ANDPD XMM1,XMM0
UCOMISD XMM1,qword ptr [0x0014b090]
JBE 0x001049e7
CVTTSD2SI RAX,XMM0
MOV RCX,-0x3333333333333333
IMUL RCX,RAX
MOV RAX,0x1999999999999999
ADD RAX,RCX
MOV RCX,0x3333333333333332
CMP RAX,RCX
JA 0x001049e7
ADDSD XMM0,qword ptr [0x0014b098]
LAB_001049e7:
LEA RSI,[0x14b600]
LAB_001049ee:
MOV AL,0x1
CALL 0x001022c0
default:
XOR EAX,EAX
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* antennaCB(LefDefParser::lefrCallbackType_e, double, void*) */
int8 antennaCB(double param_1,uint param_2,long param_3)
{
char *__format;
if (0x38 < param_2) {
fwrite("ERROR: callback type is out of bounds!\n",0x27,1,fout);
}
if (userData != param_3) {
fwrite("ERROR: returned user data is not correct!\n",0x2a,1,fout);
}
switch(param_2) {
case 0x25:
if ((DAT_0014b090 < (double)(_DAT_0014b010 & (ulong)param_1)) &&
((long)param_1 * -0x3333333333333333 + 0x1999999999999999U < 0x3333333333333333)) {
param_1 = param_1 + _DAT_0014b098;
}
__format = "INPUTPINANTENNASIZE %g\n";
break;
case 0x26:
if ((DAT_0014b090 < (double)(_DAT_0014b010 & (ulong)param_1)) &&
((long)param_1 * -0x3333333333333333 + 0x1999999999999999U < 0x3333333333333333)) {
param_1 = param_1 + _DAT_0014b098;
}
__format = "OUTPUTPINANTENNASIZE %g\n";
break;
case 0x27:
if ((DAT_0014b090 < (double)(_DAT_0014b010 & (ulong)param_1)) &&
((long)param_1 * -0x3333333333333333 + 0x1999999999999999U < 0x3333333333333333)) {
param_1 = param_1 + _DAT_0014b098;
}
__format = "INOUTPINANTENNASIZE %g\n";
break;
case 0x28:
if ((DAT_0014b090 < (double)(_DAT_0014b010 & (ulong)param_1)) &&
((long)param_1 * -0x3333333333333333 + 0x1999999999999999U < 0x3333333333333333)) {
param_1 = param_1 + _DAT_0014b098;
}
__format = "ANTINPUTGATEAREA %g\n";
break;
case 0x29:
if ((DAT_0014b090 < (double)(_DAT_0014b010 & (ulong)param_1)) &&
((long)param_1 * -0x3333333333333333 + 0x1999999999999999U < 0x3333333333333333)) {
param_1 = param_1 + _DAT_0014b098;
}
__format = "ANTINOUTDIFFAREA %g\n";
break;
case 0x2a:
if ((DAT_0014b090 < (double)(_DAT_0014b010 & (ulong)param_1)) &&
((long)param_1 * -0x3333333333333333 + 0x1999999999999999U < 0x3333333333333333)) {
param_1 = param_1 + _DAT_0014b098;
}
__format = "ANTOUTPUTDIFFAREA %g\n";
break;
default:
goto switchD_001047b4_default;
}
fprintf(fout,__format,param_1);
switchD_001047b4_default:
return 0;
}
|
|
66,404 |
apply_shift
|
eloqsql/strings/ctype-uca.c
|
static my_bool
apply_shift(MY_CHARSET_LOADER *loader,
MY_COLL_RULES *rules, MY_COLL_RULE *r, int level,
uint16 *to, size_t nweights)
{
/* Apply level difference. */
if (nweights)
{
to[nweights - 1]+= r->diff[level];
if (r->before_level == 1) /* Apply "&[before primary]" */
{
if (nweights >= 2)
{
to[nweights - 2]--; /* Reset before */
if (rules->shift_after_method == my_shift_method_expand)
{
/*
Special case. Don't let characters shifted after X
and before next(X) intermix to each other.
For example:
"[shift-after-method expand] &0 < a &[before primary]1 < A".
I.e. we reorder 'a' after '0', and then 'A' before '1'.
'a' must be sorted before 'A'.
Note, there are no real collations in CLDR which shift
after and before two neighbourgh characters. We need this
just in case. Reserving 4096 (0x1000) weights for such
cases is perfectly enough.
*/
to[nweights - 1]+= 0x1000; /* W3-TODO: const may vary on levels 2,3*/
}
}
else
{
my_snprintf(loader->error, sizeof(loader->error),
"Can't reset before "
"a primary ignorable character U+%04lX", r->base[0]);
return TRUE;
}
}
}
else
{
/* Shift to an ignorable character, e.g.: & \u0000 < \u0001 */
DBUG_ASSERT(to[0] == 0);
to[0]= r->diff[level];
}
return FALSE;
}
|
O0
|
c
|
apply_shift:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xa066a
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x80(%rax,%rcx,4), %esi
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movzwl (%rax,%rcx,2), %edx
addl %esi, %edx
movw %dx, (%rax,%rcx,2)
movq -0x20(%rbp), %rax
cmpq $0x1, 0x90(%rax)
jne 0xa0668
cmpq $0x2, -0x38(%rbp)
jb 0xa0642
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x2, %rcx
movw (%rax,%rcx,2), %dx
addw $-0x1, %dx
movw %dx, (%rax,%rcx,2)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0xa0640
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movzwl (%rax,%rcx,2), %edx
addl $0x1000, %edx # imm = 0x1000
movw %dx, (%rax,%rcx,2)
jmp 0xa0666
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl $0x80, %esi
leaq 0x2eace(%rip), %rdx # 0xcf127
movb $0x0, %al
callq 0xc6250
movb $0x1, -0x1(%rbp)
jmp 0xa068b
jmp 0xa0668
jmp 0xa0687
jmp 0xa066c
jmp 0xa066e
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x80(%rax,%rcx,4), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
apply_shift:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
cmp [rbp+var_38], 0
jz loc_A066A
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_24]
mov esi, [rax+rcx*4+80h]
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub rcx, 1
movzx edx, word ptr [rax+rcx*2]
add edx, esi
mov [rax+rcx*2], dx
mov rax, [rbp+var_20]
cmp qword ptr [rax+90h], 1
jnz short loc_A0668
cmp [rbp+var_38], 2
jb short loc_A0642
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub rcx, 2
mov dx, [rax+rcx*2]
add dx, 0FFFFh
mov [rax+rcx*2], dx
mov rax, [rbp+var_18]
cmp dword ptr [rax+30h], 1
jnz short loc_A0640
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub rcx, 1
movzx edx, word ptr [rax+rcx*2]
add edx, 1000h
mov [rax+rcx*2], dx
loc_A0640:
jmp short loc_A0666
loc_A0642:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_20]
mov rcx, [rax]
mov esi, 80h
lea rdx, aCanTResetBefor; "Can't reset before a primary ignorable "...
mov al, 0
call my_snprintf
mov [rbp+var_1], 1
jmp short loc_A068B
loc_A0666:
jmp short $+2
loc_A0668:
jmp short loc_A0687
loc_A066A:
jmp short $+2
loc_A066C:
jmp short $+2
loc_A066E:
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_24]
mov eax, [rax+rcx*4+80h]
mov cx, ax
mov rax, [rbp+var_30]
mov [rax], cx
loc_A0687:
mov [rbp+var_1], 0
loc_A068B:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
|
char apply_shift(int a1, long long a2, _QWORD *a3, int a4, _WORD *a5, unsigned long long a6)
{
if ( !a6 )
{
*a5 = *((_DWORD *)a3 + a4 + 32);
return 0;
}
a5[a6 - 1] += *((_DWORD *)a3 + a4 + 32);
if ( a3[18] != 1LL )
return 0;
if ( a6 >= 2 )
{
--a5[a6 - 2];
if ( *(_DWORD *)(a2 + 48) == 1 )
a5[a6 - 1] += 4096;
return 0;
}
my_snprintf(a1, 128, (unsigned int)"Can't reset before a primary ignorable character U+%04lX", *a3, (_DWORD)a5, a6);
return 1;
}
|
apply_shift:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
CMP qword ptr [RBP + -0x38],0x0
JZ 0x001a066a
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV ESI,dword ptr [RAX + RCX*0x4 + 0x80]
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB RCX,0x1
MOVZX EDX,word ptr [RAX + RCX*0x2]
ADD EDX,ESI
MOV word ptr [RAX + RCX*0x2],DX
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x90],0x1
JNZ 0x001a0668
CMP qword ptr [RBP + -0x38],0x2
JC 0x001a0642
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB RCX,0x2
MOV DX,word ptr [RAX + RCX*0x2]
ADD DX,-0x1
MOV word ptr [RAX + RCX*0x2],DX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x30],0x1
JNZ 0x001a0640
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB RCX,0x1
MOVZX EDX,word ptr [RAX + RCX*0x2]
ADD EDX,0x1000
MOV word ptr [RAX + RCX*0x2],DX
LAB_001a0640:
JMP 0x001a0666
LAB_001a0642:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV ESI,0x80
LEA RDX,[0x1cf127]
MOV AL,0x0
CALL 0x001c6250
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001a068b
LAB_001a0666:
JMP 0x001a0668
LAB_001a0668:
JMP 0x001a0687
LAB_001a066a:
JMP 0x001a066c
LAB_001a066c:
JMP 0x001a066e
LAB_001a066e:
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV EAX,dword ptr [RAX + RCX*0x4 + 0x80]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x30]
MOV word ptr [RAX],CX
LAB_001a0687:
MOV byte ptr [RBP + -0x1],0x0
LAB_001a068b:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1
apply_shift(int8 param_1,long param_2,int8 *param_3,int param_4,int2 *param_5,
ulong param_6)
{
if (param_6 == 0) {
*param_5 = (short)*(int4 *)((long)param_3 + (long)param_4 * 4 + 0x80);
}
else {
param_5[param_6 - 1] =
param_5[param_6 - 1] + (short)*(int4 *)((long)param_3 + (long)param_4 * 4 + 0x80);
if (param_3[0x12] == 1) {
if (param_6 < 2) {
my_snprintf(param_1,0x80,"Can\'t reset before a primary ignorable character U+%04lX",
*param_3);
return 1;
}
param_5[param_6 - 2] = param_5[param_6 - 2] + -1;
if (*(int *)(param_2 + 0x30) == 1) {
param_5[param_6 - 1] = param_5[param_6 - 1] + 0x1000;
}
}
}
return 0;
}
|
|
66,405 |
my_error_register
|
eloqsql/mysys/my_error.c
|
int my_error_register(const char** (*get_errmsgs)(int error), uint first,
uint last)
{
struct my_err_head *meh_p;
struct my_err_head **search_meh_pp;
/* Allocate a new header structure. */
if (! (meh_p= (struct my_err_head*) my_malloc(key_memory_my_err_head,
sizeof(struct my_err_head),
MYF(MY_WME))))
return 1;
meh_p->get_errmsgs= get_errmsgs;
meh_p->meh_first= first;
meh_p->meh_last= last;
/* Search for the right position in the list. */
for (search_meh_pp= &my_errmsgs_list;
*search_meh_pp;
search_meh_pp= &(*search_meh_pp)->meh_next)
{
if ((*search_meh_pp)->meh_last > first)
break;
}
/* Error numbers must be unique. No overlapping is allowed. */
if (*search_meh_pp && ((*search_meh_pp)->meh_first <= last))
{
my_free(meh_p);
return 1;
}
/* Insert header into the chain. */
meh_p->meh_next= *search_meh_pp;
*search_meh_pp= meh_p;
return 0;
}
|
O0
|
c
|
my_error_register:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
leaq 0x35a447(%rip), %rax # 0x391e10
movl (%rax), %edi
movl $0x18, %esi
movl $0x10, %edx
callq 0x2b560
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x379f0
movl $0x1, -0x4(%rbp)
jmp 0x37a90
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
leaq 0x1a2851(%rip), %rax # 0x1da268
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x37a45
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x14(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x37a36
jmp 0x37a45
jmp 0x37a38
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x37a1b
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x37a70
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
cmpl -0x18(%rbp), %eax
ja 0x37a70
movq -0x20(%rbp), %rdi
callq 0x2b8e0
movl $0x1, -0x4(%rbp)
jmp 0x37a90
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
my_error_register:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
lea rax, key_memory_my_err_head
mov edi, [rax]
mov esi, 18h
mov edx, 10h
call my_malloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_379F0
mov [rbp+var_4], 1
jmp loc_37A90
loc_379F0:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+10h], ecx
mov ecx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+14h], ecx
lea rax, my_errmsgs_list
mov [rbp+var_28], rax
loc_37A1B:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_37A45
mov rax, [rbp+var_28]
mov rax, [rax]
mov eax, [rax+14h]
cmp eax, [rbp+var_14]
jbe short loc_37A36
jmp short loc_37A45
loc_37A36:
jmp short $+2
loc_37A38:
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short loc_37A1B
loc_37A45:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_37A70
mov rax, [rbp+var_28]
mov rax, [rax]
mov eax, [rax+10h]
cmp eax, [rbp+var_18]
ja short loc_37A70
mov rdi, [rbp+var_20]
call my_free
mov [rbp+var_4], 1
jmp short loc_37A90
loc_37A70:
mov rax, [rbp+var_28]
mov rcx, [rax]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_28]
mov [rax], rcx
mov [rbp+var_4], 0
loc_37A90:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long my_error_register(long long a1, unsigned int a2, unsigned int a3)
{
long long **i; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+10h] [rbp-20h]
v5 = my_malloc(key_memory_my_err_head, 0x18uLL, 16);
if ( v5 )
{
*(_QWORD *)(v5 + 8) = a1;
*(_DWORD *)(v5 + 16) = a2;
*(_DWORD *)(v5 + 20) = a3;
for ( i = &my_errmsgs_list; *i && *((_DWORD *)*i + 5) <= a2; i = (long long **)*i )
;
if ( *i && *((_DWORD *)*i + 4) <= a3 )
{
my_free(v5);
return 1;
}
else
{
*(_QWORD *)v5 = *i;
*i = (long long *)v5;
return 0;
}
}
else
{
return 1;
}
}
|
my_error_register:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
LEA RAX,[0x491e10]
MOV EDI,dword ptr [RAX]
MOV ESI,0x18
MOV EDX,0x10
CALL 0x0012b560
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x001379f0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00137a90
LAB_001379f0:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x10],ECX
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x14],ECX
LEA RAX,[0x2da268]
MOV qword ptr [RBP + -0x28],RAX
LAB_00137a1b:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x00137a45
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x14]
CMP EAX,dword ptr [RBP + -0x14]
JBE 0x00137a36
JMP 0x00137a45
LAB_00137a36:
JMP 0x00137a38
LAB_00137a38:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00137a1b
LAB_00137a45:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x00137a70
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
CMP EAX,dword ptr [RBP + -0x18]
JA 0x00137a70
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0012b8e0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00137a90
LAB_00137a70:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x0
LAB_00137a90:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_error_register(long param_1,uint param_2,uint param_3)
{
long *plVar1;
int **local_30;
int4 local_c;
plVar1 = (long *)my_malloc(key_memory_my_err_head,0x18,0x10);
if (plVar1 == (long *)0x0) {
local_c = 1;
}
else {
plVar1[1] = param_1;
*(uint *)(plVar1 + 2) = param_2;
*(uint *)((long)plVar1 + 0x14) = param_3;
for (local_30 = &my_errmsgs_list;
(*local_30 != (int *)0x0 && (*(uint *)(*local_30 + 0x14) <= param_2));
local_30 = (int **)*local_30) {
}
if ((*local_30 == (int *)0x0) || (param_3 < *(uint *)(*local_30 + 0x10))) {
*plVar1 = (long)*local_30;
*local_30 = (int *)plVar1;
local_c = 0;
}
else {
my_free(plVar1);
local_c = 1;
}
}
return local_c;
}
|
|
66,406 |
ggml_transpose
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_transpose(
struct ggml_context * ctx,
struct ggml_tensor * a) {
bool is_node = false;
if (a->grad) {
is_node = true;
}
struct ggml_tensor * result = ggml_view_tensor(ctx, a);
ggml_format_name(result, "%s (transposed)", a->name);
result->ne[0] = a->ne[1];
result->ne[1] = a->ne[0];
result->nb[0] = a->nb[1];
result->nb[1] = a->nb[0];
result->op = GGML_OP_TRANSPOSE;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
return result;
}
|
O1
|
c
|
ggml_transpose:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x98(%rsi), %r13
callq 0x90b1a
movq %rax, %r14
leaq 0x120(%rbx), %rdx
leaq 0x32bed(%rip), %rsi # 0xc60ef
xorl %r12d, %r12d
movq %rax, %rdi
xorl %eax, %eax
callq 0x90a74
movq 0x18(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x38(%rbx), %rax
movq %rax, 0x30(%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x38(%r14)
movl $0x21, 0x50(%r14)
testq %r13, %r13
je 0x9355c
movq %r14, %rcx
addq $0x10, %rcx
movl (%r14), %esi
movq %r15, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e8b7
movq %rax, %r12
movq %r12, 0x98(%r14)
movq %rbx, 0xa0(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
ggml_transpose:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rsi
mov r15, rdi
mov r13, [rsi+98h]
call ggml_view_tensor
mov r14, rax
lea rdx, [rbx+120h]
lea rsi, aSTransposed; "%s (transposed)"
xor r12d, r12d
mov rdi, rax
xor eax, eax
call ggml_format_name
mov rax, [rbx+18h]
mov [r14+10h], rax
mov rax, [rbx+10h]
mov [r14+18h], rax
mov rax, [rbx+38h]
mov [r14+30h], rax
mov rax, [rbx+30h]
mov [r14+38h], rax
mov dword ptr [r14+50h], 21h ; '!'
test r13, r13
jz short loc_9355C
mov rcx, r14
add rcx, 10h
mov esi, [r14]
mov rdi, r15
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov r12, rax
loc_9355C:
mov [r14+98h], r12
mov [r14+0A0h], rbx
mov rax, r14
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long ggml_transpose(
long long a1,
_QWORD *a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // r13
long long v11; // r14
long long v12; // r12
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
char v19; // [rsp+0h] [rbp-28h]
v10 = a2[19];
v11 = ggml_view_tensor(a1, (long long)a2, a3, a4, a5, a6, a7, a8, a9, a10);
v12 = 0LL;
ggml_format_name(
v11,
(long long)"%s (transposed)",
(long long)(a2 + 36),
v13,
v14,
v15,
a3,
a4,
a5,
a6,
v16,
v17,
a9,
a10,
v19);
*(_QWORD *)(v11 + 16) = a2[3];
*(_QWORD *)(v11 + 24) = a2[2];
*(_QWORD *)(v11 + 48) = a2[7];
*(_QWORD *)(v11 + 56) = a2[6];
*(_DWORD *)(v11 + 80) = 33;
if ( v10 )
v12 = ggml_new_tensor_impl(a1, *(_DWORD *)v11, 4, (_QWORD *)(v11 + 16), 0LL, 0LL, a3, a4);
*(_QWORD *)(v11 + 152) = v12;
*(_QWORD *)(v11 + 160) = a2;
return v11;
}
| |||
66,407 |
ggml_transpose
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_transpose(
struct ggml_context * ctx,
struct ggml_tensor * a) {
bool is_node = false;
if (a->grad) {
is_node = true;
}
struct ggml_tensor * result = ggml_view_tensor(ctx, a);
ggml_format_name(result, "%s (transposed)", a->name);
result->ne[0] = a->ne[1];
result->ne[1] = a->ne[0];
result->nb[0] = a->nb[1];
result->nb[1] = a->nb[0];
result->op = GGML_OP_TRANSPOSE;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
return result;
}
|
O2
|
c
|
ggml_transpose:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x98(%rsi), %r13
callq 0x69922
movq %rax, %r14
leaq 0x120(%rbx), %rdx
leaq 0x358a7(%rip), %rsi # 0xa1ec7
xorl %r12d, %r12d
movq %rax, %rdi
xorl %eax, %eax
callq 0x6987c
movq 0x18(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x38(%rbx), %rax
movq %rax, 0x30(%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x38(%r14)
movl $0x21, 0x50(%r14)
testq %r13, %r13
je 0x6c668
movq %r15, %rdi
movq %r14, %rsi
callq 0x68a65
movq %rax, %r12
movq %r12, 0x98(%r14)
movq %rbx, 0xa0(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
ggml_transpose:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rsi
mov r15, rdi
mov r13, [rsi+98h]
call ggml_view_tensor
mov r14, rax
lea rdx, [rbx+120h]
lea rsi, aSTransposed; "%s (transposed)"
xor r12d, r12d
mov rdi, rax
xor eax, eax
call ggml_format_name
mov rax, [rbx+18h]
mov [r14+10h], rax
mov rax, [rbx+10h]
mov [r14+18h], rax
mov rax, [rbx+38h]
mov [r14+30h], rax
mov rax, [rbx+30h]
mov [r14+38h], rax
mov dword ptr [r14+50h], 21h ; '!'
test r13, r13
jz short loc_6C668
mov rdi, r15
mov rsi, r14
call ggml_dup_tensor
mov r12, rax
loc_6C668:
mov [r14+98h], r12
mov [r14+0A0h], rbx
mov rax, r14
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long ggml_transpose(
long long a1,
_QWORD *a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // r13
long long v11; // r14
long long v12; // r12
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
char v19; // [rsp+0h] [rbp-28h]
v10 = a2[19];
v11 = ggml_view_tensor(a1, (long long)a2, a3, a4, a5, a6, a7, a8, a9, a10);
v12 = 0LL;
ggml_format_name(
v11,
(long long)"%s (transposed)",
(long long)(a2 + 36),
v13,
v14,
v15,
a3,
a4,
a5,
a6,
v16,
v17,
a9,
a10,
v19);
*(_QWORD *)(v11 + 16) = a2[3];
*(_QWORD *)(v11 + 24) = a2[2];
*(_QWORD *)(v11 + 48) = a2[7];
*(_QWORD *)(v11 + 56) = a2[6];
*(_DWORD *)(v11 + 80) = 33;
if ( v10 )
v12 = ggml_dup_tensor(a1, (unsigned int *)v11);
*(_QWORD *)(v11 + 152) = v12;
*(_QWORD *)(v11 + 160) = a2;
return v11;
}
|
ggml_transpose:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R15,RDI
MOV R13,qword ptr [RSI + 0x98]
CALL 0x00169922
MOV R14,RAX
LEA RDX,[RBX + 0x120]
LEA RSI,[0x1a1ec7]
XOR R12D,R12D
MOV RDI,RAX
XOR EAX,EAX
CALL 0x0016987c
MOV RAX,qword ptr [RBX + 0x18]
MOV qword ptr [R14 + 0x10],RAX
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [R14 + 0x18],RAX
MOV RAX,qword ptr [RBX + 0x38]
MOV qword ptr [R14 + 0x30],RAX
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [R14 + 0x38],RAX
MOV dword ptr [R14 + 0x50],0x21
TEST R13,R13
JZ 0x0016c668
MOV RDI,R15
MOV RSI,R14
CALL 0x00168a65
MOV R12,RAX
LAB_0016c668:
MOV qword ptr [R14 + 0x98],R12
MOV qword ptr [R14 + 0xa0],RBX
MOV RAX,R14
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
long ggml_transpose(int8 param_1,long param_2)
{
long lVar1;
long lVar2;
int8 uVar3;
lVar1 = *(long *)(param_2 + 0x98);
lVar2 = ggml_view_tensor();
uVar3 = 0;
ggml_format_name(lVar2,"%s (transposed)",param_2 + 0x120);
*(int8 *)(lVar2 + 0x10) = *(int8 *)(param_2 + 0x18);
*(int8 *)(lVar2 + 0x18) = *(int8 *)(param_2 + 0x10);
*(int8 *)(lVar2 + 0x30) = *(int8 *)(param_2 + 0x38);
*(int8 *)(lVar2 + 0x38) = *(int8 *)(param_2 + 0x30);
*(int4 *)(lVar2 + 0x50) = 0x21;
if (lVar1 != 0) {
uVar3 = ggml_dup_tensor(param_1,lVar2);
}
*(int8 *)(lVar2 + 0x98) = uVar3;
*(long *)(lVar2 + 0xa0) = param_2;
return lVar2;
}
|
|
66,408 |
ggml_transpose
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_transpose(
struct ggml_context * ctx,
struct ggml_tensor * a) {
bool is_node = false;
if (a->grad) {
is_node = true;
}
struct ggml_tensor * result = ggml_view_tensor(ctx, a);
ggml_format_name(result, "%s (transposed)", a->name);
result->ne[0] = a->ne[1];
result->ne[1] = a->ne[0];
result->nb[0] = a->nb[1];
result->nb[1] = a->nb[0];
result->op = GGML_OP_TRANSPOSE;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
return result;
}
|
O3
|
c
|
ggml_transpose:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x98(%rsi), %r13
callq 0x8f880
movq %rax, %r14
leaq 0x120(%rbx), %rdx
leaq 0x32da5(%rip), %rsi # 0xc5113
xorl %r12d, %r12d
movq %rax, %rdi
xorl %eax, %eax
callq 0x8f7da
movq 0x18(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x38(%rbx), %rax
movq %rax, 0x30(%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x38(%r14)
movl $0x21, 0x50(%r14)
testq %r13, %r13
je 0x923c8
movq %r14, %rcx
addq $0x10, %rcx
movl (%r14), %esi
movq %r15, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8d64f
movq %rax, %r12
movq %r12, 0x98(%r14)
movq %rbx, 0xa0(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
ggml_transpose:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rsi
mov r15, rdi
mov r13, [rsi+98h]
call ggml_view_tensor
mov r14, rax
lea rdx, [rbx+120h]
lea rsi, aSTransposed; "%s (transposed)"
xor r12d, r12d
mov rdi, rax
xor eax, eax
call ggml_format_name
mov rax, [rbx+18h]
mov [r14+10h], rax
mov rax, [rbx+10h]
mov [r14+18h], rax
mov rax, [rbx+38h]
mov [r14+30h], rax
mov rax, [rbx+30h]
mov [r14+38h], rax
mov dword ptr [r14+50h], 21h ; '!'
test r13, r13
jz short loc_923C8
mov rcx, r14
add rcx, 10h
mov esi, [r14]
mov rdi, r15
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov r12, rax
loc_923C8:
mov [r14+98h], r12
mov [r14+0A0h], rbx
mov rax, r14
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long ggml_transpose(
long long a1,
_QWORD *a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // r13
long long v11; // r14
long long v12; // r12
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
char v19; // [rsp+0h] [rbp-28h]
v10 = a2[19];
v11 = ggml_view_tensor(a1, (long long)a2, a3, a4, a5, a6, a7, a8, a9, a10);
v12 = 0LL;
ggml_format_name(
v11,
(long long)"%s (transposed)",
(long long)(a2 + 36),
v13,
v14,
v15,
a3,
a4,
a5,
a6,
v16,
v17,
a9,
a10,
v19);
*(_QWORD *)(v11 + 16) = a2[3];
*(_QWORD *)(v11 + 24) = a2[2];
*(_QWORD *)(v11 + 48) = a2[7];
*(_QWORD *)(v11 + 56) = a2[6];
*(_DWORD *)(v11 + 80) = 33;
if ( v10 )
v12 = ggml_new_tensor_impl(a1, *(_DWORD *)v11, 4, (_QWORD *)(v11 + 16), 0LL, 0LL, a3, a4);
*(_QWORD *)(v11 + 152) = v12;
*(_QWORD *)(v11 + 160) = a2;
return v11;
}
| |||
66,409 |
free_maria_share
|
eloqsql/storage/maria/ma_close.c
|
void free_maria_share(MARIA_SHARE *share)
{
if (!share->internal_table)
mysql_mutex_assert_owner(&share->intern_lock);
if (!share->reopen && !share->in_trans &&
!(share->in_checkpoint & MARIA_CHECKPOINT_SHOULD_FREE_ME))
{
/* No one can access this share anymore, time to delete it ! */
if (!share->internal_table)
mysql_mutex_unlock(&share->intern_lock);
ma_crypt_free(share);
my_free(share->s3_path);
(void) mysql_mutex_destroy(&share->intern_lock);
(void) mysql_mutex_destroy(&share->close_lock);
(void) mysql_cond_destroy(&share->key_del_cond);
my_free(share);
return;
}
if (!share->internal_table)
mysql_mutex_unlock(&share->intern_lock);
return;
}
|
O0
|
c
|
free_maria_share:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x7e2(%rax)
jne 0x46e8f
jmp 0x46e8b
jmp 0x46e8d
jmp 0x46e8f
movq -0x8(%rbp), %rax
cmpl $0x0, 0x7a8(%rax)
jne 0x46f35
movq -0x8(%rbp), %rax
cmpl $0x0, 0x7ac(%rax)
jne 0x46f35
movq -0x8(%rbp), %rax
movzbl 0x7d8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x46f35
movq -0x8(%rbp), %rax
cmpb $0x0, 0x7e2(%rax)
jne 0x46ee1
movq -0x8(%rbp), %rdi
addq $0x8f0, %rdi # imm = 0x8F0
callq 0x46e10
movq -0x8(%rbp), %rdi
callq 0x5e4a0
movq -0x8(%rbp), %rax
movq 0x798(%rax), %rdi
callq 0xf3bb0
movq -0x8(%rbp), %rdi
addq $0x8f0, %rdi # imm = 0x8F0
callq 0x46d50
movq -0x8(%rbp), %rdi
addq $0x9b8, %rdi # imm = 0x9B8
callq 0x46d50
movq -0x8(%rbp), %rdi
addq $0x980, %rdi # imm = 0x980
callq 0x46f60
movq -0x8(%rbp), %rdi
callq 0xf3bb0
jmp 0x46f54
movq -0x8(%rbp), %rax
cmpb $0x0, 0x7e2(%rax)
jne 0x46f52
movq -0x8(%rbp), %rdi
addq $0x8f0, %rdi # imm = 0x8F0
callq 0x46e10
jmp 0x46f54
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
free_maria_share:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp byte ptr [rax+7E2h], 0
jnz short loc_46E8F
jmp short $+2
loc_46E8B:
jmp short $+2
loc_46E8D:
jmp short $+2
loc_46E8F:
mov rax, [rbp+var_8]
cmp dword ptr [rax+7A8h], 0
jnz loc_46F35
mov rax, [rbp+var_8]
cmp dword ptr [rax+7ACh], 0
jnz loc_46F35
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+7D8h]
and eax, 2
cmp eax, 0
jnz short loc_46F35
mov rax, [rbp+var_8]
cmp byte ptr [rax+7E2h], 0
jnz short loc_46EE1
mov rdi, [rbp+var_8]
add rdi, 8F0h
call inline_mysql_mutex_unlock_5
loc_46EE1:
mov rdi, [rbp+var_8]
call ma_crypt_free
mov rax, [rbp+var_8]
mov rdi, [rax+798h]
call my_free
mov rdi, [rbp+var_8]
add rdi, 8F0h
call inline_mysql_mutex_destroy_1
mov rdi, [rbp+var_8]
add rdi, 9B8h
call inline_mysql_mutex_destroy_1
mov rdi, [rbp+var_8]
add rdi, 980h
call inline_mysql_cond_destroy_0
mov rdi, [rbp+var_8]
call my_free
jmp short loc_46F54
loc_46F35:
mov rax, [rbp+var_8]
cmp byte ptr [rax+7E2h], 0
jnz short loc_46F52
mov rdi, [rbp+var_8]
add rdi, 8F0h
call inline_mysql_mutex_unlock_5
loc_46F52:
jmp short $+2
loc_46F54:
add rsp, 10h
pop rbp
retn
|
long long free_maria_share(long long a1)
{
long long result; // rax
if ( *(_DWORD *)(a1 + 1960) || *(_DWORD *)(a1 + 1964) || (*(_BYTE *)(a1 + 2008) & 2) != 0 )
{
result = a1;
if ( !*(_BYTE *)(a1 + 2018) )
return inline_mysql_mutex_unlock_5(a1 + 2288);
}
else
{
if ( !*(_BYTE *)(a1 + 2018) )
inline_mysql_mutex_unlock_5(a1 + 2288);
ma_crypt_free(a1);
my_free(*(_QWORD *)(a1 + 1944));
inline_mysql_mutex_destroy_1(a1 + 2288);
inline_mysql_mutex_destroy_1(a1 + 2488);
inline_mysql_cond_destroy_0(a1 + 2432);
return my_free(a1);
}
return result;
}
|
free_maria_share:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x7e2],0x0
JNZ 0x00146e8f
JMP 0x00146e8b
LAB_00146e8b:
JMP 0x00146e8d
LAB_00146e8d:
JMP 0x00146e8f
LAB_00146e8f:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x7a8],0x0
JNZ 0x00146f35
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x7ac],0x0
JNZ 0x00146f35
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x7d8]
AND EAX,0x2
CMP EAX,0x0
JNZ 0x00146f35
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x7e2],0x0
JNZ 0x00146ee1
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x8f0
CALL 0x00146e10
LAB_00146ee1:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0015e4a0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x798]
CALL 0x001f3bb0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x8f0
CALL 0x00146d50
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x9b8
CALL 0x00146d50
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x980
CALL 0x00146f60
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001f3bb0
JMP 0x00146f54
LAB_00146f35:
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x7e2],0x0
JNZ 0x00146f52
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x8f0
CALL 0x00146e10
LAB_00146f52:
JMP 0x00146f54
LAB_00146f54:
ADD RSP,0x10
POP RBP
RET
|
void free_maria_share(long param_1)
{
if (((*(int *)(param_1 + 0x7a8) == 0) && (*(int *)(param_1 + 0x7ac) == 0)) &&
((*(byte *)(param_1 + 0x7d8) & 2) == 0)) {
if (*(char *)(param_1 + 0x7e2) == '\0') {
inline_mysql_mutex_unlock(param_1 + 0x8f0);
}
ma_crypt_free(param_1);
my_free(*(int8 *)(param_1 + 0x798));
inline_mysql_mutex_destroy(param_1 + 0x8f0);
inline_mysql_mutex_destroy(param_1 + 0x9b8);
inline_mysql_cond_destroy(param_1 + 0x980);
my_free(param_1);
}
else if (*(char *)(param_1 + 0x7e2) == '\0') {
inline_mysql_mutex_unlock(param_1 + 0x8f0);
}
return;
}
|
|
66,410 |
js_proxy_isExtensible
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_proxy_isExtensible(JSContext *ctx, JSValue obj)
{
JSProxyData *s;
JSValue method, ret;
BOOL res;
int res2;
s = get_proxy_method(ctx, &method, obj, JS_ATOM_isExtensible);
if (!s)
return -1;
if (JS_IsUndefined(method))
return JS_IsExtensible(ctx, s->target);
ret = JS_CallFree(ctx, method, s->handler, 1, &s->target);
if (JS_IsException(ret))
return -1;
res = JS_ToBoolFree(ctx, ret);
res2 = JS_IsExtensible(ctx, s->target);
if (res2 < 0)
return res2;
if (res != res2) {
JS_ThrowTypeError(ctx, "proxy: inconsistent isExtensible");
return -1;
}
return res;
}
|
O1
|
c
|
js_proxy_isExtensible:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movl $0x62, %r8d
callq 0x3d3e0
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x23f40
movq %rax, %r14
movq 0x10(%rsp), %rdx
cmpl $0x3, %edx
je 0x23f4d
movq 0x8(%rsp), %rsi
movq 0x10(%r14), %rcx
movq 0x18(%r14), %r8
movq %r14, (%rsp)
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x22c9d
cmpl $0x6, %edx
jne 0x23f66
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf6fb
movq %rbx, %rdi
movq %rax, %rsi
callq 0x22d0d
movl %eax, %r15d
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xf6fb
testl %eax, %eax
js 0x23f40
movl %r15d, %ebp
cmpl %eax, %r15d
je 0x23f40
leaq 0x7bf36(%rip), %rsi # 0x9fecc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0x23f40
|
js_proxy_isExtensible:
push rbp
push r15
push r14
push rbx
sub rsp, 18h
mov rcx, rdx
mov rdx, rsi
mov rbx, rdi
lea rsi, [rsp+38h+var_30]
mov r8d, 62h ; 'b'
call get_proxy_method
mov ebp, 0FFFFFFFFh
test rax, rax
jz short loc_23F40
mov r14, rax
mov rdx, [rsp+38h+var_28]
cmp edx, 3
jz short loc_23F4D
mov rsi, [rsp+38h+var_30]
mov rcx, [r14+10h]
mov r8, [r14+18h]
mov [rsp+38h+var_38], r14
mov rdi, rbx
mov r9d, 1
call JS_CallFree
cmp edx, 6
jnz short loc_23F66
loc_23F40:
mov eax, ebp
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_23F4D:
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
jmp JS_IsExtensible
loc_23F66:
mov rdi, rbx
mov rsi, rax
call JS_ToBoolFree
mov r15d, eax
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call JS_IsExtensible
test eax, eax
js short loc_23F40
mov ebp, r15d
cmp r15d, eax
jz short loc_23F40
lea rsi, aProxyInconsist_0; "proxy: inconsistent isExtensible"
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov ebp, 0FFFFFFFFh
jmp short loc_23F40
|
long long js_proxy_isExtensible(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long *proxy_method; // rax
unsigned int v12; // ebp
long long *v13; // r14
long long v14; // rax
long long v15; // rdx
unsigned int v17; // r15d
int IsExtensible; // eax
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
char v25; // [rsp+0h] [rbp-38h]
_DWORD *v26; // [rsp+8h] [rbp-30h] BYREF
long long v27; // [rsp+10h] [rbp-28h]
proxy_method = (long long *)get_proxy_method(a1, &v26, a2, a3, 98LL);
v12 = -1;
if ( !proxy_method )
return v12;
v13 = proxy_method;
if ( (_DWORD)v27 != 3 )
{
v14 = JS_CallFree(a1, v26, v27, proxy_method[2], proxy_method[3], 1, (long long)proxy_method);
if ( (_DWORD)v15 != 6 )
{
v17 = JS_ToBoolFree(a1, v14, v15);
IsExtensible = JS_IsExtensible(a1, *v13, v13[1]);
if ( IsExtensible >= 0 )
{
v12 = v17;
if ( v17 != IsExtensible )
{
JS_ThrowTypeError(
a1,
(long long)"proxy: inconsistent isExtensible",
v19,
v20,
v21,
v22,
a4,
a5,
a6,
a7,
v23,
v24,
a10,
a11,
v25);
return (unsigned int)-1;
}
}
}
return v12;
}
return JS_IsExtensible(a1, *proxy_method, proxy_method[1]);
}
|
js_proxy_isExtensible:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RCX,RDX
MOV RDX,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x8]
MOV R8D,0x62
CALL 0x0013d3e0
MOV EBP,0xffffffff
TEST RAX,RAX
JZ 0x00123f40
MOV R14,RAX
MOV RDX,qword ptr [RSP + 0x10]
CMP EDX,0x3
JZ 0x00123f4d
MOV RSI,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [R14 + 0x10]
MOV R8,qword ptr [R14 + 0x18]
MOV qword ptr [RSP],R14
MOV RDI,RBX
MOV R9D,0x1
CALL 0x00122c9d
CMP EDX,0x6
JNZ 0x00123f66
LAB_00123f40:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00123f4d:
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0010f6fb
LAB_00123f66:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00122d0d
MOV R15D,EAX
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0010f6fb
TEST EAX,EAX
JS 0x00123f40
MOV EBP,R15D
CMP R15D,EAX
JZ 0x00123f40
LEA RSI,[0x19fecc]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00122567
MOV EBP,0xffffffff
JMP 0x00123f40
|
ulong js_proxy_isExtensible(int8 param_1,int8 param_2,int8 param_3)
{
uint uVar1;
uint uVar2;
int8 *puVar3;
ulong uVar4;
int1 auVar5 [12];
int8 local_30;
int8 local_28;
puVar3 = (int8 *)get_proxy_method(param_1,&local_30,param_2,param_3,0x62);
uVar4 = 0xffffffff;
if (puVar3 != (int8 *)0x0) {
if ((int)local_28 == 3) {
uVar4 = JS_IsExtensible(param_1,*puVar3,puVar3[1]);
return uVar4;
}
auVar5 = JS_CallFree(param_1,local_30,local_28,puVar3[2],puVar3[3],1,puVar3);
if (auVar5._8_4_ != 6) {
uVar1 = JS_ToBoolFree(param_1,auVar5._0_8_);
uVar2 = JS_IsExtensible(param_1,*puVar3,puVar3[1]);
if ((-1 < (int)uVar2) && (uVar4 = (ulong)uVar1, uVar1 != uVar2)) {
JS_ThrowTypeError(param_1,"proxy: inconsistent isExtensible");
uVar4 = 0xffffffff;
}
}
}
return uVar4;
}
|
|
66,411 |
js_date_Symbol_toPrimitive
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_date_Symbol_toPrimitive(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
// Symbol_toPrimitive(hint)
JSValue obj = this_val;
JSAtom hint = JS_ATOM_NULL;
int hint_num;
if (!JS_IsObject(obj))
return JS_ThrowTypeErrorNotAnObject(ctx);
if (JS_IsString(argv[0])) {
hint = JS_ValueToAtom(ctx, argv[0]);
if (hint == JS_ATOM_NULL)
return JS_EXCEPTION;
JS_FreeAtom(ctx, hint);
}
switch (hint) {
case JS_ATOM_number:
case JS_ATOM_integer:
hint_num = HINT_NUMBER;
break;
case JS_ATOM_string:
case JS_ATOM_default:
hint_num = HINT_STRING;
break;
default:
return JS_ThrowTypeError(ctx, "invalid hint");
}
return JS_ToPrimitive(ctx, obj, hint_num | HINT_FORCE_ORDINARY);
}
|
O2
|
c
|
js_date_Symbol_toPrimitive:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl $-0x1, %r14d
jne 0x49ebc
movq 0x8(%r8), %rdx
cmpl $-0x7, %edx
jne 0x49ecc
movq %rsi, %r15
movq (%r8), %rsi
movq %rbx, %rdi
callq 0x1e0bc
testl %eax, %eax
je 0x49ec4
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x1a995
cmpl $0x16, %ebp
je 0x49e99
pushq $0x11
popq %rcx
cmpl $0x47, %ebp
je 0x49e9c
cmpl $0x4c, %ebp
je 0x49e9c
cmpl $0x49, %ebp
jne 0x49ecc
pushq $0x10
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21846
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r14d
jmp 0x49ee5
movq %rbx, %rdi
callq 0x1d5e1
pushq $0x6
popq %rdx
xorl %r14d, %r14d
jmp 0x49ee3
leaq 0x3d773(%rip), %rsi # 0x87646
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1c64d
pushq $0x6
popq %rdx
xorl %ecx, %ecx
orq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
js_date_Symbol_toPrimitive:
push rbp
push r15
push r14
push rbx
push rax
mov r14, rdx
mov rbx, rdi
cmp r14d, 0FFFFFFFFh
jnz short loc_49EBC
mov rdx, [r8+8]
cmp edx, 0FFFFFFF9h
jnz short loc_49ECC
mov r15, rsi
mov rsi, [r8]
mov rdi, rbx
call JS_ValueToAtom
test eax, eax
jz short loc_49EC4
mov ebp, eax
mov rdi, rbx
mov esi, eax
call JS_FreeAtom
cmp ebp, 16h
jz short loc_49E99
push 11h
pop rcx
cmp ebp, 47h ; 'G'
jz short loc_49E9C
cmp ebp, 4Ch ; 'L'
jz short loc_49E9C
cmp ebp, 49h ; 'I'
jnz short loc_49ECC
loc_49E99:
push 10h
pop rcx
loc_49E9C:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_ToPrimitive
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r14d, eax
jmp short loc_49EE5
loc_49EBC:
mov rdi, rbx
call JS_ThrowTypeErrorNotAnObject
loc_49EC4:
push 6
pop rdx
xor r14d, r14d
jmp short loc_49EE3
loc_49ECC:
lea rsi, aInvalidHint; "invalid hint"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
push 6
pop rdx
loc_49EE3:
xor ecx, ecx
loc_49EE5:
or r14, rcx
mov rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
unsigned long long js_date_Symbol_toPrimitive(
long long a1,
_DWORD *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 v14; // al
long long v15; // rdx
int v16; // eax
int v17; // ebp
long long v18; // rax
unsigned long long v19; // rcx
long long v20; // r14
char v22; // [rsp-8h] [rbp-28h]
v22 = v14;
if ( (_DWORD)a3 != -1 )
{
JS_ThrowTypeErrorNotAnObject(a1, a7, a8, a9, a10, a11, a12, a13, a14, (long long)a2, a3, a4, (long long)a5, a6, v14);
goto LABEL_10;
}
v15 = a5[1];
if ( (_DWORD)v15 != -7 )
{
LABEL_11:
v20 = 0LL;
JS_ThrowTypeError(a1, (long long)"invalid hint", v15, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v22);
goto LABEL_12;
}
v16 = JS_ValueToAtom(a1, *a5, -7);
if ( !v16 )
{
LABEL_10:
v20 = 0LL;
LABEL_12:
v19 = 0LL;
return v19 | v20;
}
v17 = v16;
JS_FreeAtom(a1, v16);
if ( v17 != 22 )
{
a4 = 17LL;
if ( v17 != 71 && v17 != 76 && v17 != 73 )
goto LABEL_11;
}
v18 = JS_ToPrimitive(a1, a2, 0xFFFFFFFF);
v19 = v18 & 0xFFFFFFFF00000000LL;
v20 = (unsigned int)v18;
return v19 | v20;
}
|
js_date_Symbol_toPrimitive:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV RBX,RDI
CMP R14D,-0x1
JNZ 0x00149ebc
MOV RDX,qword ptr [R8 + 0x8]
CMP EDX,-0x7
JNZ 0x00149ecc
MOV R15,RSI
MOV RSI,qword ptr [R8]
MOV RDI,RBX
CALL 0x0011e0bc
TEST EAX,EAX
JZ 0x00149ec4
MOV EBP,EAX
MOV RDI,RBX
MOV ESI,EAX
CALL 0x0011a995
CMP EBP,0x16
JZ 0x00149e99
PUSH 0x11
POP RCX
CMP EBP,0x47
JZ 0x00149e9c
CMP EBP,0x4c
JZ 0x00149e9c
CMP EBP,0x49
JNZ 0x00149ecc
LAB_00149e99:
PUSH 0x10
POP RCX
LAB_00149e9c:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00121846
MOV RCX,-0x100000000
AND RCX,RAX
MOV R14D,EAX
JMP 0x00149ee5
LAB_00149ebc:
MOV RDI,RBX
CALL 0x0011d5e1
LAB_00149ec4:
PUSH 0x6
POP RDX
XOR R14D,R14D
JMP 0x00149ee3
LAB_00149ecc:
LEA RSI,[0x187646]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011c64d
PUSH 0x6
POP RDX
LAB_00149ee3:
XOR ECX,ECX
LAB_00149ee5:
OR R14,RCX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong js_date_Symbol_toPrimitive
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int iVar1;
ulong uVar2;
ulong uVar3;
int8 extraout_RDX;
int8 uVar4;
if ((int)param_3 == -1) {
uVar4 = param_5[1];
if ((int)uVar4 == -7) {
iVar1 = JS_ValueToAtom(param_1,*param_5);
if (iVar1 != 0) {
JS_FreeAtom(param_1,iVar1);
if (iVar1 == 0x16) {
LAB_00149e99:
param_4 = 0x10;
}
else {
param_4 = 0x11;
if ((iVar1 != 0x47) && (iVar1 != 0x4c)) {
uVar4 = extraout_RDX;
if (iVar1 != 0x49) goto LAB_00149ecc;
goto LAB_00149e99;
}
}
uVar2 = JS_ToPrimitive(param_1,param_2,param_3,param_4);
uVar3 = uVar2 & 0xffffffff00000000;
uVar2 = uVar2 & 0xffffffff;
goto LAB_00149ee5;
}
}
else {
LAB_00149ecc:
JS_ThrowTypeError(param_1,"invalid hint",uVar4,param_4);
}
}
else {
JS_ThrowTypeErrorNotAnObject(param_1);
}
uVar2 = 0;
uVar3 = 0;
LAB_00149ee5:
return uVar2 | uVar3;
}
|
|
66,412 |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get()
|
monkey531[P]llama/common/json.hpp
|
char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
token_string.push_back(char_traits<char_type>::to_char_type(current));
}
if (current == '\n')
{
++position.lines_read;
position.chars_read_current_line = 0;
}
return current;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get():
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x1b227
movb $0x0, 0x18(%rbx)
movl 0x14(%rbx), %eax
jmp 0x1b23c
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x1b26f
movzbl (%rcx), %eax
incq %rcx
movq %rcx, (%rbx)
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
je 0x1b26b
leaq 0x38(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0x59424
movl 0x14(%rbx), %eax
cmpl $0xa, %eax
jne 0x1b265
incq 0x30(%rbx)
andq $0x0, 0x28(%rbx)
pushq $0xa
popq %rax
addq $0x10, %rsp
popq %rbx
retq
pushq $-0x1
jmp 0x1b264
pushq $-0x1
popq %rax
jmp 0x1b239
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv:
push rbx
sub rsp, 10h
mov rbx, rdi
movdqu xmm0, xmmword ptr [rdi+20h]
pcmpeqd xmm1, xmm1
psubq xmm0, xmm1
movdqu xmmword ptr [rdi+20h], xmm0
cmp byte ptr [rdi+18h], 1
jnz short loc_1B227
mov byte ptr [rbx+18h], 0
mov eax, [rbx+14h]
jmp short loc_1B23C
loc_1B227:
mov rcx, [rbx]
cmp rcx, [rbx+8]
jz short loc_1B26F
movzx eax, byte ptr [rcx]
inc rcx
mov [rbx], rcx
loc_1B239:
mov [rbx+14h], eax
loc_1B23C:
cmp eax, 0FFFFFFFFh
jz short loc_1B26B
lea rdi, [rbx+38h]
lea rsi, [rsp+18h+var_9]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
mov eax, [rbx+14h]
cmp eax, 0Ah
jnz short loc_1B265
inc qword ptr [rbx+30h]
and qword ptr [rbx+28h], 0
push 0Ah
loc_1B264:
pop rax
loc_1B265:
add rsp, 10h
pop rbx
retn
loc_1B26B:
push 0FFFFFFFFFFFFFFFFh
jmp short loc_1B264
loc_1B26F:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_1B239
|
long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(
__m128i *a1)
{
int v1; // eax
unsigned __int8 *v2; // rcx
long long result; // rax
a1[2] = _mm_sub_epi64(_mm_loadu_si128(a1 + 2), (__m128i)-1LL);
if ( a1[1].m128i_i8[8] == 1 )
{
a1[1].m128i_i8[8] = 0;
v1 = a1[1].m128i_i32[1];
}
else
{
v2 = (unsigned __int8 *)a1->m128i_i64[0];
if ( a1->m128i_i64[0] == a1->m128i_i64[1] )
{
v1 = -1;
}
else
{
v1 = *v2;
a1->m128i_i64[0] = (long long)(v2 + 1);
}
a1[1].m128i_i32[1] = v1;
}
if ( v1 == -1 )
return -1LL;
std::vector<char>::emplace_back<char>(&a1[3].m128i_u64[1]);
result = a1[1].m128i_u32[1];
if ( (_DWORD)result != 10 )
return result;
++a1[3].m128i_i64[0];
a1[2].m128i_i64[1] = 0LL;
return 10LL;
}
|
get:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOVDQU XMM0,xmmword ptr [RDI + 0x20]
PCMPEQD XMM1,XMM1
PSUBQ XMM0,XMM1
MOVDQU xmmword ptr [RDI + 0x20],XMM0
CMP byte ptr [RDI + 0x18],0x1
JNZ 0x0011b227
MOV byte ptr [RBX + 0x18],0x0
MOV EAX,dword ptr [RBX + 0x14]
JMP 0x0011b23c
LAB_0011b227:
MOV RCX,qword ptr [RBX]
CMP RCX,qword ptr [RBX + 0x8]
JZ 0x0011b26f
MOVZX EAX,byte ptr [RCX]
INC RCX
MOV qword ptr [RBX],RCX
LAB_0011b239:
MOV dword ptr [RBX + 0x14],EAX
LAB_0011b23c:
CMP EAX,-0x1
JZ 0x0011b26b
LEA RDI,[RBX + 0x38]
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],AL
CALL 0x00159424
MOV EAX,dword ptr [RBX + 0x14]
CMP EAX,0xa
JNZ 0x0011b265
INC qword ptr [RBX + 0x30]
AND qword ptr [RBX + 0x28],0x0
PUSH 0xa
LAB_0011b264:
POP RAX
LAB_0011b265:
ADD RSP,0x10
POP RBX
RET
LAB_0011b26b:
PUSH -0x1
JMP 0x0011b264
LAB_0011b26f:
PUSH -0x1
POP RAX
JMP 0x0011b239
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::get() */
ulong __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::get(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
byte *pbVar1;
uint uVar2;
ulong uStack_20;
char local_9;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + 1;
*(long *)(this + 0x28) = *(long *)(this + 0x28) + 1;
if (this[0x18] ==
(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x1) {
this[0x18] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x0;
uVar2 = *(uint *)(this + 0x14);
}
else {
pbVar1 = *(byte **)this;
if (pbVar1 == *(byte **)(this + 8)) {
uVar2 = 0xffffffff;
}
else {
uVar2 = (uint)*pbVar1;
*(byte **)this = pbVar1 + 1;
}
*(uint *)(this + 0x14) = uVar2;
}
if (uVar2 == 0xffffffff) {
uStack_20 = 0xffffffffffffffff;
}
else {
local_9 = (char)uVar2;
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),&local_9);
uStack_20 = (ulong)*(uint *)(this + 0x14);
if (*(uint *)(this + 0x14) == 10) {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + 1;
*(int8 *)(this + 0x28) = 0;
uStack_20 = 10;
}
}
return uStack_20;
}
|
|
66,413 |
ma_page_setup
|
eloqsql/storage/maria/ma_page.c
|
void _ma_page_setup(MARIA_PAGE *page, MARIA_HA *info,
const MARIA_KEYDEF *keyinfo, my_off_t pos,
uchar *buff)
{
MARIA_SHARE *share= info->s;
page->info= info;
page->keyinfo= keyinfo;
page->buff= buff;
page->pos= pos;
page->size= _ma_get_page_used(share, buff);
page->org_size= page->size;
page->flag= _ma_get_keypage_flag(share, buff);
page->node= ((page->flag & KEYPAGE_FLAG_ISNOD) ?
share->base.key_reflength : 0);
}
|
O0
|
c
|
ma_page_setup:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movl 0x744(%rcx), %ecx
movzbl -0x1(%rax,%rcx), %eax
movzwl %ax, %eax
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movl 0x744(%rdx), %edx
movzbl -0x2(%rcx,%rdx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movl 0x744(%rcx), %ecx
subl $0x2, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6ee3a
movq -0x30(%rbp), %rax
movl 0x3e4(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x6ee41
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x6ee41
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
|
_ma_page_setup:
push rbp
mov rbp, rsp
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 rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_30], rax
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax+18h], rcx
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
mov ecx, [rcx+744h]
movzx eax, byte ptr [rax+rcx-1]
movzx eax, ax
mov rcx, [rbp+var_28]
mov rdx, [rbp+var_30]
mov edx, [rdx+744h]
movzx ecx, byte ptr [rcx+rdx-2]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx ecx, ax
mov rax, [rbp+var_8]
mov [rax+20h], ecx
mov rax, [rbp+var_8]
mov ecx, [rax+20h]
mov rax, [rbp+var_8]
mov [rax+24h], ecx
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
mov ecx, [rcx+744h]
sub ecx, 2
sub ecx, 1
mov ecx, ecx
movzx ecx, byte ptr [rax+rcx]
mov rax, [rbp+var_8]
mov [rax+2Ch], ecx
mov rax, [rbp+var_8]
mov eax, [rax+2Ch]
and eax, 1
cmp eax, 0
jz short loc_6EE3A
mov rax, [rbp+var_30]
mov eax, [rax+3E4h]
mov [rbp+var_34], eax
jmp short loc_6EE41
loc_6EE3A:
xor eax, eax
mov [rbp+var_34], eax
jmp short $+2
loc_6EE41:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_8]
mov [rax+28h], ecx
pop rbp
retn
|
long long ma_page_setup(long long a1, long long *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
int v6; // [rsp+0h] [rbp-34h]
long long v7; // [rsp+4h] [rbp-30h]
v7 = *a2;
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 8) = a3;
*(_QWORD *)(a1 + 16) = a5;
*(_QWORD *)(a1 + 24) = a4;
*(_DWORD *)(a1 + 32) = _byteswap_ushort(*(_WORD *)(a5 + *(unsigned int *)(v7 + 1860) - 2));
*(_DWORD *)(a1 + 36) = *(_DWORD *)(a1 + 32);
*(_DWORD *)(a1 + 44) = *(unsigned __int8 *)(a5 + (unsigned int)(*(_DWORD *)(v7 + 1860) - 3));
if ( (*(_DWORD *)(a1 + 44) & 1) != 0 )
v6 = *(_DWORD *)(v7 + 996);
else
v6 = 0;
result = a1;
*(_DWORD *)(a1 + 40) = v6;
return result;
}
|
_ma_page_setup:
PUSH RBP
MOV RBP,RSP
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 RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RCX + 0x744]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + -0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RDX + 0x744]
MOVZX ECX,byte ptr [RCX + RDX*0x1 + -0x2]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX ECX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x20],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x24],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RCX + 0x744]
SUB ECX,0x2
SUB ECX,0x1
MOV ECX,ECX
MOVZX ECX,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x2c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0016ee3a
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x3e4]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0016ee41
LAB_0016ee3a:
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0016ee41
LAB_0016ee41:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],ECX
POP RBP
RET
|
void _ma_page_setup(int8 *param_1,long *param_2,int8 param_3,int8 param_4,
long param_5)
{
long lVar1;
int4 local_3c;
lVar1 = *param_2;
*param_1 = param_2;
param_1[1] = param_3;
param_1[2] = param_5;
param_1[3] = param_4;
*(uint *)(param_1 + 4) =
(uint)CONCAT11(*(int1 *)(param_5 + -2 + (ulong)*(uint *)(lVar1 + 0x744)),
*(int1 *)(param_5 + -1 + (ulong)*(uint *)(lVar1 + 0x744)));
*(int4 *)((long)param_1 + 0x24) = *(int4 *)(param_1 + 4);
*(uint *)((long)param_1 + 0x2c) = (uint)*(byte *)(param_5 + (ulong)(*(int *)(lVar1 + 0x744) - 3));
if ((*(uint *)((long)param_1 + 0x2c) & 1) == 0) {
local_3c = 0;
}
else {
local_3c = *(int4 *)(lVar1 + 0x3e4);
}
*(int4 *)(param_1 + 5) = local_3c;
return;
}
|
|
66,414 |
ResnetBlock::forward(ggml_context*, ggml_tensor*)
|
7CodeWizard[P]stablediffusion/vae.hpp
|
struct ggml_tensor* forward(struct ggml_context* ctx, struct ggml_tensor* z) {
// z: [N, in_channels, h, w]
auto h = ggml_nn_group_norm(ctx, z, norm1_w, norm1_b);
h = ggml_silu_inplace(ctx, h);
h = ggml_nn_conv_2d(ctx, h, conv1_w, conv1_b, 1, 1, 1, 1); // [N, out_channels, h, w]
h = ggml_nn_group_norm(ctx, h, norm2_w, norm2_b);
h = ggml_silu_inplace(ctx, h);
// dropout, skip for inference
h = ggml_nn_conv_2d(ctx, h, conv2_w, conv2_b, 1, 1, 1, 1); // [N, out_channels, h, w]
// skip connection
if (out_channels != in_channels) {
z = ggml_nn_conv_2d(ctx, z, nin_shortcut_w, nin_shortcut_b); // [N, out_channels, h, w]
}
h = ggml_add(ctx, h, z);
return h; // [N, out_channels, h, w]
}
|
O0
|
cpp
|
ResnetBlock::forward(ggml_context*, ggml_tensor*):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movl $0x20, %r8d
callq 0x36290
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x120ba0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x361c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x28(%rax), %rdx
movq 0x30(%rax), %rcx
movl $0x20, %r8d
callq 0x36290
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x120ba0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rax), %rdx
movq 0x40(%rax), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x361c0
movq 0x20(%rsp), %rcx
movq %rax, 0x28(%rsp)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
je 0x85bc0
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x48(%rax), %rdx
movq 0x50(%rax), %rcx
movl $0x1, %r9d
xorl %eax, %eax
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x361c0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x11ea50
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN11ResnetBlock7forwardEP12ggml_contextP11ggml_tensor:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_18], rdx
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_28], rax
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_18]
mov rdx, [rax+8]
mov rcx, [rax+10h]
mov r8d, 20h ; ' '
call _ZL18ggml_nn_group_normP12ggml_contextP11ggml_tensorS2_S2_i; ggml_nn_group_norm(ggml_context *,ggml_tensor *,ggml_tensor *,ggml_tensor *,int)
mov [rsp+48h+var_20], rax
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_20]
call ggml_silu_inplace
mov rcx, rax
mov rax, [rsp+48h+var_28]
mov [rsp+48h+var_20], rcx
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_20]
mov rdx, [rax+18h]
mov rcx, [rax+20h]
mov r9d, 1
mov r8d, r9d
mov [rsp+48h+var_48], 1
mov [rsp+48h+var_40], 1
mov [rsp+48h+var_38], 1
mov [rsp+48h+var_30], 1
call _ZL15ggml_nn_conv_2dP12ggml_contextP11ggml_tensorS2_S2_iiiiii; ggml_nn_conv_2d(ggml_context *,ggml_tensor *,ggml_tensor *,ggml_tensor *,int,int,int,int,int,int)
mov rcx, rax
mov rax, [rsp+48h+var_28]
mov [rsp+48h+var_20], rcx
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_20]
mov rdx, [rax+28h]
mov rcx, [rax+30h]
mov r8d, 20h ; ' '
call _ZL18ggml_nn_group_normP12ggml_contextP11ggml_tensorS2_S2_i; ggml_nn_group_norm(ggml_context *,ggml_tensor *,ggml_tensor *,ggml_tensor *,int)
mov [rsp+48h+var_20], rax
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_20]
call ggml_silu_inplace
mov rcx, rax
mov rax, [rsp+48h+var_28]
mov [rsp+48h+var_20], rcx
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_20]
mov rdx, [rax+38h]
mov rcx, [rax+40h]
mov r9d, 1
mov r8d, r9d
mov [rsp+48h+var_48], 1
mov [rsp+48h+var_40], 1
mov [rsp+48h+var_38], 1
mov [rsp+48h+var_30], 1
call _ZL15ggml_nn_conv_2dP12ggml_contextP11ggml_tensorS2_S2_iiiiii; ggml_nn_conv_2d(ggml_context *,ggml_tensor *,ggml_tensor *,ggml_tensor *,int,int,int,int,int,int)
mov rcx, [rsp+48h+var_28]
mov [rsp+48h+var_20], rax
mov eax, [rcx+4]
cmp eax, [rcx]
jz short loc_85BC0
mov rax, [rsp+48h+var_28]
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_18]
mov rdx, [rax+48h]
mov rcx, [rax+50h]
mov r9d, 1
xor eax, eax
mov r8d, r9d
mov [rsp+48h+var_48], 0
mov [rsp+48h+var_40], 0
mov [rsp+48h+var_38], 1
mov [rsp+48h+var_30], 1
call _ZL15ggml_nn_conv_2dP12ggml_contextP11ggml_tensorS2_S2_iiiiii; ggml_nn_conv_2d(ggml_context *,ggml_tensor *,ggml_tensor *,ggml_tensor *,int,int,int,int,int,int)
mov [rsp+48h+var_18], rax
loc_85BC0:
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_20]
mov rdx, [rsp+48h+var_18]
call ggml_add
mov [rsp+48h+var_20], rax
mov rax, [rsp+48h+var_20]
add rsp, 48h
retn
|
long long ResnetBlock::forward(long long a1, long long a2, long long a3)
{
long long v3; // rax
int v4; // eax
long long v5; // rax
long long v6; // rax
int v7; // eax
long long v10; // [rsp+28h] [rbp-20h]
long long v11; // [rsp+30h] [rbp-18h]
v11 = a3;
v3 = ggml_nn_group_norm(a2, a3, *(_QWORD *)(a1 + 8), *(_QWORD *)(a1 + 16), 0x20u);
v4 = ggml_silu_inplace(a2, v3);
v5 = ggml_nn_conv_2d(a2, v4, *(_QWORD *)(a1 + 24), *(_QWORD *)(a1 + 32), 1, 1, 1, 1, 1, 1);
v6 = ggml_nn_group_norm(a2, v5, *(_QWORD *)(a1 + 40), *(_QWORD *)(a1 + 48), 0x20u);
v7 = ggml_silu_inplace(a2, v6);
v10 = ggml_nn_conv_2d(a2, v7, *(_QWORD *)(a1 + 56), *(_QWORD *)(a1 + 64), 1, 1, 1, 1, 1, 1);
if ( *(_DWORD *)(a1 + 4) != *(_DWORD *)a1 )
v11 = ggml_nn_conv_2d(a2, v11, *(_QWORD *)(a1 + 72), *(_QWORD *)(a1 + 80), 1, 1, 0, 0, 1, 1);
return ggml_add(a2, v10, v11);
}
|
forward:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x10]
MOV R8D,0x20
CALL 0x00136290
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00220ba0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x28],RCX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RAX + 0x20]
MOV R9D,0x1
MOV R8D,R9D
MOV dword ptr [RSP],0x1
MOV dword ptr [RSP + 0x8],0x1
MOV dword ptr [RSP + 0x10],0x1
MOV dword ptr [RSP + 0x18],0x1
CALL 0x001361c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x28],RCX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RAX + 0x30]
MOV R8D,0x20
CALL 0x00136290
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00220ba0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x28],RCX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RAX + 0x40]
MOV R9D,0x1
MOV R8D,R9D
MOV dword ptr [RSP],0x1
MOV dword ptr [RSP + 0x8],0x1
MOV dword ptr [RSP + 0x10],0x1
MOV dword ptr [RSP + 0x18],0x1
CALL 0x001361c0
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x28],RAX
MOV EAX,dword ptr [RCX + 0x4]
CMP EAX,dword ptr [RCX]
JZ 0x00185bc0
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RAX + 0x48]
MOV RCX,qword ptr [RAX + 0x50]
MOV R9D,0x1
XOR EAX,EAX
MOV R8D,R9D
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
MOV dword ptr [RSP + 0x10],0x1
MOV dword ptr [RSP + 0x18],0x1
CALL 0x001361c0
MOV qword ptr [RSP + 0x30],RAX
LAB_00185bc0:
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x0021ea50
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x28]
ADD RSP,0x48
RET
|
/* ResnetBlock::forward(ggml_context*, ggml_tensor*) */
int8 __thiscall
ResnetBlock::forward(ResnetBlock *this,ggml_context *param_1,ggml_tensor *param_2)
{
int8 uVar1;
ggml_tensor *pgVar2;
ggml_tensor *local_18;
uVar1 = ggml_nn_group_norm(param_1,param_2,*(ggml_tensor **)(this + 8),
*(ggml_tensor **)(this + 0x10),0x20);
pgVar2 = (ggml_tensor *)ggml_silu_inplace(param_1,uVar1);
pgVar2 = (ggml_tensor *)
ggml_nn_conv_2d(param_1,pgVar2,*(ggml_tensor **)(this + 0x18),
*(ggml_tensor **)(this + 0x20),1,1,1,1,1,1);
uVar1 = ggml_nn_group_norm(param_1,pgVar2,*(ggml_tensor **)(this + 0x28),
*(ggml_tensor **)(this + 0x30),0x20);
pgVar2 = (ggml_tensor *)ggml_silu_inplace(param_1,uVar1);
uVar1 = ggml_nn_conv_2d(param_1,pgVar2,*(ggml_tensor **)(this + 0x38),
*(ggml_tensor **)(this + 0x40),1,1,1,1,1,1);
local_18 = param_2;
if (*(int *)(this + 4) != *(int *)this) {
local_18 = (ggml_tensor *)
ggml_nn_conv_2d(param_1,param_2,*(ggml_tensor **)(this + 0x48),
*(ggml_tensor **)(this + 0x50),1,1,0,0,1,1);
}
uVar1 = ggml_add(param_1,uVar1,local_18);
return uVar1;
}
|
|
66,415 |
ResnetBlock::forward(ggml_context*, ggml_tensor*)
|
7CodeWizard[P]stablediffusion/vae.hpp
|
struct ggml_tensor* forward(struct ggml_context* ctx, struct ggml_tensor* z) {
// z: [N, in_channels, h, w]
auto h = ggml_nn_group_norm(ctx, z, norm1_w, norm1_b);
h = ggml_silu_inplace(ctx, h);
h = ggml_nn_conv_2d(ctx, h, conv1_w, conv1_b, 1, 1, 1, 1); // [N, out_channels, h, w]
h = ggml_nn_group_norm(ctx, h, norm2_w, norm2_b);
h = ggml_silu_inplace(ctx, h);
// dropout, skip for inference
h = ggml_nn_conv_2d(ctx, h, conv2_w, conv2_b, 1, 1, 1, 1); // [N, out_channels, h, w]
// skip connection
if (out_channels != in_channels) {
z = ggml_nn_conv_2d(ctx, z, nin_shortcut_w, nin_shortcut_b); // [N, out_channels, h, w]
}
h = ggml_add(ctx, h, z);
return h; // [N, out_channels, h, w]
}
|
O1
|
cpp
|
ResnetBlock::forward(ggml_context*, ggml_tensor*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %r12
movq %rdx, %rdi
callq 0x8e2c1
cmpl $0x3, %eax
jl 0x54814
movq 0x10(%r13), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x93083
movq %rax, %r13
movq 0x10(%r12), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x93083
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movl $0x20, %edx
callq 0x92281
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x912d2
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x90c8a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x91f1f
movq 0x18(%r15), %rsi
movq 0x20(%r15), %r13
subq $0x8, %rsp
movl $0x1, %r10d
movq %rbx, %rdi
movq %rax, %rdx
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq %r10
pushq %r10
pushq %r10
callq 0x9447a
addq $0x20, %rsp
movq %rax, %r12
testq %r13, %r13
je 0x548bb
movq 0x10(%r13), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x93083
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x90c8a
movq %rax, %r12
movq 0x28(%r15), %rbp
movq 0x30(%r15), %r13
movq %r12, %rdi
callq 0x8e2c1
cmpl $0x3, %eax
jl 0x54914
movq 0x10(%rbp), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x93083
movq %rax, %rbp
movq 0x10(%r13), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x93083
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
movl $0x20, %edx
callq 0x92281
movq %rbx, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x912d2
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x90c8a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x91f1f
movq 0x38(%r15), %rsi
movq 0x40(%r15), %r13
subq $0x8, %rsp
movl $0x1, %r10d
movq %rbx, %rdi
movq %rax, %rdx
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq %r10
pushq %r10
pushq %r10
callq 0x9447a
addq $0x20, %rsp
movq %rax, %r12
testq %r13, %r13
je 0x549bb
movq 0x10(%r13), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x93083
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x90c8a
movq %rax, %r12
movl 0x4(%r15), %eax
cmpl (%r15), %eax
je 0x54a2e
movq 0x48(%r15), %rsi
movq 0x50(%r15), %r15
subq $0x8, %rsp
movl $0x1, %eax
movq %rbx, %rdi
movq %r14, %rdx
movl $0x1, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq $0x0
callq 0x9447a
addq $0x20, %rsp
movq %rax, %r14
testq %r15, %r15
je 0x54a2e
movq 0x10(%r15), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x93083
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x90c8a
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x90c8a
|
_ZN11ResnetBlock7forwardEP12ggml_contextP11ggml_tensor:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov r13, [rdi+8]
mov r12, [rdi+10h]
mov rdi, rdx
call ggml_n_dims
cmp eax, 3
jl short loc_54814
mov r8, [r13+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r13
call ggml_reshape_4d
mov r13, rax
mov r8, [r12+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r12
call ggml_reshape_4d
mov r12, rax
loc_54814:
mov rdi, rbx
mov rsi, r14
mov edx, 20h ; ' '
call ggml_group_norm
mov rdi, rbx
mov rsi, rax
mov rdx, r13
call ggml_mul
mov rdi, rbx
mov rsi, rax
mov rdx, r12
call ggml_add
mov rdi, rbx
mov rsi, rax
call ggml_silu_inplace
mov rsi, [r15+18h]
mov r13, [r15+20h]
sub rsp, 8
mov r10d, 1
mov rdi, rbx
mov rdx, rax
mov ecx, 1
mov r8d, 1
mov r9d, 1
push r10
push r10
push r10
call ggml_conv_2d
add rsp, 20h
mov r12, rax
test r13, r13
jz short loc_548BB
mov r8, [r13+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r13
call ggml_reshape_4d
mov rdi, rbx
mov rsi, r12
mov rdx, rax
call ggml_add
mov r12, rax
loc_548BB:
mov rbp, [r15+28h]
mov r13, [r15+30h]
mov rdi, r12
call ggml_n_dims
cmp eax, 3
jl short loc_54914
mov r8, [rbp+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, rbp
call ggml_reshape_4d
mov rbp, rax
mov r8, [r13+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r13
call ggml_reshape_4d
mov r13, rax
loc_54914:
mov rdi, rbx
mov rsi, r12
mov edx, 20h ; ' '
call ggml_group_norm
mov rdi, rbx
mov rsi, rax
mov rdx, rbp
call ggml_mul
mov rdi, rbx
mov rsi, rax
mov rdx, r13
call ggml_add
mov rdi, rbx
mov rsi, rax
call ggml_silu_inplace
mov rsi, [r15+38h]
mov r13, [r15+40h]
sub rsp, 8
mov r10d, 1
mov rdi, rbx
mov rdx, rax
mov ecx, 1
mov r8d, 1
mov r9d, 1
push r10
push r10
push r10
call ggml_conv_2d
add rsp, 20h
mov r12, rax
test r13, r13
jz short loc_549BB
mov r8, [r13+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r13
call ggml_reshape_4d
mov rdi, rbx
mov rsi, r12
mov rdx, rax
call ggml_add
mov r12, rax
loc_549BB:
mov eax, [r15+4]
cmp eax, [r15]
jz short loc_54A2E
mov rsi, [r15+48h]
mov r15, [r15+50h]
sub rsp, 8
mov eax, 1
mov rdi, rbx
mov rdx, r14
mov ecx, 1
mov r8d, 1
xor r9d, r9d
push rax
push rax
push 0
call ggml_conv_2d
add rsp, 20h
mov r14, rax
test r15, r15
jz short loc_54A2E
mov r8, [r15+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r15
call ggml_reshape_4d
mov rdi, rbx
mov rsi, r14
mov rdx, rax
call ggml_add
mov r14, rax
loc_54A2E:
mov rdi, rbx
mov rsi, r12
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp ggml_add
|
long long ResnetBlock::forward(long long a1, long long a2, long long a3)
{
long long v3; // r14
long long v4; // r13
long long v5; // r12
long long v6; // rax
long long v7; // rax
long long v8; // rax
int v9; // eax
long long v10; // r13
long long v11; // r12
long long v12; // rax
long long v13; // rbp
long long v14; // r13
long long v15; // rax
long long v16; // rax
long long v17; // rax
int v18; // eax
long long v19; // r13
long long v20; // r12
long long v21; // rax
long long v22; // r15
long long v23; // rax
v3 = a3;
v4 = *(_QWORD *)(a1 + 8);
v5 = *(_QWORD *)(a1 + 16);
if ( (int)ggml_n_dims(a3) >= 3 )
{
v4 = ggml_reshape_4d(a2, v4, 1LL, 1LL, *(_QWORD *)(v4 + 16), 1LL);
v5 = ggml_reshape_4d(a2, v5, 1LL, 1LL, *(_QWORD *)(v5 + 16), 1LL);
}
v6 = ggml_group_norm(a2, v3, 32LL);
v7 = ggml_mul(a2, v6, v4);
v8 = ggml_add(a2, v7, v5);
v9 = ggml_silu_inplace(a2, v8);
v10 = *(_QWORD *)(a1 + 32);
v11 = ggml_conv_2d(a2, *(_QWORD *)(a1 + 24), v9, 1, 1, 1, 1, 1, 1);
if ( v10 )
{
v12 = ggml_reshape_4d(a2, v10, 1LL, 1LL, *(_QWORD *)(v10 + 16), 1LL);
v11 = ggml_add(a2, v11, v12);
}
v13 = *(_QWORD *)(a1 + 40);
v14 = *(_QWORD *)(a1 + 48);
if ( (int)ggml_n_dims(v11) >= 3 )
{
v13 = ggml_reshape_4d(a2, v13, 1LL, 1LL, *(_QWORD *)(v13 + 16), 1LL);
v14 = ggml_reshape_4d(a2, v14, 1LL, 1LL, *(_QWORD *)(v14 + 16), 1LL);
}
v15 = ggml_group_norm(a2, v11, 32LL);
v16 = ggml_mul(a2, v15, v13);
v17 = ggml_add(a2, v16, v14);
v18 = ggml_silu_inplace(a2, v17);
v19 = *(_QWORD *)(a1 + 64);
v20 = ggml_conv_2d(a2, *(_QWORD *)(a1 + 56), v18, 1, 1, 1, 1, 1, 1);
if ( v19 )
{
v21 = ggml_reshape_4d(a2, v19, 1LL, 1LL, *(_QWORD *)(v19 + 16), 1LL);
v20 = ggml_add(a2, v20, v21);
}
if ( *(_DWORD *)(a1 + 4) != *(_DWORD *)a1 )
{
v22 = *(_QWORD *)(a1 + 80);
v3 = ggml_conv_2d(a2, *(_QWORD *)(a1 + 72), v3, 1, 1, 0, 0, 1, 1);
if ( v22 )
{
v23 = ggml_reshape_4d(a2, v22, 1LL, 1LL, *(_QWORD *)(v22 + 16), 1LL);
v3 = ggml_add(a2, v3, v23);
}
}
return ggml_add(a2, v20, v3);
}
| |||
66,416 |
ResnetBlock::forward(ggml_context*, ggml_tensor*)
|
7CodeWizard[P]stablediffusion/vae.hpp
|
struct ggml_tensor* forward(struct ggml_context* ctx, struct ggml_tensor* z) {
// z: [N, in_channels, h, w]
auto h = ggml_nn_group_norm(ctx, z, norm1_w, norm1_b);
h = ggml_silu_inplace(ctx, h);
h = ggml_nn_conv_2d(ctx, h, conv1_w, conv1_b, 1, 1, 1, 1); // [N, out_channels, h, w]
h = ggml_nn_group_norm(ctx, h, norm2_w, norm2_b);
h = ggml_silu_inplace(ctx, h);
// dropout, skip for inference
h = ggml_nn_conv_2d(ctx, h, conv2_w, conv2_b, 1, 1, 1, 1); // [N, out_channels, h, w]
// skip connection
if (out_channels != in_channels) {
z = ggml_nn_conv_2d(ctx, z, nin_shortcut_w, nin_shortcut_b); // [N, out_channels, h, w]
}
h = ggml_add(ctx, h, z);
return h; // [N, out_channels, h, w]
}
|
O2
|
cpp
|
ResnetBlock::forward(ggml_context*, ggml_tensor*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x1cf13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6abb8
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
pushq $0x1
popq %r12
movq %rbx, %rdi
movq %rax, %rsi
movl %r12d, %r8d
movl %r12d, %r9d
pushq %r12
pushq %r12
callq 0x1ce99
addq $0x10, %rsp
movq 0x28(%r15), %rdx
movq 0x30(%r15), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1cf13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6abb8
movq 0x38(%r15), %rdx
movq 0x40(%r15), %rcx
movq %rbx, %rdi
movq %rax, %rsi
movl %r12d, %r8d
movl %r12d, %r9d
pushq %r12
pushq %r12
callq 0x1ce99
popq %rcx
popq %rdx
movq %rax, %r12
movl 0x4(%r15), %eax
cmpl (%r15), %eax
je 0x36e0a
movq 0x48(%r15), %rdx
movq 0x50(%r15), %rcx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
movl %r8d, %r9d
pushq $0x0
pushq $0x0
callq 0x1ce99
popq %rcx
popq %rdx
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x69a53
nop
|
_ZN11ResnetBlock7forwardEP12ggml_contextP11ggml_tensor:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rdx, [rdi+8]
mov rcx, [rdi+10h]
mov rdi, rsi
mov rsi, r14
call _ZL18ggml_nn_group_normP12ggml_contextP11ggml_tensorS2_S2_i; ggml_nn_group_norm(ggml_context *,ggml_tensor *,ggml_tensor *,ggml_tensor *,int)
mov rdi, rbx
mov rsi, rax
call ggml_silu_inplace
mov rdx, [r15+18h]
mov rcx, [r15+20h]
push 1
pop r12
mov rdi, rbx
mov rsi, rax
mov r8d, r12d
mov r9d, r12d
push r12
push r12
call _ZL15ggml_nn_conv_2dP12ggml_contextP11ggml_tensorS2_S2_iiiiii; ggml_nn_conv_2d(ggml_context *,ggml_tensor *,ggml_tensor *,ggml_tensor *,int,int,int,int,int,int)
add rsp, 10h
mov rdx, [r15+28h]
mov rcx, [r15+30h]
mov rdi, rbx
mov rsi, rax
call _ZL18ggml_nn_group_normP12ggml_contextP11ggml_tensorS2_S2_i; ggml_nn_group_norm(ggml_context *,ggml_tensor *,ggml_tensor *,ggml_tensor *,int)
mov rdi, rbx
mov rsi, rax
call ggml_silu_inplace
mov rdx, [r15+38h]
mov rcx, [r15+40h]
mov rdi, rbx
mov rsi, rax
mov r8d, r12d
mov r9d, r12d
push r12
push r12
call _ZL15ggml_nn_conv_2dP12ggml_contextP11ggml_tensorS2_S2_iiiiii; ggml_nn_conv_2d(ggml_context *,ggml_tensor *,ggml_tensor *,ggml_tensor *,int,int,int,int,int,int)
pop rcx
pop rdx
mov r12, rax
mov eax, [r15+4]
cmp eax, [r15]
jz short loc_36E0A
mov rdx, [r15+48h]
mov rcx, [r15+50h]
push 1
pop r8
mov rdi, rbx
mov rsi, r14
mov r9d, r8d
push 0
push 0
call _ZL15ggml_nn_conv_2dP12ggml_contextP11ggml_tensorS2_S2_iiiiii; ggml_nn_conv_2d(ggml_context *,ggml_tensor *,ggml_tensor *,ggml_tensor *,int,int,int,int,int,int)
pop rcx
pop rdx
mov r14, rax
loc_36E0A:
mov rdi, rbx
mov rsi, r12
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp ggml_add
|
long long ResnetBlock::forward(long long a1, long long a2, long long a3)
{
long long v3; // r14
long long v5; // rax
int v6; // eax
long long v7; // rax
long long v8; // rax
int v9; // eax
long long v10; // r12
v3 = a3;
v5 = ggml_nn_group_norm(a2, a3, *(_QWORD *)(a1 + 8), *(_QWORD *)(a1 + 16));
v6 = ggml_silu_inplace(a2, v5);
v7 = ggml_nn_conv_2d(a2, v6, *(_QWORD *)(a1 + 24), *(_QWORD *)(a1 + 32), 1, 1, 1, 1);
v8 = ggml_nn_group_norm(a2, v7, *(_QWORD *)(a1 + 40), *(_QWORD *)(a1 + 48));
v9 = ggml_silu_inplace(a2, v8);
v10 = ggml_nn_conv_2d(a2, v9, *(_QWORD *)(a1 + 56), *(_QWORD *)(a1 + 64), 1, 1, 1, 1);
if ( *(_DWORD *)(a1 + 4) != *(_DWORD *)a1 )
v3 = ggml_nn_conv_2d(a2, v3, *(_QWORD *)(a1 + 72), *(_QWORD *)(a1 + 80), 1, 1, 0, 0);
return ggml_add(a2, v10, v3);
}
|
forward:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RDX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI + 0x10]
MOV RDI,RSI
MOV RSI,R14
CALL 0x0011cf13
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0016abb8
MOV RDX,qword ptr [R15 + 0x18]
MOV RCX,qword ptr [R15 + 0x20]
PUSH 0x1
POP R12
MOV RDI,RBX
MOV RSI,RAX
MOV R8D,R12D
MOV R9D,R12D
PUSH R12
PUSH R12
CALL 0x0011ce99
ADD RSP,0x10
MOV RDX,qword ptr [R15 + 0x28]
MOV RCX,qword ptr [R15 + 0x30]
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011cf13
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0016abb8
MOV RDX,qword ptr [R15 + 0x38]
MOV RCX,qword ptr [R15 + 0x40]
MOV RDI,RBX
MOV RSI,RAX
MOV R8D,R12D
MOV R9D,R12D
PUSH R12
PUSH R12
CALL 0x0011ce99
POP RCX
POP RDX
MOV R12,RAX
MOV EAX,dword ptr [R15 + 0x4]
CMP EAX,dword ptr [R15]
JZ 0x00136e0a
MOV RDX,qword ptr [R15 + 0x48]
MOV RCX,qword ptr [R15 + 0x50]
PUSH 0x1
POP R8
MOV RDI,RBX
MOV RSI,R14
MOV R9D,R8D
PUSH 0x0
PUSH 0x0
CALL 0x0011ce99
POP RCX
POP RDX
MOV R14,RAX
LAB_00136e0a:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00169a53
|
/* ResnetBlock::forward(ggml_context*, ggml_tensor*) */
void ResnetBlock::forward(ggml_context *param_1,ggml_tensor *param_2)
{
int in_EAX;
int8 uVar1;
ggml_tensor *pgVar2;
ggml_tensor *in_RDX;
int unaff_EBX;
int in_R8D;
int iVar3;
int8 uVar4;
uVar1 = ggml_nn_group_norm((ggml_context *)param_2,in_RDX,*(ggml_tensor **)(param_1 + 8),
*(ggml_tensor **)(param_1 + 0x10),in_R8D);
pgVar2 = (ggml_tensor *)ggml_silu_inplace(param_2,uVar1);
iVar3 = 1;
pgVar2 = (ggml_tensor *)
ggml_nn_conv_2d((ggml_context *)param_2,pgVar2,*(ggml_tensor **)(param_1 + 0x18),
*(ggml_tensor **)(param_1 + 0x20),1,1,1,1,in_EAX,unaff_EBX);
uVar1 = ggml_nn_group_norm((ggml_context *)param_2,pgVar2,*(ggml_tensor **)(param_1 + 0x28),
*(ggml_tensor **)(param_1 + 0x30),iVar3);
pgVar2 = (ggml_tensor *)ggml_silu_inplace(param_2,uVar1);
uVar4 = 1;
uVar1 = ggml_nn_conv_2d((ggml_context *)param_2,pgVar2,*(ggml_tensor **)(param_1 + 0x38),
*(ggml_tensor **)(param_1 + 0x40),1,1,1,1,in_EAX,unaff_EBX);
if (*(int *)(param_1 + 4) != *(int *)param_1) {
uVar4 = 0;
in_RDX = (ggml_tensor *)
ggml_nn_conv_2d((ggml_context *)param_2,in_RDX,*(ggml_tensor **)(param_1 + 0x48),
*(ggml_tensor **)(param_1 + 0x50),1,1,0,0,in_EAX,unaff_EBX);
}
ggml_add(param_2,uVar1,in_RDX,uVar4);
return;
}
|
|
66,417 |
ResnetBlock::forward(ggml_context*, ggml_tensor*)
|
7CodeWizard[P]stablediffusion/vae.hpp
|
struct ggml_tensor* forward(struct ggml_context* ctx, struct ggml_tensor* z) {
// z: [N, in_channels, h, w]
auto h = ggml_nn_group_norm(ctx, z, norm1_w, norm1_b);
h = ggml_silu_inplace(ctx, h);
h = ggml_nn_conv_2d(ctx, h, conv1_w, conv1_b, 1, 1, 1, 1); // [N, out_channels, h, w]
h = ggml_nn_group_norm(ctx, h, norm2_w, norm2_b);
h = ggml_silu_inplace(ctx, h);
// dropout, skip for inference
h = ggml_nn_conv_2d(ctx, h, conv2_w, conv2_b, 1, 1, 1, 1); // [N, out_channels, h, w]
// skip connection
if (out_channels != in_channels) {
z = ggml_nn_conv_2d(ctx, z, nin_shortcut_w, nin_shortcut_b); // [N, out_channels, h, w]
}
h = ggml_add(ctx, h, z);
return h; // [N, out_channels, h, w]
}
|
O3
|
cpp
|
ResnetBlock::forward(ggml_context*, ggml_tensor*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %r12
movq %rdx, %rdi
callq 0x8d052
cmpl $0x3, %eax
jl 0x53d4a
movq 0x10(%r13), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x91eef
movq %rax, %r13
movq 0x10(%r12), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x91eef
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movl $0x20, %edx
callq 0x910e3
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x900ae
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x8f9f3
movq %rbx, %rdi
movq %rax, %rsi
callq 0x90d56
movq 0x18(%r15), %rsi
movq 0x20(%r15), %r13
subq $0x8, %rsp
movl $0x1, %r10d
movq %rbx, %rdi
movq %rax, %rdx
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq %r10
pushq %r10
pushq %r10
callq 0x932c7
addq $0x20, %rsp
movq %rax, %r12
testq %r13, %r13
je 0x53df1
movq 0x10(%r13), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x91eef
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x8f9f3
movq %rax, %r12
movq 0x28(%r15), %rbp
movq 0x30(%r15), %r13
movq %r12, %rdi
callq 0x8d052
cmpl $0x3, %eax
jl 0x53e4a
movq 0x10(%rbp), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x91eef
movq %rax, %rbp
movq 0x10(%r13), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x91eef
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
movl $0x20, %edx
callq 0x910e3
movq %rbx, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x900ae
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x8f9f3
movq %rbx, %rdi
movq %rax, %rsi
callq 0x90d56
movq 0x38(%r15), %rsi
movq 0x40(%r15), %r13
subq $0x8, %rsp
movl $0x1, %r10d
movq %rbx, %rdi
movq %rax, %rdx
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq %r10
pushq %r10
pushq %r10
callq 0x932c7
addq $0x20, %rsp
movq %rax, %r12
testq %r13, %r13
je 0x53ef1
movq 0x10(%r13), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x91eef
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x8f9f3
movq %rax, %r12
movl 0x4(%r15), %eax
cmpl (%r15), %eax
je 0x53f64
movq 0x48(%r15), %rsi
movq 0x50(%r15), %r15
subq $0x8, %rsp
movl $0x1, %eax
movq %rbx, %rdi
movq %r14, %rdx
movl $0x1, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq $0x0
callq 0x932c7
addq $0x20, %rsp
movq %rax, %r14
testq %r15, %r15
je 0x53f64
movq 0x10(%r15), %r8
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x91eef
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8f9f3
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8f9f3
|
_ZN11ResnetBlock7forwardEP12ggml_contextP11ggml_tensor:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov r13, [rdi+8]
mov r12, [rdi+10h]
mov rdi, rdx
call ggml_n_dims
cmp eax, 3
jl short loc_53D4A
mov r8, [r13+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r13
call ggml_reshape_4d
mov r13, rax
mov r8, [r12+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r12
call ggml_reshape_4d
mov r12, rax
loc_53D4A:
mov rdi, rbx
mov rsi, r14
mov edx, 20h ; ' '
call ggml_group_norm
mov rdi, rbx
mov rsi, rax
mov rdx, r13
call ggml_mul
mov rdi, rbx
mov rsi, rax
mov rdx, r12
call ggml_add
mov rdi, rbx
mov rsi, rax
call ggml_silu_inplace
mov rsi, [r15+18h]
mov r13, [r15+20h]
sub rsp, 8
mov r10d, 1
mov rdi, rbx
mov rdx, rax
mov ecx, 1
mov r8d, 1
mov r9d, 1
push r10
push r10
push r10
call ggml_conv_2d
add rsp, 20h
mov r12, rax
test r13, r13
jz short loc_53DF1
mov r8, [r13+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r13
call ggml_reshape_4d
mov rdi, rbx
mov rsi, r12
mov rdx, rax
call ggml_add
mov r12, rax
loc_53DF1:
mov rbp, [r15+28h]
mov r13, [r15+30h]
mov rdi, r12
call ggml_n_dims
cmp eax, 3
jl short loc_53E4A
mov r8, [rbp+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, rbp
call ggml_reshape_4d
mov rbp, rax
mov r8, [r13+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r13
call ggml_reshape_4d
mov r13, rax
loc_53E4A:
mov rdi, rbx
mov rsi, r12
mov edx, 20h ; ' '
call ggml_group_norm
mov rdi, rbx
mov rsi, rax
mov rdx, rbp
call ggml_mul
mov rdi, rbx
mov rsi, rax
mov rdx, r13
call ggml_add
mov rdi, rbx
mov rsi, rax
call ggml_silu_inplace
mov rsi, [r15+38h]
mov r13, [r15+40h]
sub rsp, 8
mov r10d, 1
mov rdi, rbx
mov rdx, rax
mov ecx, 1
mov r8d, 1
mov r9d, 1
push r10
push r10
push r10
call ggml_conv_2d
add rsp, 20h
mov r12, rax
test r13, r13
jz short loc_53EF1
mov r8, [r13+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r13
call ggml_reshape_4d
mov rdi, rbx
mov rsi, r12
mov rdx, rax
call ggml_add
mov r12, rax
loc_53EF1:
mov eax, [r15+4]
cmp eax, [r15]
jz short loc_53F64
mov rsi, [r15+48h]
mov r15, [r15+50h]
sub rsp, 8
mov eax, 1
mov rdi, rbx
mov rdx, r14
mov ecx, 1
mov r8d, 1
xor r9d, r9d
push rax
push rax
push 0
call ggml_conv_2d
add rsp, 20h
mov r14, rax
test r15, r15
jz short loc_53F64
mov r8, [r15+10h]
mov edx, 1
mov ecx, 1
mov r9d, 1
mov rdi, rbx
mov rsi, r15
call ggml_reshape_4d
mov rdi, rbx
mov rsi, r14
mov rdx, rax
call ggml_add
mov r14, rax
loc_53F64:
mov rdi, rbx
mov rsi, r12
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp ggml_add
|
long long ResnetBlock::forward(long long a1, long long a2, long long a3)
{
long long v3; // r14
long long v4; // r13
long long v5; // r12
long long v6; // rax
long long v7; // rax
long long v8; // rax
int v9; // eax
long long v10; // r13
long long v11; // r12
long long v12; // rax
long long v13; // rbp
long long v14; // r13
long long v15; // rax
long long v16; // rax
long long v17; // rax
int v18; // eax
long long v19; // r13
long long v20; // r12
long long v21; // rax
long long v22; // r15
long long v23; // rax
v3 = a3;
v4 = *(_QWORD *)(a1 + 8);
v5 = *(_QWORD *)(a1 + 16);
if ( (int)ggml_n_dims(a3) >= 3 )
{
v4 = ggml_reshape_4d(a2, v4, 1LL, 1LL, *(_QWORD *)(v4 + 16), 1LL);
v5 = ggml_reshape_4d(a2, v5, 1LL, 1LL, *(_QWORD *)(v5 + 16), 1LL);
}
v6 = ggml_group_norm(a2, v3, 32LL);
v7 = ggml_mul(a2, v6, v4);
v8 = ggml_add(a2, v7, v5);
v9 = ggml_silu_inplace(a2, v8);
v10 = *(_QWORD *)(a1 + 32);
v11 = ggml_conv_2d(a2, *(_QWORD *)(a1 + 24), v9, 1, 1, 1, 1, 1, 1);
if ( v10 )
{
v12 = ggml_reshape_4d(a2, v10, 1LL, 1LL, *(_QWORD *)(v10 + 16), 1LL);
v11 = ggml_add(a2, v11, v12);
}
v13 = *(_QWORD *)(a1 + 40);
v14 = *(_QWORD *)(a1 + 48);
if ( (int)ggml_n_dims(v11) >= 3 )
{
v13 = ggml_reshape_4d(a2, v13, 1LL, 1LL, *(_QWORD *)(v13 + 16), 1LL);
v14 = ggml_reshape_4d(a2, v14, 1LL, 1LL, *(_QWORD *)(v14 + 16), 1LL);
}
v15 = ggml_group_norm(a2, v11, 32LL);
v16 = ggml_mul(a2, v15, v13);
v17 = ggml_add(a2, v16, v14);
v18 = ggml_silu_inplace(a2, v17);
v19 = *(_QWORD *)(a1 + 64);
v20 = ggml_conv_2d(a2, *(_QWORD *)(a1 + 56), v18, 1, 1, 1, 1, 1, 1);
if ( v19 )
{
v21 = ggml_reshape_4d(a2, v19, 1LL, 1LL, *(_QWORD *)(v19 + 16), 1LL);
v20 = ggml_add(a2, v20, v21);
}
if ( *(_DWORD *)(a1 + 4) != *(_DWORD *)a1 )
{
v22 = *(_QWORD *)(a1 + 80);
v3 = ggml_conv_2d(a2, *(_QWORD *)(a1 + 72), v3, 1, 1, 0, 0, 1, 1);
if ( v22 )
{
v23 = ggml_reshape_4d(a2, v22, 1LL, 1LL, *(_QWORD *)(v22 + 16), 1LL);
v3 = ggml_add(a2, v3, v23);
}
}
return ggml_add(a2, v20, v3);
}
| |||
66,418 |
my_uca_scanner_next_implicit
|
eloqsql/strings/ctype-uca.c
|
static inline int
my_uca_scanner_next_implicit(my_uca_scanner *scanner)
{
switch (scanner->level->levelno) {
case 0: return my_uca_scanner_next_implicit_primary(scanner);/* Primary level*/
case 1: scanner->wbeg= nochar; return 0x0020; /* Secondary level */
case 2: scanner->wbeg= nochar; return 0x0002; /* Tertiary level */
default: scanner->wbeg= nochar; break;
}
DBUG_ASSERT(0);
return 0;
}
|
O0
|
c
|
my_uca_scanner_next_implicit:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x4a324
jmp 0x4a310
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x4a332
jmp 0x4a31a
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x4a349
jmp 0x4a360
movq -0x10(%rbp), %rdi
callq 0x4a670
movl %eax, -0x4(%rbp)
jmp 0x4a379
movq -0x10(%rbp), %rax
leaq 0xa9603(%rip), %rcx # 0xf3940
movq %rcx, (%rax)
movl $0x20, -0x4(%rbp)
jmp 0x4a379
movq -0x10(%rbp), %rax
leaq 0xa95ec(%rip), %rcx # 0xf3940
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x4a379
movq -0x10(%rbp), %rax
leaq 0xa95d5(%rip), %rcx # 0xf3940
movq %rcx, (%rax)
jmp 0x4a370
jmp 0x4a372
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_uca_scanner_next_implicit:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov eax, [rax+30h]
mov [rbp+var_14], eax
test eax, eax
jz short loc_4A324
jmp short $+2
loc_4A310:
mov eax, [rbp+var_14]
sub eax, 1
jz short loc_4A332
jmp short $+2
loc_4A31A:
mov eax, [rbp+var_14]
sub eax, 2
jz short loc_4A349
jmp short loc_4A360
loc_4A324:
mov rdi, [rbp+var_10]
call my_uca_scanner_next_implicit_primary
mov [rbp+var_4], eax
jmp short loc_4A379
loc_4A332:
mov rax, [rbp+var_10]
lea rcx, nochar
mov [rax], rcx
mov [rbp+var_4], 20h ; ' '
jmp short loc_4A379
loc_4A349:
mov rax, [rbp+var_10]
lea rcx, nochar
mov [rax], rcx
mov [rbp+var_4], 2
jmp short loc_4A379
loc_4A360:
mov rax, [rbp+var_10]
lea rcx, nochar
mov [rax], rcx
jmp short $+2
loc_4A370:
jmp short $+2
loc_4A372:
mov [rbp+var_4], 0
loc_4A379:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long my_uca_scanner_next_implicit(_QWORD *a1)
{
int v2; // [rsp+Ch] [rbp-14h]
v2 = *(_DWORD *)(a1[3] + 48LL);
if ( v2 )
{
if ( v2 == 1 )
{
*a1 = &nochar;
return 32;
}
else
{
*a1 = &nochar;
if ( v2 == 2 )
return 2;
else
return 0;
}
}
else
{
return (unsigned int)my_uca_scanner_next_implicit_primary(a1);
}
}
|
my_uca_scanner_next_implicit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV EAX,dword ptr [RAX + 0x30]
MOV dword ptr [RBP + -0x14],EAX
TEST EAX,EAX
JZ 0x0014a324
JMP 0x0014a310
LAB_0014a310:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
JZ 0x0014a332
JMP 0x0014a31a
LAB_0014a31a:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x2
JZ 0x0014a349
JMP 0x0014a360
LAB_0014a324:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014a670
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014a379
LAB_0014a332:
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x1f3940]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x20
JMP 0x0014a379
LAB_0014a349:
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x1f3940]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0014a379
LAB_0014a360:
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x1f3940]
MOV qword ptr [RAX],RCX
JMP 0x0014a370
LAB_0014a370:
JMP 0x0014a372
LAB_0014a372:
MOV dword ptr [RBP + -0x4],0x0
LAB_0014a379:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_uca_scanner_next_implicit(int8 *param_1)
{
int iVar1;
int4 local_c;
iVar1 = *(int *)(param_1[3] + 0x30);
if (iVar1 == 0) {
local_c = my_uca_scanner_next_implicit_primary(param_1);
}
else if (iVar1 == 1) {
*param_1 = &nochar;
local_c = 0x20;
}
else if (iVar1 == 2) {
*param_1 = &nochar;
local_c = 2;
}
else {
*param_1 = &nochar;
local_c = 0;
}
return local_c;
}
|
|
66,419 |
pvio_socket_set_timeout
|
eloqsql/libmariadb/plugins/pvio/pvio_socket.c
|
my_bool pvio_socket_set_timeout(MARIADB_PVIO *pvio, enum enum_pvio_timeout type, int timeout)
{
struct st_pvio_socket *csock= NULL;
if (!pvio)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
pvio->timeout[type]= (timeout > 0) ? timeout * 1000 : -1;
if (csock)
return pvio_socket_change_timeout(pvio, type, timeout * 1000);
return 0;
}
|
O0
|
c
|
pvio_socket_set_timeout:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x72b07
movb $0x1, -0x1(%rbp)
jmp 0x72b5f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x72b24
imull $0x3e8, -0x18(%rbp), %eax # imm = 0x3E8
movl %eax, -0x24(%rbp)
jmp 0x72b2e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x72b2e
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, 0x24(%rax,%rcx,4)
cmpq $0x0, -0x20(%rbp)
je 0x72b5b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
imull $0x3e8, -0x18(%rbp), %edx # imm = 0x3E8
callq 0x74110
movb %al, -0x1(%rbp)
jmp 0x72b5f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
pvio_socket_set_timeout:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], 0
cmp [rbp+var_10], 0
jnz short loc_72B07
mov [rbp+var_1], 1
jmp short loc_72B5F
loc_72B07:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
cmp [rbp+var_18], 0
jle short loc_72B24
imul eax, [rbp+var_18], 3E8h
mov [rbp+var_24], eax
jmp short loc_72B2E
loc_72B24:
mov eax, 0FFFFFFFFh
mov [rbp+var_24], eax
jmp short $+2
loc_72B2E:
mov edx, [rbp+var_24]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_14]
mov [rax+rcx*4+24h], edx
cmp [rbp+var_20], 0
jz short loc_72B5B
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
imul edx, [rbp+var_18], 3E8h
call pvio_socket_change_timeout
mov [rbp+var_1], al
jmp short loc_72B5F
loc_72B5B:
mov [rbp+var_1], 0
loc_72B5F:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char pvio_socket_set_timeout(_QWORD *a1, unsigned int a2, int a3)
{
int v4; // [rsp+Ch] [rbp-24h]
long long v5; // [rsp+10h] [rbp-20h]
if ( !a1 )
return 1;
v5 = *a1;
if ( a3 <= 0 )
v4 = -1;
else
v4 = 1000 * a3;
*((_DWORD *)a1 + a2 + 9) = v4;
if ( v5 )
return pvio_socket_change_timeout(a1, a2, (unsigned int)(1000 * a3));
else
return 0;
}
|
pvio_socket_set_timeout:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],0x0
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00172b07
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00172b5f
LAB_00172b07:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
CMP dword ptr [RBP + -0x18],0x0
JLE 0x00172b24
IMUL EAX,dword ptr [RBP + -0x18],0x3e8
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00172b2e
LAB_00172b24:
MOV EAX,0xffffffff
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00172b2e
LAB_00172b2e:
MOV EDX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
MOV dword ptr [RAX + RCX*0x4 + 0x24],EDX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00172b5b
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
IMUL EDX,dword ptr [RBP + -0x18],0x3e8
CALL 0x00174110
MOV byte ptr [RBP + -0x1],AL
JMP 0x00172b5f
LAB_00172b5b:
MOV byte ptr [RBP + -0x1],0x0
LAB_00172b5f:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 pvio_socket_set_timeout(long *param_1,uint param_2,int param_3)
{
long lVar1;
int local_2c;
int1 local_9;
if (param_1 == (long *)0x0) {
local_9 = 1;
}
else {
lVar1 = *param_1;
if (param_3 < 1) {
local_2c = -1;
}
else {
local_2c = param_3 * 1000;
}
*(int *)((long)param_1 + (ulong)param_2 * 4 + 0x24) = local_2c;
if (lVar1 == 0) {
local_9 = 0;
}
else {
local_9 = pvio_socket_change_timeout(param_1,param_2,param_3 * 1000);
}
}
return local_9;
}
|
|
66,420 |
gzprintf
|
3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/gzwrite.c
|
int ZEXPORTVA gzprintf(gzFile file, const char *format, ...)
{
va_list va;
int ret;
va_start(va, format);
ret = gzvprintf(file, format, va);
va_end(va);
return ret;
}
|
O3
|
c
|
gzprintf:
subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x89df
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %r10, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x3040
addq $0xd8, %rsp
retq
|
gzprintf:
sub rsp, 0D8h
lea r10, [rsp+0D8h+var_B8]
mov [r10+10h], rdx
mov [r10+18h], rcx
mov [r10+20h], r8
mov [r10+28h], r9
test al, al
jz short loc_89DF
movaps [rsp+0D8h+var_88], xmm0
movaps [rsp+0D8h+var_78], xmm1
movaps [rsp+0D8h+var_68], xmm2
movaps [rsp+0D8h+var_58], xmm3
movaps [rsp+0D8h+var_48], xmm4
movaps [rsp+0D8h+var_38], xmm5
movaps [rsp+0D8h+var_28], xmm6
movaps [rsp+0D8h+var_18], xmm7
loc_89DF:
mov rdx, rsp
mov [rdx+10h], r10
lea rax, [rsp+0D8h+arg_0]
mov [rdx+8], rax
mov rax, 3000000010h
mov [rdx], rax
call _gzvprintf
add rsp, 0D8h
retn
|
long long gzprintf(
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)
{
_QWORD v16[4]; // [rsp+0h] [rbp-D8h] BYREF
char v17; // [rsp+20h] [rbp-B8h] BYREF
long long v18; // [rsp+30h] [rbp-A8h]
long long v19; // [rsp+38h] [rbp-A0h]
long long v20; // [rsp+40h] [rbp-98h]
long long v21; // [rsp+48h] [rbp-90h]
__m128 v22; // [rsp+50h] [rbp-88h]
__m128 v23; // [rsp+60h] [rbp-78h]
__m128 v24; // [rsp+70h] [rbp-68h]
__m128 v25; // [rsp+80h] [rbp-58h]
__m128 v26; // [rsp+90h] [rbp-48h]
__m128 v27; // [rsp+A0h] [rbp-38h]
__m128 v28; // [rsp+B0h] [rbp-28h]
__m128 v29; // [rsp+C0h] [rbp-18h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v18 = a3;
v19 = a4;
v20 = a5;
v21 = a6;
v16[2] = &v17;
v16[1] = &a15;
v16[0] = 0x3000000010LL;
return gzvprintf(a1, a2, (long long)v16);
}
|
gzprintf:
SUB RSP,0xd8
LEA R10,[RSP + 0x20]
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 0x001089df
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_001089df:
MOV RDX,RSP
MOV qword ptr [RDX + 0x10],R10
LEA RAX,[RSP + 0xe0]
MOV qword ptr [RDX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RDX],RAX
CALL 0x00103040
ADD RSP,0xd8
RET
|
void gzprintf(void)
{
gzvprintf();
return;
}
|
|
66,421 |
my_rw_trywrlock
|
eloqsql/mysys/thr_rwlock.c
|
int my_rw_trywrlock(my_rw_lock_t *rwp)
{
int res;
pthread_mutex_lock(&rwp->lock);
if (rwp->state)
res= EBUSY; /* Can't get lock */
else
{
res=0;
rwp->state = -1;
#ifdef SAFE_MUTEX
rwp->write_thread= pthread_self();
#endif
}
pthread_mutex_unlock(&rwp->lock);
return(res);
}
|
O3
|
c
|
my_rw_trywrlock:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x29200
movl $0x10, %r14d
cmpl $0x0, 0x88(%rbx)
jne 0xa4466
movl $0xffffffff, 0x88(%rbx) # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x291c0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
my_rw_trywrlock:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call _pthread_mutex_lock
mov r14d, 10h
cmp dword ptr [rbx+88h], 0
jnz short loc_A4466
mov dword ptr [rbx+88h], 0FFFFFFFFh
xor r14d, r14d
loc_A4466:
mov rdi, rbx
call _pthread_mutex_unlock
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
|
long long my_rw_trywrlock(long long a1)
{
unsigned int v1; // r14d
pthread_mutex_lock(a1);
v1 = 16;
if ( !*(_DWORD *)(a1 + 136) )
{
*(_DWORD *)(a1 + 136) = -1;
v1 = 0;
}
pthread_mutex_unlock(a1);
return v1;
}
|
my_rw_trywrlock:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x00129200
MOV R14D,0x10
CMP dword ptr [RBX + 0x88],0x0
JNZ 0x001a4466
MOV dword ptr [RBX + 0x88],0xffffffff
XOR R14D,R14D
LAB_001a4466:
MOV RDI,RBX
CALL 0x001291c0
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
int8 my_rw_trywrlock(pthread_mutex_t *param_1)
{
int8 uVar1;
pthread_mutex_lock(param_1);
uVar1 = 0x10;
if (*(int *)((long)param_1 + 0x88) == 0) {
*(int4 *)((long)param_1 + 0x88) = 0xffffffff;
uVar1 = 0;
}
pthread_mutex_unlock(param_1);
return uVar1;
}
|
|
66,422 |
my_caseup_str_utf8mb3
|
eloqsql/strings/ctype-utf8.c
|
static size_t my_caseup_str_utf8mb3(CHARSET_INFO *cs, char *src)
{
my_wc_t wc;
int srcres, dstres;
char *dst= src, *dst0= src;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(cs->caseup_multiply == 1);
while (*src &&
(srcres= my_utf8mb3_uni_no_range(cs, &wc, (uchar *) src)) > 0)
{
my_toupper_utf8mb3(uni_plane, &wc);
if ((dstres= my_uni_utf8mb3_no_range(cs, wc, (uchar*) dst)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
*dst= '\0';
return (size_t) (dst - dst0);
}
|
O3
|
c
|
my_caseup_str_utf8mb3:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
movq %rsi, %r14
je 0x86d7f
movq 0x78(%rdi), %r13
leaq -0x30(%rbp), %r15
movq %rbx, %r12
movq %rbx, %r14
movq %r15, %rdi
movq %r12, %rsi
callq 0x87658
testl %eax, %eax
je 0x86d7f
movq 0x8(%r13), %rdx
movq -0x30(%rbp), %rcx
movzbl %ch, %esi
movq (%rdx,%rsi,8), %rdx
testq %rdx, %rdx
je 0x86d0e
movzbl %cl, %ecx
leaq (%rcx,%rcx,2), %rcx
movl (%rdx,%rcx,4), %ecx
movq %rcx, -0x30(%rbp)
movl $0x1, %edx
cmpq $0x80, %rcx
jb 0x86d68
movl $0x2, %edx
cmpq $0x800, %rcx # imm = 0x800
jb 0x86d4f
cmpq $0xffff, %rcx # imm = 0xFFFF
ja 0x86d7f
movl %ecx, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x2(%r14)
shrq $0x6, %rcx
orq $0x800, %rcx # imm = 0x800
movl $0x3, %edx
movl %ecx, %esi
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x1(%r14)
shrq $0x6, %rcx
orq $0xc0, %rcx
movb %cl, (%r14)
movl %eax, %eax
addq %rdx, %r14
cmpb $0x0, (%r12,%rax)
leaq (%r12,%rax), %r12
jne 0x86cd9
movb $0x0, (%r14)
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_caseup_str_utf8mb3:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
cmp byte ptr [rsi], 0
mov r14, rsi
jz loc_86D7F
mov r13, [rdi+78h]
lea r15, [rbp+var_30]
mov r12, rbx
mov r14, rbx
loc_86CD9:
mov rdi, r15
mov rsi, r12
call my_utf8mb3_uni_no_range
test eax, eax
jz loc_86D7F
mov rdx, [r13+8]
mov rcx, [rbp+var_30]
movzx esi, ch
mov rdx, [rdx+rsi*8]
test rdx, rdx
jz short loc_86D0E
movzx ecx, cl
lea rcx, [rcx+rcx*2]
mov ecx, [rdx+rcx*4]
mov [rbp+var_30], rcx
loc_86D0E:
mov edx, 1
cmp rcx, 80h
jb short loc_86D68
mov edx, 2
cmp rcx, 800h
jb short loc_86D4F
cmp rcx, 0FFFFh
ja short loc_86D7F
mov edx, ecx
and dl, 3Fh
or dl, 80h
mov [r14+2], dl
shr rcx, 6
or rcx, 800h
mov edx, 3
loc_86D4F:
mov esi, ecx
and sil, 3Fh
or sil, 80h
mov [r14+1], sil
shr rcx, 6
or rcx, 0C0h
loc_86D68:
mov [r14], cl
mov eax, eax
add r14, rdx
cmp byte ptr [r12+rax], 0
lea r12, [r12+rax]
jnz loc_86CD9
loc_86D7F:
mov byte ptr [r14], 0
sub r14, rbx
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_caseup_str_utf8mb3(long long a1, _BYTE *a2)
{
unsigned long long v2; // rax
_BYTE *v3; // r14
long long v4; // r13
_BYTE *v5; // r12
unsigned int v6; // eax
unsigned long long v7; // rcx
long long v8; // rdx
long long v9; // rdx
bool v10; // zf
unsigned long long v12; // [rsp+0h] [rbp-30h] BYREF
v12 = v2;
v3 = a2;
if ( *a2 )
{
v4 = *(_QWORD *)(a1 + 120);
v5 = a2;
v3 = a2;
do
{
v6 = my_utf8mb3_uni_no_range(&v12, v5);
if ( !v6 )
break;
v7 = v12;
v8 = *(_QWORD *)(*(_QWORD *)(v4 + 8) + 8LL * BYTE1(v12));
if ( v8 )
{
v7 = *(unsigned int *)(v8 + 12LL * (unsigned __int8)v12);
v12 = v7;
}
v9 = 1LL;
if ( v7 >= 0x80 )
{
v9 = 2LL;
if ( v7 >= 0x800 )
{
if ( v7 > 0xFFFF )
break;
v3[2] = v7 & 0x3F | 0x80;
v7 = (v7 >> 6) | 0x800;
v9 = 3LL;
}
v3[1] = v7 & 0x3F | 0x80;
v7 = (v7 >> 6) | 0xC0;
}
*v3 = v7;
v3 += v9;
v10 = v5[v6] == 0;
v5 += v6;
}
while ( !v10 );
}
*v3 = 0;
return v3 - a2;
}
|
my_caseup_str_utf8mb3:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
CMP byte ptr [RSI],0x0
MOV R14,RSI
JZ 0x00186d7f
MOV R13,qword ptr [RDI + 0x78]
LEA R15,[RBP + -0x30]
MOV R12,RBX
MOV R14,RBX
LAB_00186cd9:
MOV RDI,R15
MOV RSI,R12
CALL 0x00187658
TEST EAX,EAX
JZ 0x00186d7f
MOV RDX,qword ptr [R13 + 0x8]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ESI,CH
MOV RDX,qword ptr [RDX + RSI*0x8]
TEST RDX,RDX
JZ 0x00186d0e
MOVZX ECX,CL
LEA RCX,[RCX + RCX*0x2]
MOV ECX,dword ptr [RDX + RCX*0x4]
MOV qword ptr [RBP + -0x30],RCX
LAB_00186d0e:
MOV EDX,0x1
CMP RCX,0x80
JC 0x00186d68
MOV EDX,0x2
CMP RCX,0x800
JC 0x00186d4f
CMP RCX,0xffff
JA 0x00186d7f
MOV EDX,ECX
AND DL,0x3f
OR DL,0x80
MOV byte ptr [R14 + 0x2],DL
SHR RCX,0x6
OR RCX,0x800
MOV EDX,0x3
LAB_00186d4f:
MOV ESI,ECX
AND SIL,0x3f
OR SIL,0x80
MOV byte ptr [R14 + 0x1],SIL
SHR RCX,0x6
OR RCX,0xc0
LAB_00186d68:
MOV byte ptr [R14],CL
MOV EAX,EAX
ADD R14,RDX
CMP byte ptr [R12 + RAX*0x1],0x0
LEA R12,[R12 + RAX*0x1]
JNZ 0x00186cd9
LAB_00186d7f:
MOV byte ptr [R14],0x0
SUB R14,RBX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_caseup_str_utf8mb3(long param_1,char *param_2)
{
char *pcVar1;
long lVar2;
uint uVar3;
ulong in_RAX;
ulong uVar4;
long lVar5;
char *pcVar6;
char *pcVar7;
ulong local_38;
pcVar7 = param_2;
if (*param_2 != '\0') {
lVar2 = *(long *)(param_1 + 0x78);
pcVar6 = param_2;
local_38 = in_RAX;
do {
uVar3 = my_utf8mb3_uni_no_range(&local_38,pcVar6);
if (uVar3 == 0) break;
lVar5 = *(long *)(*(long *)(lVar2 + 8) + (local_38 >> 8 & 0xff) * 8);
if (lVar5 != 0) {
local_38 = (ulong)*(uint *)(lVar5 + (local_38 & 0xff) * 0xc);
}
lVar5 = 1;
uVar4 = local_38;
if (0x7f < local_38) {
lVar5 = 2;
if (0x7ff < local_38) {
if (0xffff < local_38) break;
pcVar7[2] = (byte)local_38 & 0x3f | 0x80;
uVar4 = local_38 >> 6 | 0x800;
lVar5 = 3;
}
pcVar7[1] = (byte)uVar4 & 0x3f | 0x80;
uVar4 = uVar4 >> 6 | 0xc0;
}
*pcVar7 = (char)uVar4;
pcVar7 = pcVar7 + lVar5;
pcVar1 = pcVar6 + uVar3;
pcVar6 = pcVar6 + uVar3;
} while (*pcVar1 != '\0');
}
*pcVar7 = '\0';
return (long)pcVar7 - (long)param_2;
}
|
|
66,423 |
trnman_end_trn
|
eloqsql/storage/maria/trnman.c
|
my_bool trnman_end_trn(TRN *trn, my_bool commit)
{
int res= 1;
uint16 cached_short_id= trn->short_id; /* we have to cache it, see below */
TRN *free_me= 0;
LF_PINS *pins= trn->pins;
DBUG_ENTER("trnman_end_trn");
DBUG_PRINT("enter", ("trn: %p commit: %d", trn, commit));
/* if a rollback, all UNDO records should have been executed */
DBUG_ASSERT(commit || trn->undo_lsn == 0);
DBUG_ASSERT(trn != &dummy_transaction_object);
DBUG_ASSERT(trn->locked_tables == 0 && trn->used_instances == 0);
DBUG_PRINT("info", ("mysql_mutex_lock LOCK_trn_list"));
mysql_mutex_lock(&LOCK_trn_list);
/* remove from active list */
trn->next->prev= trn->prev;
trn->prev->next= trn->next;
/*
if trn was the oldest active transaction, now that it goes away there
may be committed transactions in the list which no active transaction
needs to bother about - clean up the committed list
*/
if (trn->prev == &active_list_min)
{
uint free_me_count;
TRN *t;
for (t= committed_list_min.next, free_me_count= 0;
t->commit_trid < active_list_min.next->min_read_from;
t= t->next, free_me_count++) /* no-op */;
DBUG_ASSERT((t != committed_list_min.next && free_me_count > 0) ||
(t == committed_list_min.next && free_me_count == 0));
/* found transactions committed before the oldest active one */
if (t != committed_list_min.next)
{
free_me= committed_list_min.next;
committed_list_min.next= t;
t->prev->next= 0;
t->prev= &committed_list_min;
trnman_committed_transactions-= free_me_count;
}
}
mysql_mutex_lock(&trn->state_lock);
if (commit)
trn->commit_trid= global_trid_generator;
wt_thd_release_self(trn);
mysql_mutex_unlock(&trn->state_lock);
/*
if transaction is committed and it was not the only active transaction -
add it to the committed list
*/
if (commit && active_list_min.next != &active_list_max)
{
trn->next= &committed_list_max;
trn->prev= committed_list_max.prev;
trnman_committed_transactions++;
committed_list_max.prev= trn->prev->next= trn;
}
else
{
trn->next= free_me;
free_me= trn;
}
trid_min_read_from= active_list_min.next->min_read_from;
if ((*trnman_end_trans_hook)(trn, commit,
active_list_min.next != &active_list_max))
res= -1;
trnman_active_transactions--;
DBUG_PRINT("info", ("mysql_mutex_unlock LOCK_trn_list"));
mysql_mutex_unlock(&LOCK_trn_list);
/*
the rest is done outside of a critical section
note that we don't own trn anymore, it may be in a shared list now.
Thus, we cannot dereference it, and must use cached_short_id below.
*/
my_atomic_storeptr((void **)&short_trid_to_active_trn[cached_short_id], 0);
/*
we, under the mutex, removed going-in-free_me transactions from the
active and committed lists, thus nobody else may see them when it scans
those lists, and thus nobody may want to free them. Now we don't
need a mutex to access free_me list
*/
/* QQ: send them to the purge thread */
while (free_me)
{
TRN *t= free_me;
free_me= free_me->next;
/* ignore OOM. it's harmless, and we can do nothing here anyway */
(void)lf_hash_delete(&trid_to_trn, pins, &t->trid, sizeof(TrID));
trnman_free_trn(t);
}
lf_hash_put_pins(pins);
DBUG_RETURN(res < 0);
}
|
O3
|
c
|
trnman_end_trn:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r12d
movq %rdi, %r15
movzwl 0xac(%rdi), %r13d
movq (%rdi), %rbx
cmpq $0x0, 0x3a31c8(%rip) # 0x3ff540
jne 0x5c570
leaq 0x3a317b(%rip), %rdi # 0x3ff500
callq 0x291d0
movq 0x68(%r15), %rax
movq 0x70(%r15), %rcx
movq %rcx, 0x70(%rax)
movq 0x68(%r15), %rax
movq %rax, 0x68(%rcx)
leaq 0x3a2db3(%rip), %rax # 0x3ff158
cmpq %rax, 0x70(%r15)
movq %r13, -0x30(%rbp)
jne 0x5c40c
movq 0x3a2e0a(%rip), %rax # 0x3ff1c0
movq 0x80(%rax), %rdx
movq 0x3a300c(%rip), %r14 # 0x3ff3d0
xorl %eax, %eax
cmpq %rdx, 0x88(%r14)
jae 0x5c40c
movq %r14, %rcx
movq 0x68(%rcx), %rcx
decl %eax
cmpq %rdx, 0x88(%rcx)
jb 0x5c3d2
cmpq %r14, %rcx
je 0x5c40c
movq %rcx, 0x3a2fe3(%rip) # 0x3ff3d0
leaq 0x3a2f74(%rip), %rdx # 0x3ff368
movq 0x70(%rcx), %rsi
movq $0x0, 0x68(%rsi)
movq %rdx, 0x70(%rcx)
addl %eax, 0x3a3012(%rip) # 0x3ff41c
jmp 0x5c40f
xorl %r14d, %r14d
leaq 0x10(%r15), %r13
cmpq $0x0, 0x50(%r15)
jne 0x5c57a
movq %r13, %rdi
callq 0x291d0
testb %r12b, %r12b
je 0x5c439
movq 0x3a2ffe(%rip), %rax # 0x3ff430
movq %rax, 0x88(%r15)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x5c461
leaq 0x328c9f(%rip), %rax # 0x3850e8
leaq -0x40(%rbp), %rsi
movq %rax, 0x8(%rsi)
movq %r15, (%rsi)
callq 0xa87ca
movq $0x0, 0x8(%r15)
movq 0x50(%r15), %rdi
testq %rdi, %rdi
jne 0x5c593
movq %r13, %rdi
callq 0x291a0
leaq 0x3a2d8b(%rip), %rax # 0x3ff208
testb %r12b, %r12b
je 0x5c4b4
cmpq %rax, 0x3a2d37(%rip) # 0x3ff1c0
je 0x5c4b4
leaq 0x3a2e26(%rip), %rcx # 0x3ff2b8
movq %rcx, 0x68(%r15)
movq 0x3a2e8b(%rip), %rcx # 0x3ff328
movq %rcx, 0x70(%r15)
incl 0x3a2f75(%rip) # 0x3ff41c
movq %r15, 0x68(%rcx)
movq %r15, 0x3a2e76(%rip) # 0x3ff328
jmp 0x5c4bb
movq %r14, 0x68(%r15)
movq %r15, %r14
movq -0x30(%rbp), %r13
movq 0x3a2cfa(%rip), %rcx # 0x3ff1c0
movq 0x80(%rcx), %rdx
movq %rdx, 0x328cb4(%rip) # 0x385188
xorl %edx, %edx
cmpq %rax, %rcx
setne %dl
movsbl %r12b, %esi
movq %r15, %rdi
callq *0x328c97(%rip) # 0x385180
decl 0x3a2f29(%rip) # 0x3ff418
movl %eax, %r15d
movq 0x3a3047(%rip), %rdi # 0x3ff540
testq %rdi, %rdi
jne 0x5c5a8
leaq 0x3a2ff7(%rip), %rdi # 0x3ff500
callq 0x291a0
movq 0x3a2c3b(%rip), %rax # 0x3ff150
xorl %ecx, %ecx
xchgq %rcx, (%rax,%r13,8)
testq %r14, %r14
je 0x5c54f
leaq 0x3a2f11(%rip), %r12 # 0x3ff438
movq 0x68(%r14), %r13
leaq 0x78(%r14), %rdx
movq %r12, %rdi
movq %rbx, %rsi
movl $0x8, %ecx
callq 0x2fa11
movq %r14, %rdi
callq 0x5c2d4
movq %r13, %r14
testq %r13, %r13
jne 0x5c527
testb %r15b, %r15b
setne %r14b
movq %rbx, %rdi
callq 0xa6b8b
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a9f7
jmp 0x5c38a
leaq 0x7e26a(%rip), %rsi # 0xda7eb
movq %r13, %rdi
movl $0x1d9, %edx # imm = 0x1D9
callq 0x2ee6f
jmp 0x5c426
leaq 0x32aab6(%rip), %rax # 0x387050
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x5c46e
leaq 0x32aaa1(%rip), %rax # 0x387050
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x5c502
|
trnman_end_trn:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12d, esi
mov r15, rdi
movzx r13d, word ptr [rdi+0ACh]
mov rbx, [rdi]
cmp cs:qword_3FF540, 0
jnz loc_5C570
lea rdi, LOCK_trn_list
call _pthread_mutex_lock
loc_5C38A:
mov rax, [r15+68h]
mov rcx, [r15+70h]
mov [rax+70h], rcx
mov rax, [r15+68h]
mov [rcx+68h], rax
lea rax, active_list_min
cmp [r15+70h], rax
mov [rbp+var_30], r13
jnz short loc_5C40C
mov rax, cs:qword_3FF1C0
mov rdx, [rax+80h]
mov r14, cs:qword_3FF3D0
xor eax, eax
cmp [r14+88h], rdx
jnb short loc_5C40C
mov rcx, r14
loc_5C3D2:
mov rcx, [rcx+68h]
dec eax
cmp [rcx+88h], rdx
jb short loc_5C3D2
cmp rcx, r14
jz short loc_5C40C
mov cs:qword_3FF3D0, rcx
lea rdx, committed_list_min
mov rsi, [rcx+70h]
mov qword ptr [rsi+68h], 0
mov [rcx+70h], rdx
add cs:trnman_committed_transactions, eax
jmp short loc_5C40F
loc_5C40C:
xor r14d, r14d
loc_5C40F:
lea r13, [r15+10h]
cmp qword ptr [r15+50h], 0
jnz loc_5C57A
mov rdi, r13
call _pthread_mutex_lock
loc_5C426:
test r12b, r12b
jz short loc_5C439
mov rax, cs:global_trid_generator
mov [r15+88h], rax
loc_5C439:
mov rdi, [r15+8]
test rdi, rdi
jz short loc_5C461
lea rax, ma_rc_dup_unique
lea rsi, [rbp+var_40]
mov [rsi+8], rax
mov [rsi], r15
call wt_thd_release
mov qword ptr [r15+8], 0
loc_5C461:
mov rdi, [r15+50h]
test rdi, rdi
jnz loc_5C593
loc_5C46E:
mov rdi, r13
call _pthread_mutex_unlock
lea rax, active_list_max
test r12b, r12b
jz short loc_5C4B4
cmp cs:qword_3FF1C0, rax
jz short loc_5C4B4
lea rcx, committed_list_max
mov [r15+68h], rcx
mov rcx, cs:qword_3FF328
mov [r15+70h], rcx
inc cs:trnman_committed_transactions
mov [rcx+68h], r15
mov cs:qword_3FF328, r15
jmp short loc_5C4BB
loc_5C4B4:
mov [r15+68h], r14
mov r14, r15
loc_5C4BB:
mov r13, [rbp+var_30]
mov rcx, cs:qword_3FF1C0
mov rdx, [rcx+80h]
mov cs:trid_min_read_from, rdx
xor edx, edx
cmp rcx, rax
setnz dl
movsx esi, r12b
mov rdi, r15
call cs:trnman_end_trans_hook
dec cs:trnman_active_transactions
mov r15d, eax
mov rdi, cs:qword_3FF540
test rdi, rdi
jnz loc_5C5A8
loc_5C502:
lea rdi, LOCK_trn_list
call _pthread_mutex_unlock
mov rax, cs:short_trid_to_active_trn
xor ecx, ecx
xchg rcx, [rax+r13*8]
test r14, r14
jz short loc_5C54F
lea r12, trid_to_trn
loc_5C527:
mov r13, [r14+68h]
lea rdx, [r14+78h]
mov rdi, r12
mov rsi, rbx
mov ecx, 8
call lf_hash_delete
mov rdi, r14
call trnman_free_trn
mov r14, r13
test r13, r13
jnz short loc_5C527
loc_5C54F:
test r15b, r15b
setnz r14b
mov rdi, rbx
call lf_pinbox_put_pins
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5C570:
call trnman_end_trn_cold_1
jmp loc_5C38A
loc_5C57A:
lea rsi, aWorkspaceLlm4b_8; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r13
mov edx, 1D9h
call psi_mutex_lock
jmp loc_5C426
loc_5C593:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_5C46E
loc_5C5A8:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_5C502
|
long long trnman_end_trn(long long a1, char a2)
{
long long v3; // r13
volatile long long *v4; // rbx
long long v5; // rcx
bool v6; // zf
unsigned long long v7; // rdx
signed long long v8; // r14
int v9; // eax
_QWORD *v10; // rcx
long long v11; // rdi
long long v12; // rcx
long long v13; // r13
volatile long long *v14; // rsi
char v15; // al
char v16; // r15
long long v17; // rdx
long long v18; // rcx
signed long long v19; // r13
_QWORD v21[2]; // [rsp+0h] [rbp-40h] BYREF
long long v22; // [rsp+10h] [rbp-30h]
v3 = *(unsigned __int16 *)(a1 + 172);
v4 = *(volatile long long **)a1;
if ( qword_3FF540 )
trnman_end_trn_cold_1();
else
pthread_mutex_lock(&LOCK_trn_list);
v5 = *(_QWORD *)(a1 + 112);
*(_QWORD *)(*(_QWORD *)(a1 + 104) + 112LL) = v5;
*(_QWORD *)(v5 + 104) = *(_QWORD *)(a1 + 104);
v6 = *(_QWORD *)(a1 + 112) == (_QWORD)&active_list_min;
v22 = v3;
if ( !v6 )
goto LABEL_9;
v7 = *(_QWORD *)(qword_3FF1C0 + 128);
v8 = qword_3FF3D0;
v9 = 0;
if ( *(_QWORD *)(qword_3FF3D0 + 136) >= v7 )
goto LABEL_9;
v10 = (_QWORD *)qword_3FF3D0;
do
{
v10 = (_QWORD *)v10[13];
--v9;
}
while ( v10[17] < v7 );
if ( v10 == (_QWORD *)qword_3FF3D0 )
{
LABEL_9:
v8 = 0LL;
}
else
{
qword_3FF3D0 = (long long)v10;
*(_QWORD *)(v10[14] + 104LL) = 0LL;
v10[14] = &committed_list_min;
trnman_committed_transactions += v9;
}
if ( *(_QWORD *)(a1 + 80) )
psi_mutex_lock(a1 + 16, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 0x1D9u);
else
pthread_mutex_lock(a1 + 16);
if ( a2 )
*(_QWORD *)(a1 + 136) = global_trid_generator;
v11 = *(_QWORD *)(a1 + 8);
if ( v11 )
{
v21[1] = &ma_rc_dup_unique;
v21[0] = a1;
wt_thd_release(v11, v21);
*(_QWORD *)(a1 + 8) = 0LL;
}
if ( *(_QWORD *)(a1 + 80) )
PSI_server[44]();
pthread_mutex_unlock(a1 + 16);
if ( !a2 || (_UNKNOWN *)qword_3FF1C0 == &active_list_max )
{
*(_QWORD *)(a1 + 104) = v8;
v8 = a1;
}
else
{
*(_QWORD *)(a1 + 104) = &committed_list_max;
v12 = qword_3FF328;
*(_QWORD *)(a1 + 112) = qword_3FF328;
++trnman_committed_transactions;
*(_QWORD *)(v12 + 104) = a1;
qword_3FF328 = a1;
}
v13 = v22;
trid_min_read_from = *(_QWORD *)(qword_3FF1C0 + 128);
v14 = (volatile long long *)(unsigned int)a2;
v15 = trnman_end_trans_hook();
--trnman_active_transactions;
v16 = v15;
if ( qword_3FF540 )
((void ( *)(long long, volatile long long *))PSI_server[44])(qword_3FF540, v14);
pthread_mutex_unlock(&LOCK_trn_list);
v18 = _InterlockedExchange64((volatile long long *)(short_trid_to_active_trn + 8 * v13), 0LL);
if ( v8 )
{
do
{
v19 = *(_QWORD *)(v8 + 104);
v14 = v4;
lf_hash_delete((long long)&trid_to_trn, v4, v8 + 120, 8u);
trnman_free_trn(v8);
v8 = v19;
}
while ( v19 );
}
LOBYTE(v8) = v16 != 0;
lf_pinbox_put_pins(v4, v14, v17, v18);
return (unsigned int)v8;
}
|
trnman_end_trn:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12D,ESI
MOV R15,RDI
MOVZX R13D,word ptr [RDI + 0xac]
MOV RBX,qword ptr [RDI]
CMP qword ptr [0x004ff540],0x0
JNZ 0x0015c570
LEA RDI,[0x4ff500]
CALL 0x001291d0
LAB_0015c38a:
MOV RAX,qword ptr [R15 + 0x68]
MOV RCX,qword ptr [R15 + 0x70]
MOV qword ptr [RAX + 0x70],RCX
MOV RAX,qword ptr [R15 + 0x68]
MOV qword ptr [RCX + 0x68],RAX
LEA RAX,[0x4ff158]
CMP qword ptr [R15 + 0x70],RAX
MOV qword ptr [RBP + -0x30],R13
JNZ 0x0015c40c
MOV RAX,qword ptr [0x004ff1c0]
MOV RDX,qword ptr [RAX + 0x80]
MOV R14,qword ptr [0x004ff3d0]
XOR EAX,EAX
CMP qword ptr [R14 + 0x88],RDX
JNC 0x0015c40c
MOV RCX,R14
LAB_0015c3d2:
MOV RCX,qword ptr [RCX + 0x68]
DEC EAX
CMP qword ptr [RCX + 0x88],RDX
JC 0x0015c3d2
CMP RCX,R14
JZ 0x0015c40c
MOV qword ptr [0x004ff3d0],RCX
LEA RDX,[0x4ff368]
MOV RSI,qword ptr [RCX + 0x70]
MOV qword ptr [RSI + 0x68],0x0
MOV qword ptr [RCX + 0x70],RDX
ADD dword ptr [0x004ff41c],EAX
JMP 0x0015c40f
LAB_0015c40c:
XOR R14D,R14D
LAB_0015c40f:
LEA R13,[R15 + 0x10]
CMP qword ptr [R15 + 0x50],0x0
JNZ 0x0015c57a
MOV RDI,R13
CALL 0x001291d0
LAB_0015c426:
TEST R12B,R12B
JZ 0x0015c439
MOV RAX,qword ptr [0x004ff430]
MOV qword ptr [R15 + 0x88],RAX
LAB_0015c439:
MOV RDI,qword ptr [R15 + 0x8]
TEST RDI,RDI
JZ 0x0015c461
LEA RAX,[0x4850e8]
LEA RSI,[RBP + -0x40]
MOV qword ptr [RSI + 0x8],RAX
MOV qword ptr [RSI],R15
CALL 0x001a87ca
MOV qword ptr [R15 + 0x8],0x0
LAB_0015c461:
MOV RDI,qword ptr [R15 + 0x50]
TEST RDI,RDI
JNZ 0x0015c593
LAB_0015c46e:
MOV RDI,R13
CALL 0x001291a0
LEA RAX,[0x4ff208]
TEST R12B,R12B
JZ 0x0015c4b4
CMP qword ptr [0x004ff1c0],RAX
JZ 0x0015c4b4
LEA RCX,[0x4ff2b8]
MOV qword ptr [R15 + 0x68],RCX
MOV RCX,qword ptr [0x004ff328]
MOV qword ptr [R15 + 0x70],RCX
INC dword ptr [0x004ff41c]
MOV qword ptr [RCX + 0x68],R15
MOV qword ptr [0x004ff328],R15
JMP 0x0015c4bb
LAB_0015c4b4:
MOV qword ptr [R15 + 0x68],R14
MOV R14,R15
LAB_0015c4bb:
MOV R13,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [0x004ff1c0]
MOV RDX,qword ptr [RCX + 0x80]
MOV qword ptr [0x00485188],RDX
XOR EDX,EDX
CMP RCX,RAX
SETNZ DL
MOVSX ESI,R12B
MOV RDI,R15
CALL qword ptr [0x00485180]
DEC dword ptr [0x004ff418]
MOV R15D,EAX
MOV RDI,qword ptr [0x004ff540]
TEST RDI,RDI
JNZ 0x0015c5a8
LAB_0015c502:
LEA RDI,[0x4ff500]
CALL 0x001291a0
MOV RAX,qword ptr [0x004ff150]
XOR ECX,ECX
XCHG qword ptr [RAX + R13*0x8],RCX
TEST R14,R14
JZ 0x0015c54f
LEA R12,[0x4ff438]
LAB_0015c527:
MOV R13,qword ptr [R14 + 0x68]
LEA RDX,[R14 + 0x78]
MOV RDI,R12
MOV RSI,RBX
MOV ECX,0x8
CALL 0x0012fa11
MOV RDI,R14
CALL 0x0015c2d4
MOV R14,R13
TEST R13,R13
JNZ 0x0015c527
LAB_0015c54f:
TEST R15B,R15B
SETNZ R14B
MOV RDI,RBX
CALL 0x001a6b8b
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015c570:
CALL 0x0012a9f7
JMP 0x0015c38a
LAB_0015c57a:
LEA RSI,[0x1da7eb]
MOV RDI,R13
MOV EDX,0x1d9
CALL 0x0012ee6f
JMP 0x0015c426
LAB_0015c593:
LEA RAX,[0x487050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0015c46e
LAB_0015c5a8:
LEA RAX,[0x487050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0015c502
|
bool trnman_end_trn(int8 *param_1,char param_2)
{
pthread_mutex_t *__mutex;
ushort uVar1;
int8 uVar2;
int8 *puVar3;
char cVar4;
int iVar5;
long lVar6;
int8 *puVar7;
uVar1 = *(ushort *)((long)param_1 + 0xac);
uVar2 = *param_1;
if (LOCK_trn_list._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)LOCK_trn_list);
}
else {
trnman_end_trn_cold_1();
}
lVar6 = param_1[0xe];
*(long *)(param_1[0xd] + 0x70) = lVar6;
*(int8 *)(lVar6 + 0x68) = param_1[0xd];
puVar7 = (int8 *)committed_list_min._104_8_;
if ((int1 *)param_1[0xe] == active_list_min) {
iVar5 = 0;
lVar6 = committed_list_min._104_8_;
if (*(ulong *)(committed_list_min._104_8_ + 0x88) < *(ulong *)(active_list_min._104_8_ + 0x80))
{
do {
lVar6 = *(long *)(lVar6 + 0x68);
iVar5 = iVar5 + -1;
} while (*(ulong *)(lVar6 + 0x88) < *(ulong *)(active_list_min._104_8_ + 0x80));
if (lVar6 != committed_list_min._104_8_) {
committed_list_min._104_8_ = lVar6;
*(int8 *)(*(long *)(lVar6 + 0x70) + 0x68) = 0;
*(int1 **)(lVar6 + 0x70) = committed_list_min;
trnman_committed_transactions = trnman_committed_transactions + iVar5;
goto LAB_0015c40f;
}
}
}
puVar7 = (int8 *)0x0;
LAB_0015c40f:
__mutex = (pthread_mutex_t *)(param_1 + 2);
if (param_1[10] == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x1d9);
}
if (param_2 != '\0') {
param_1[0x11] = global_trid_generator;
}
if (param_1[1] != 0) {
wt_thd_release();
param_1[1] = 0;
}
if (param_1[10] != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
if ((param_2 == '\0') || ((int1 *)active_list_min._104_8_ == active_list_max)) {
param_1[0xd] = puVar7;
puVar7 = param_1;
}
else {
param_1[0xd] = committed_list_max;
param_1[0xe] = committed_list_max._112_8_;
trnman_committed_transactions = trnman_committed_transactions + 1;
*(int8 **)(committed_list_max._112_8_ + 0x68) = param_1;
committed_list_max._112_8_ = param_1;
}
trid_min_read_from = *(int8 *)(active_list_min._104_8_ + 0x80);
cVar4 = (*(code *)trnman_end_trans_hook)
(param_1,(int)param_2,(int1 *)active_list_min._104_8_ != active_list_max);
trnman_active_transactions = trnman_active_transactions + -1;
if (LOCK_trn_list._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_trn_list);
LOCK();
*(int8 *)(short_trid_to_active_trn + (ulong)uVar1 * 8) = 0;
UNLOCK();
while (puVar7 != (int8 *)0x0) {
puVar3 = (int8 *)puVar7[0xd];
lf_hash_delete(trid_to_trn,uVar2,puVar7 + 0xf,8);
trnman_free_trn(puVar7);
puVar7 = puVar3;
}
lf_pinbox_put_pins(uVar2);
return cVar4 != '\0';
}
|
|
66,424 |
OpenSubdiv::v3_6_0::Bfr::VertexDescriptor::initFaceSizes()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/vertexDescriptor.cpp
|
void
VertexDescriptor::initFaceSizes() {
_faceSizeOffsets.SetSize(_numFaces + 1);
std::fill(&_faceSizeOffsets[0], &_faceSizeOffsets[_numFaces + 1], 0);
_hasFaceSizes = true;
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Bfr::VertexDescriptor::initFaceSizes():
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movswl 0x2(%rdi), %ebp
incl %ebp
jne 0xa5dad
movq 0x90(%rbx), %rdi
callq 0x3a0a0
leaq 0x70(%rbx), %rdi
movq %rdi, 0x60(%rbx)
movl $0x8, 0x6c(%rbx)
jmp 0xa5def
cmpl %ebp, 0x6c(%rbx)
jae 0xa5deb
movq 0x90(%rbx), %rdi
callq 0x3a0a0
leaq 0x70(%rbx), %rax
movq %rax, 0x60(%rbx)
movl $0x8, 0x6c(%rbx)
movl %ebp, %edi
shlq $0x2, %rdi
callq 0x3a210
movq %rax, %rdi
movq %rax, 0x90(%rbx)
movq %rax, 0x60(%rbx)
movl %ebp, 0x6c(%rbx)
jmp 0xa5def
movq 0x60(%rbx), %rdi
movl %ebp, 0x68(%rbx)
movswq 0x2(%rbx), %rax
leaq (%rdi,%rax,4), %rcx
addq $0x4, %rcx
cmpq %rcx, %rdi
je 0xa5e13
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x391a0
orb $0x20, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
|
_ZN10OpenSubdiv6v3_6_03Bfr16VertexDescriptor13initFaceSizesEv:
push rbp
push rbx
push rax
mov rbx, rdi
movsx ebp, word ptr [rdi+2]
inc ebp
jnz short loc_A5DAD
mov rdi, [rbx+90h]; void *
call __ZdlPv; operator delete(void *)
lea rdi, [rbx+70h]
mov [rbx+60h], rdi
mov dword ptr [rbx+6Ch], 8
jmp short loc_A5DEF
loc_A5DAD:
cmp [rbx+6Ch], ebp
jnb short loc_A5DEB
mov rdi, [rbx+90h]; void *
call __ZdlPv; operator delete(void *)
lea rax, [rbx+70h]
mov [rbx+60h], rax
mov dword ptr [rbx+6Ch], 8
mov edi, ebp
shl rdi, 2; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax
mov [rbx+90h], rax
mov [rbx+60h], rax
mov [rbx+6Ch], ebp
jmp short loc_A5DEF
loc_A5DEB:
mov rdi, [rbx+60h]
loc_A5DEF:
mov [rbx+68h], ebp
movsx rax, word ptr [rbx+2]
lea rcx, [rdi+rax*4]
add rcx, 4
cmp rdi, rcx
jz short loc_A5E13
lea rdx, ds:4[rax*4]
xor esi, esi
call _memset
loc_A5E13:
or byte ptr [rbx], 20h
add rsp, 8
pop rbx
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Bfr::VertexDescriptor::initFaceSizes(void **this)
{
unsigned int v2; // ebp
char *v3; // rdi
long long result; // rax
v2 = *((__int16 *)this + 1) + 1;
if ( *((__int16 *)this + 1) == -1 )
{
operator delete(this[18]);
v3 = (char *)(this + 14);
this[12] = this + 14;
*((_DWORD *)this + 27) = 8;
}
else if ( *((_DWORD *)this + 27) >= v2 )
{
v3 = (char *)this[12];
}
else
{
operator delete(this[18]);
this[12] = this + 14;
*((_DWORD *)this + 27) = 8;
v3 = (char *)operator new(4LL * v2);
this[18] = v3;
this[12] = v3;
*((_DWORD *)this + 27) = v2;
}
*((_DWORD *)this + 26) = v2;
result = *((__int16 *)this + 1);
if ( v3 != &v3[4 * result + 4] )
result = memset(v3, 0LL, 4 * result + 4);
*(_BYTE *)this |= 0x20u;
return result;
}
|
initFaceSizes:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOVSX EBP,word ptr [RDI + 0x2]
INC EBP
JNZ 0x001a5dad
MOV RDI,qword ptr [RBX + 0x90]
CALL 0x0013a0a0
LEA RDI,[RBX + 0x70]
MOV qword ptr [RBX + 0x60],RDI
MOV dword ptr [RBX + 0x6c],0x8
JMP 0x001a5def
LAB_001a5dad:
CMP dword ptr [RBX + 0x6c],EBP
JNC 0x001a5deb
MOV RDI,qword ptr [RBX + 0x90]
CALL 0x0013a0a0
LEA RAX,[RBX + 0x70]
MOV qword ptr [RBX + 0x60],RAX
MOV dword ptr [RBX + 0x6c],0x8
MOV EDI,EBP
SHL RDI,0x2
CALL 0x0013a210
MOV RDI,RAX
MOV qword ptr [RBX + 0x90],RAX
MOV qword ptr [RBX + 0x60],RAX
MOV dword ptr [RBX + 0x6c],EBP
JMP 0x001a5def
LAB_001a5deb:
MOV RDI,qword ptr [RBX + 0x60]
LAB_001a5def:
MOV dword ptr [RBX + 0x68],EBP
MOVSX RAX,word ptr [RBX + 0x2]
LEA RCX,[RDI + RAX*0x4]
ADD RCX,0x4
CMP RDI,RCX
JZ 0x001a5e13
LEA RDX,[0x4 + RAX*0x4]
XOR ESI,ESI
CALL 0x001391a0
LAB_001a5e13:
OR byte ptr [RBX],0x20
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Bfr::VertexDescriptor::initFaceSizes() */
void __thiscall OpenSubdiv::v3_6_0::Bfr::VertexDescriptor::initFaceSizes(VertexDescriptor *this)
{
VertexDescriptor *__s;
uint uVar1;
uVar1 = (int)*(short *)(this + 2) + 1;
if (uVar1 == 0) {
operator_delete(*(void **)(this + 0x90));
__s = this + 0x70;
*(VertexDescriptor **)(this + 0x60) = __s;
*(int4 *)(this + 0x6c) = 8;
}
else if (*(uint *)(this + 0x6c) < uVar1) {
operator_delete(*(void **)(this + 0x90));
*(VertexDescriptor **)(this + 0x60) = this + 0x70;
*(int4 *)(this + 0x6c) = 8;
__s = (VertexDescriptor *)operator_new((ulong)uVar1 << 2);
*(VertexDescriptor **)(this + 0x90) = __s;
*(VertexDescriptor **)(this + 0x60) = __s;
*(uint *)(this + 0x6c) = uVar1;
}
else {
__s = *(VertexDescriptor **)(this + 0x60);
}
*(uint *)(this + 0x68) = uVar1;
if (__s != __s + (long)*(short *)(this + 2) * 4 + 4) {
memset(__s,0,(long)*(short *)(this + 2) * 4 + 4);
}
*this = (VertexDescriptor)((byte)*this | 0x20);
return;
}
|
|
66,425 |
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 0x542bc
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 0x5428c
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x5428a
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 0x5423e
jmp 0x542ba
jmp 0x5428e
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x542b8
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 0x5428e
jmp 0x542ba
jmp 0x54322
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 0x54320
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x5431e
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 0x542de
jmp 0x54320
jmp 0x54322
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_542BC
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_5428C
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rax
loc_5423E:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
ja short loc_5428A
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_5423E
loc_5428A:
jmp short loc_542BA
loc_5428C:
jmp short $+2
loc_5428E:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_542B8
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_5428E
loc_542B8:
jmp short $+2
loc_542BA:
jmp short loc_54322
loc_542BC:
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_54320
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rax
loc_542DE:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_5431E
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_542DE
loc_5431E:
jmp short $+2
loc_54320:
jmp short $+2
loc_54322:
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 0x001542bc
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 0x0015428c
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_0015423e:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JA 0x0015428a
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 0x0015423e
LAB_0015428a:
JMP 0x001542ba
LAB_0015428c:
JMP 0x0015428e
LAB_0015428e:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x001542b8
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 0x0015428e
LAB_001542b8:
JMP 0x001542ba
LAB_001542ba:
JMP 0x00154322
LAB_001542bc:
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 0x00154320
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_001542de:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x0015431e
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 0x001542de
LAB_0015431e:
JMP 0x00154320
LAB_00154320:
JMP 0x00154322
LAB_00154322:
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;
}
|
|
66,426 |
JS_NewRuntime2
|
bluesky950520[P]quickjs/quickjs.c
|
JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
{
JSRuntime *rt;
JSMallocState ms;
memset(&ms, 0, sizeof(ms));
ms.opaque = opaque;
ms.malloc_limit = 0;
rt = mf->js_calloc(opaque, 1, sizeof(JSRuntime));
if (!rt)
return NULL;
rt->mf = *mf;
if (!rt->mf.js_malloc_usable_size) {
/* use dummy function if none provided */
rt->mf.js_malloc_usable_size = js_malloc_usable_size_unknown;
}
/* Inline what js_malloc_rt does since we cannot use it here. */
ms.malloc_count++;
ms.malloc_size += rt->mf.js_malloc_usable_size(rt) + MALLOC_OVERHEAD;
rt->malloc_state = ms;
rt->malloc_gc_threshold = 256 * 1024;
bf_context_init(&rt->bf_ctx, js_bf_realloc, rt);
init_list_head(&rt->context_list);
init_list_head(&rt->gc_obj_list);
init_list_head(&rt->gc_zero_ref_count_list);
rt->gc_phase = JS_GC_PHASE_NONE;
#ifdef DUMP_LEAKS
init_list_head(&rt->string_list);
#endif
init_list_head(&rt->job_list);
if (JS_InitAtoms(rt))
goto fail;
/* create the object, array and function classes */
if (init_class_range(rt, js_std_class_def, JS_CLASS_OBJECT,
countof(js_std_class_def)) < 0)
goto fail;
rt->class_array[JS_CLASS_ARGUMENTS].exotic = &js_arguments_exotic_methods;
rt->class_array[JS_CLASS_STRING].exotic = &js_string_exotic_methods;
rt->class_array[JS_CLASS_MODULE_NS].exotic = &js_module_ns_exotic_methods;
rt->class_array[JS_CLASS_C_FUNCTION].call = js_call_c_function;
rt->class_array[JS_CLASS_C_FUNCTION_DATA].call = js_c_function_data_call;
rt->class_array[JS_CLASS_BOUND_FUNCTION].call = js_call_bound_function;
rt->class_array[JS_CLASS_GENERATOR_FUNCTION].call = js_generator_function_call;
if (init_shape_hash(rt))
goto fail;
rt->js_class_id_alloc = JS_CLASS_INIT_COUNT;
rt->stack_size = JS_DEFAULT_STACK_SIZE;
#ifdef __wasi__
rt->stack_size = 0;
#endif
JS_UpdateStackTop(rt);
rt->current_exception = JS_UNINITIALIZED;
return rt;
fail:
JS_FreeRuntime(rt);
return NULL;
}
|
O2
|
c
|
JS_NewRuntime2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rsi
movl $0x228, %edx # imm = 0x228
movq %r14, %rdi
callq *(%r15)
testq %rax, %rax
je 0x1b049
movq %rax, %rbx
movq 0x20(%r15), %rax
movq %rax, 0x20(%rbx)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
testq %rax, %rax
jne 0x1af82
leaq 0x23b(%rip), %rax # 0x1b1b9
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq *%rax
addq $0x8, %rax
movq $0x1, 0x28(%rbx)
movq %rax, 0x30(%rbx)
andq $0x0, 0x38(%rbx)
movq %r14, 0x40(%rbx)
movq $0x40000, 0xd0(%rbx) # imm = 0x40000
leaq 0x198(%rbx), %rdi
leaq 0x203(%rip), %rsi # 0x1b1bc
movq %rbx, %rdx
callq 0x72fc8
leaq 0x88(%rbx), %rax
movq %rax, 0x88(%rbx)
movq %rax, 0x90(%rbx)
leaq 0x98(%rbx), %rax
movq %rax, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
leaq 0xa8(%rbx), %rax
movq %rax, 0xa8(%rbx)
movq %rax, 0xb0(%rbx)
movb $0x0, 0xc8(%rbx)
movq %rbx, %rax
addq $0x130, %rax # imm = 0x130
movq %rax, 0x130(%rbx)
movq %rax, 0x138(%rbx)
andl $0x0, 0x50(%rbx)
andq $0x0, 0x60(%rbx)
andq $0x0, 0x54(%rbx)
andl $0x0, 0x70(%rbx)
movq %rbx, %rdi
movl $0x100, %esi # imm = 0x100
callq 0x38156
testl %eax, %eax
je 0x1b05d
movq %rbx, %rdi
callq 0x1b842
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6ca9c(%rip), %r14 # 0x87b00
pushq $0x1
popq %r13
cmpl $0xe0, %r13d
je 0x1b0be
xorl %eax, %eax
cmpl $0xd3, %r13d
setae %al
cmpl $0xd2, %r13d
leal 0x1(%rax,%rax), %r12d
pushq $0x4
popq %rax
cmovel %eax, %r12d
movq %r14, %rdi
callq 0xe280
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %r12d, %ecx
callq 0x1e67e
testl %eax, %eax
je 0x1b041
movslq %r15d, %rax
addq %rax, %r14
incq %r14
incl %r13d
jmp 0x1b068
leaq 0x9e5fb(%rip), %rsi # 0xb96c0
pushq $0x1
popq %rdx
pushq $0x2f
popq %rcx
movq %rbx, %rdi
callq 0x1b1c1
testl %eax, %eax
js 0x1b041
movq 0x80(%rbx), %rax
leaq 0x9ea3f(%rip), %rcx # 0xb9b28
movq %rcx, 0x160(%rax)
leaq 0x9ea69(%rip), %rcx # 0xb9b60
movq %rcx, 0xe8(%rax)
leaq 0x9ea93(%rip), %rcx # 0xb9b98
movq %rcx, 0x1d8(%rax)
leaq 0x127(%rip), %rcx # 0x1b23a
movq %rcx, 0x1f8(%rax)
leaq 0x427(%rip), %rcx # 0x1b548
movq %rcx, 0x270(%rax)
leaq 0x4d4(%rip), %rcx # 0x1b603
movq %rcx, 0x248(%rax)
leaq 0x5f3(%rip), %rcx # 0x1b730
movq %rcx, 0x298(%rax)
movabsq $0x1000000004, %rax # imm = 0x1000000004
movq %rax, 0x184(%rbx)
andl $0x0, 0x18c(%rbx)
movl $0x80, %esi
movq %rbx, %rdi
callq 0x1ad58
movq %rax, 0x190(%rbx)
testq %rax, %rax
je 0x1b041
movq %rbp, %rax
movl $0x3d, 0x74(%rbx)
movq $0x100000, 0xd8(%rbx) # imm = 0x100000
movq %rbp, 0xe0(%rbx)
addq $-0x100000, %rax # imm = 0xFFF00000
movq %rax, 0xe8(%rbx)
andl $0x0, 0xf0(%rbx)
movq $0x4, 0xf8(%rbx)
jmp 0x1b04b
|
JS_NewRuntime2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov r15, rdi
push 1
pop rsi
mov edx, 228h
mov rdi, r14
call qword ptr [r15]
test rax, rax
jz loc_1B049
mov rbx, rax
mov rax, [r15+20h]
mov [rbx+20h], rax
movups xmm0, xmmword ptr [r15]
movups xmm1, xmmword ptr [r15+10h]
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
test rax, rax
jnz short loc_1AF82
lea rax, js_malloc_usable_size_unknown
mov [rbx+20h], rax
loc_1AF82:
mov rdi, rbx
call rax
add rax, 8
mov qword ptr [rbx+28h], 1
mov [rbx+30h], rax
and qword ptr [rbx+38h], 0
mov [rbx+40h], r14
mov qword ptr [rbx+0D0h], 40000h
lea rdi, [rbx+198h]
lea rsi, js_bf_realloc
mov rdx, rbx
call bf_context_init
lea rax, [rbx+88h]
mov [rbx+88h], rax
mov [rbx+90h], rax
lea rax, [rbx+98h]
mov [rbx+98h], rax
mov [rbx+0A0h], rax
lea rax, [rbx+0A8h]
mov [rbx+0A8h], rax
mov [rbx+0B0h], rax
mov byte ptr [rbx+0C8h], 0
mov rax, rbx
add rax, 130h
mov [rbx+130h], rax
mov [rbx+138h], rax
and dword ptr [rbx+50h], 0
and qword ptr [rbx+60h], 0
and qword ptr [rbx+54h], 0
and dword ptr [rbx+70h], 0
mov rdi, rbx
mov esi, 100h
call JS_ResizeAtomHash
test eax, eax
jz short loc_1B05D
loc_1B041:
mov rdi, rbx
call JS_FreeRuntime
loc_1B049:
xor ebx, ebx
loc_1B04B:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1B05D:
lea r14, js_atom_init; "null"
push 1
pop r13
loc_1B068:
cmp r13d, 0E0h
jz short loc_1B0BE
xor eax, eax
cmp r13d, 0D3h
setnb al
cmp r13d, 0D2h
lea r12d, [rax+rax+1]
push 4
pop rax
cmovz r12d, eax
mov rdi, r14
call _strlen
mov r15, rax
mov rdi, rbx
mov rsi, r14
mov edx, r15d
mov ecx, r12d
call __JS_NewAtomInit
test eax, eax
jz short loc_1B041
movsxd rax, r15d
add r14, rax
inc r14
inc r13d
jmp short loc_1B068
loc_1B0BE:
lea rsi, js_std_class_def
push 1
pop rdx
push 2Fh ; '/'
pop rcx
mov rdi, rbx
call init_class_range
test eax, eax
js loc_1B041
mov rax, [rbx+80h]
lea rcx, js_arguments_exotic_methods
mov [rax+160h], rcx
lea rcx, js_string_exotic_methods
mov [rax+0E8h], rcx
lea rcx, js_module_ns_exotic_methods
mov [rax+1D8h], rcx
lea rcx, js_call_c_function
mov [rax+1F8h], rcx
lea rcx, js_c_function_data_call
mov [rax+270h], rcx
lea rcx, js_call_bound_function
mov [rax+248h], rcx
lea rcx, js_generator_function_call
mov [rax+298h], rcx
mov rax, 1000000004h
mov [rbx+184h], rax
and dword ptr [rbx+18Ch], 0
mov esi, 80h
mov rdi, rbx
call js_mallocz_rt
mov [rbx+190h], rax
test rax, rax
jz loc_1B041
mov rax, rbp
mov dword ptr [rbx+74h], 3Dh ; '='
mov qword ptr [rbx+0D8h], 100000h
mov [rbx+0E0h], rbp
add rax, 0FFFFFFFFFFF00000h
mov [rbx+0E8h], rax
and dword ptr [rbx+0F0h], 0
mov qword ptr [rbx+0F8h], 4
jmp loc_1B04B
|
long long JS_NewRuntime2(__int128 *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rbx
long long ( *v5)(); // rax
__int128 v6; // xmm0
long long v7; // rax
const char *v9; // r14
unsigned int i; // r13d
unsigned int v11; // r12d
unsigned int v12; // r15d
_QWORD *v13; // rax
long long v14; // rax
long long v15; // [rsp-8h] [rbp-30h]
long long savedregs; // [rsp+28h] [rbp+0h] BYREF
v15 = v2;
v3 = (*(long long ( **)(long long, long long, long long))a1)(a2, 1LL, 552LL);
if ( v3 )
{
v4 = v3;
v5 = (long long ( *)())*((_QWORD *)a1 + 4);
*(_QWORD *)(v4 + 32) = v5;
v6 = *a1;
*(_OWORD *)(v4 + 16) = a1[1];
*(_OWORD *)v4 = v6;
if ( !v5 )
{
v5 = js_malloc_usable_size_unknown;
*(_QWORD *)(v4 + 32) = js_malloc_usable_size_unknown;
}
v7 = ((long long ( *)(long long))v5)(v4);
*(_QWORD *)(v4 + 40) = 1LL;
*(_QWORD *)(v4 + 48) = v7 + 8;
*(_QWORD *)(v4 + 56) = 0LL;
*(_QWORD *)(v4 + 64) = a2;
*(_QWORD *)(v4 + 208) = 0x40000LL;
bf_context_init(v4 + 408, js_bf_realloc, v4);
*(_QWORD *)(v4 + 136) = v4 + 136;
*(_QWORD *)(v4 + 144) = v4 + 136;
*(_QWORD *)(v4 + 152) = v4 + 152;
*(_QWORD *)(v4 + 160) = v4 + 152;
*(_QWORD *)(v4 + 168) = v4 + 168;
*(_QWORD *)(v4 + 176) = v4 + 168;
*(_BYTE *)(v4 + 200) = 0;
*(_QWORD *)(v4 + 304) = v4 + 304;
*(_QWORD *)(v4 + 312) = v4 + 304;
*(_DWORD *)(v4 + 80) = 0;
*(_QWORD *)(v4 + 96) = 0LL;
*(_QWORD *)(v4 + 84) = 0LL;
*(_DWORD *)(v4 + 112) = 0;
if ( !(unsigned int)JS_ResizeAtomHash(v4, 256LL) )
{
v9 = "null";
for ( i = 1; i != 224; ++i )
{
v11 = 2 * (i >= 0xD3) + 1;
if ( i == 210 )
v11 = 4;
v12 = strlen(v9);
if ( !(unsigned int)_JS_NewAtomInit(v4, v9, v12, v11) )
goto LABEL_5;
v9 += (int)v12 + 1;
}
if ( (int)init_class_range(v4, &js_std_class_def, 1LL, 47LL) >= 0 )
{
v13 = *(_QWORD **)(v4 + 128);
v13[44] = &js_arguments_exotic_methods;
v13[29] = &js_string_exotic_methods;
v13[59] = &js_module_ns_exotic_methods;
v13[63] = js_call_c_function;
v13[78] = js_c_function_data_call;
v13[73] = js_call_bound_function;
v13[83] = js_generator_function_call;
*(_QWORD *)(v4 + 388) = 0x1000000004LL;
*(_DWORD *)(v4 + 396) = 0;
v14 = js_mallocz_rt(v4, 0x80uLL);
*(_QWORD *)(v4 + 400) = v14;
if ( v14 )
{
*(_DWORD *)(v4 + 116) = 61;
*(_QWORD *)(v4 + 216) = 0x100000LL;
*(_QWORD *)(v4 + 224) = &savedregs;
*(_QWORD *)(v4 + 232) = &savedregs - 0x20000;
*(_DWORD *)(v4 + 240) = 0;
*(_QWORD *)(v4 + 248) = 4LL;
return v4;
}
}
}
LABEL_5:
JS_FreeRuntime(v4);
}
return 0LL;
}
|
JS_NewRuntime2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV R15,RDI
PUSH 0x1
POP RSI
MOV EDX,0x228
MOV RDI,R14
CALL qword ptr [R15]
TEST RAX,RAX
JZ 0x0011b049
MOV RBX,RAX
MOV RAX,qword ptr [R15 + 0x20]
MOV qword ptr [RBX + 0x20],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS XMM1,xmmword ptr [R15 + 0x10]
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
TEST RAX,RAX
JNZ 0x0011af82
LEA RAX,[0x11b1b9]
MOV qword ptr [RBX + 0x20],RAX
LAB_0011af82:
MOV RDI,RBX
CALL RAX
ADD RAX,0x8
MOV qword ptr [RBX + 0x28],0x1
MOV qword ptr [RBX + 0x30],RAX
AND qword ptr [RBX + 0x38],0x0
MOV qword ptr [RBX + 0x40],R14
MOV qword ptr [RBX + 0xd0],0x40000
LEA RDI,[RBX + 0x198]
LEA RSI,[0x11b1bc]
MOV RDX,RBX
CALL 0x00172fc8
LEA RAX,[RBX + 0x88]
MOV qword ptr [RBX + 0x88],RAX
MOV qword ptr [RBX + 0x90],RAX
LEA RAX,[RBX + 0x98]
MOV qword ptr [RBX + 0x98],RAX
MOV qword ptr [RBX + 0xa0],RAX
LEA RAX,[RBX + 0xa8]
MOV qword ptr [RBX + 0xa8],RAX
MOV qword ptr [RBX + 0xb0],RAX
MOV byte ptr [RBX + 0xc8],0x0
MOV RAX,RBX
ADD RAX,0x130
MOV qword ptr [RBX + 0x130],RAX
MOV qword ptr [RBX + 0x138],RAX
AND dword ptr [RBX + 0x50],0x0
AND qword ptr [RBX + 0x60],0x0
AND qword ptr [RBX + 0x54],0x0
AND dword ptr [RBX + 0x70],0x0
MOV RDI,RBX
MOV ESI,0x100
CALL 0x00138156
TEST EAX,EAX
JZ 0x0011b05d
LAB_0011b041:
MOV RDI,RBX
CALL 0x0011b842
LAB_0011b049:
XOR EBX,EBX
LAB_0011b04b:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011b05d:
LEA R14,[0x187b00]
PUSH 0x1
POP R13
LAB_0011b068:
CMP R13D,0xe0
JZ 0x0011b0be
XOR EAX,EAX
CMP R13D,0xd3
SETNC AL
CMP R13D,0xd2
LEA R12D,[RAX + RAX*0x1 + 0x1]
PUSH 0x4
POP RAX
CMOVZ R12D,EAX
MOV RDI,R14
CALL 0x0010e280
MOV R15,RAX
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R15D
MOV ECX,R12D
CALL 0x0011e67e
TEST EAX,EAX
JZ 0x0011b041
MOVSXD RAX,R15D
ADD R14,RAX
INC R14
INC R13D
JMP 0x0011b068
LAB_0011b0be:
LEA RSI,[0x1b96c0]
PUSH 0x1
POP RDX
PUSH 0x2f
POP RCX
MOV RDI,RBX
CALL 0x0011b1c1
TEST EAX,EAX
JS 0x0011b041
MOV RAX,qword ptr [RBX + 0x80]
LEA RCX,[0x1b9b28]
MOV qword ptr [RAX + 0x160],RCX
LEA RCX,[0x1b9b60]
MOV qword ptr [RAX + 0xe8],RCX
LEA RCX,[0x1b9b98]
MOV qword ptr [RAX + 0x1d8],RCX
LEA RCX,[0x11b23a]
MOV qword ptr [RAX + 0x1f8],RCX
LEA RCX,[0x11b548]
MOV qword ptr [RAX + 0x270],RCX
LEA RCX,[0x11b603]
MOV qword ptr [RAX + 0x248],RCX
LEA RCX,[0x11b730]
MOV qword ptr [RAX + 0x298],RCX
MOV RAX,0x1000000004
MOV qword ptr [RBX + 0x184],RAX
AND dword ptr [RBX + 0x18c],0x0
MOV ESI,0x80
MOV RDI,RBX
CALL 0x0011ad58
MOV qword ptr [RBX + 0x190],RAX
TEST RAX,RAX
JZ 0x0011b041
MOV RAX,RBP
MOV dword ptr [RBX + 0x74],0x3d
MOV qword ptr [RBX + 0xd8],0x100000
MOV qword ptr [RBX + 0xe0],RBP
ADD RAX,-0x100000
MOV qword ptr [RBX + 0xe8],RAX
AND dword ptr [RBX + 0xf0],0x0
MOV qword ptr [RBX + 0xf8],0x4
JMP 0x0011b04b
|
int4 * JS_NewRuntime2(int8 *param_1,int8 param_2)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
int iVar8;
int4 *puVar9;
code *pcVar10;
long lVar11;
size_t sVar12;
char cVar13;
uint uVar14;
char *__s;
puVar9 = (int4 *)(*(code *)*param_1)(param_2,1,0x228);
if (puVar9 != (int4 *)0x0) {
pcVar10 = (code *)param_1[4];
*(code **)(puVar9 + 8) = pcVar10;
uVar1 = *(int4 *)param_1;
uVar2 = *(int4 *)((long)param_1 + 4);
uVar3 = *(int4 *)(param_1 + 1);
uVar4 = *(int4 *)((long)param_1 + 0xc);
uVar5 = *(int4 *)((long)param_1 + 0x14);
uVar6 = *(int4 *)(param_1 + 3);
uVar7 = *(int4 *)((long)param_1 + 0x1c);
puVar9[4] = *(int4 *)(param_1 + 2);
puVar9[5] = uVar5;
puVar9[6] = uVar6;
puVar9[7] = uVar7;
*puVar9 = uVar1;
puVar9[1] = uVar2;
puVar9[2] = uVar3;
puVar9[3] = uVar4;
if (pcVar10 == (code *)0x0) {
pcVar10 = js_malloc_usable_size_unknown;
*(code **)(puVar9 + 8) = js_malloc_usable_size_unknown;
}
lVar11 = (*pcVar10)(puVar9);
*(int8 *)(puVar9 + 10) = 1;
*(long *)(puVar9 + 0xc) = lVar11 + 8;
*(int8 *)(puVar9 + 0xe) = 0;
*(int8 *)(puVar9 + 0x10) = param_2;
*(int8 *)(puVar9 + 0x34) = 0x40000;
bf_context_init(puVar9 + 0x66,js_bf_realloc,puVar9);
*(int4 **)(puVar9 + 0x22) = puVar9 + 0x22;
*(int4 **)(puVar9 + 0x24) = puVar9 + 0x22;
*(int4 **)(puVar9 + 0x26) = puVar9 + 0x26;
*(int4 **)(puVar9 + 0x28) = puVar9 + 0x26;
*(int4 **)(puVar9 + 0x2a) = puVar9 + 0x2a;
*(int4 **)(puVar9 + 0x2c) = puVar9 + 0x2a;
*(int1 *)(puVar9 + 0x32) = 0;
*(int4 **)(puVar9 + 0x4c) = puVar9 + 0x4c;
*(int4 **)(puVar9 + 0x4e) = puVar9 + 0x4c;
puVar9[0x14] = 0;
*(int8 *)(puVar9 + 0x18) = 0;
*(int8 *)(puVar9 + 0x15) = 0;
puVar9[0x1c] = 0;
iVar8 = JS_ResizeAtomHash(puVar9,0x100);
if (iVar8 == 0) {
__s = "null";
for (uVar14 = 1; uVar14 != 0xe0; uVar14 = uVar14 + 1) {
cVar13 = (0xd2 < uVar14) * '\x02' + '\x01';
if (uVar14 == 0xd2) {
cVar13 = '\x04';
}
sVar12 = strlen(__s);
iVar8 = __JS_NewAtomInit(puVar9,__s,sVar12 & 0xffffffff,cVar13);
if (iVar8 == 0) goto LAB_0011b041;
__s = __s + (long)(int)sVar12 + 1;
}
iVar8 = init_class_range(puVar9,&js_std_class_def,1,0x2f);
if (-1 < iVar8) {
lVar11 = *(long *)(puVar9 + 0x20);
*(int1 **)(lVar11 + 0x160) = js_arguments_exotic_methods;
*(int1 **)(lVar11 + 0xe8) = js_string_exotic_methods;
*(int1 **)(lVar11 + 0x1d8) = js_module_ns_exotic_methods;
*(code **)(lVar11 + 0x1f8) = js_call_c_function;
*(code **)(lVar11 + 0x270) = js_c_function_data_call;
*(code **)(lVar11 + 0x248) = js_call_bound_function;
*(code **)(lVar11 + 0x298) = js_generator_function_call;
*(int8 *)(puVar9 + 0x61) = 0x1000000004;
puVar9[99] = 0;
lVar11 = js_mallocz_rt(puVar9,0x80);
*(long *)(puVar9 + 100) = lVar11;
if (lVar11 != 0) {
puVar9[0x1d] = 0x3d;
*(int8 *)(puVar9 + 0x36) = 0x100000;
*(int1 **)(puVar9 + 0x38) = &stack0xfffffffffffffff8;
*(int1 **)(puVar9 + 0x3a) = &stack0xffffffffffeffff8;
puVar9[0x3c] = 0;
*(int8 *)(puVar9 + 0x3e) = 4;
return puVar9;
}
}
}
LAB_0011b041:
JS_FreeRuntime(puVar9);
}
return (int4 *)0x0;
}
|
|
66,427 |
long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const
|
llama.cpp/common/minja/minja.hpp
|
T get(const std::string & key, T default_value) const {
if (!contains(key)) return default_value;
return at(key).get<T>();
}
|
O3
|
cpp
|
long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xc1310
testb %al, %al
je 0xc12f0
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbb522
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbf96a
movq %rax, %rdi
callq 0xc145a
movq %rax, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x84776
movq %r14, %rdi
callq 0x88e90
leaq 0x38(%rsp), %rdi
callq 0x6fdfa
leaq 0x28(%rsp), %rdi
callq 0x6fdfa
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x6fdfa
movq -0x10(%r14), %rdi
testq %rdi, %rdi
je 0xc12f0
movq 0xa3ccd(%rip), %rax # 0x164f98
cmpb $0x0, (%rax)
je 0xc12db
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xc12e5
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xc12f0
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb57b8
movq %rbx, %rdi
callq 0x21af0
|
_ZNK5minja5Value3getIlEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES2_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rdx
mov r15, rsi
mov r14, rdi
call _ZNK5minja5Value8containsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::contains(std::string const&)
test al, al
jz loc_C12F0
mov rbx, rsp
mov rdi, rbx
mov rsi, r15
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, r14; this
mov rsi, rbx; minja::Value *
call _ZN5minja5Value2atERKS0_; minja::Value::at(minja::Value const&)
mov rdi, rax
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rbx, rax
lea r14, [rsp+68h+var_28]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+68h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea r14, [rsp+68h+var_50]
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [r14-10h]
test rdi, rdi
jz short loc_C12F0
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_C12DB
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_C12E5
loc_C12DB:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_C12E5:
cmp eax, 1
jnz short loc_C12F0
mov rax, [rdi]
call qword ptr [rax+18h]
loc_C12F0:
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
|
long long minja::Value::get<long>(minja::Value *this, long long a2, long long a3)
{
unsigned long long v4; // rax
long long v5; // rdi
signed __int32 v6; // eax
long long v8; // [rsp+0h] [rbp-68h] BYREF
long long v9; // [rsp+8h] [rbp-60h]
volatile signed __int32 *v10; // [rsp+18h] [rbp-50h] BYREF
volatile signed __int32 *v11; // [rsp+28h] [rbp-40h] BYREF
volatile signed __int32 *v12; // [rsp+38h] [rbp-30h] BYREF
char v13[40]; // [rsp+40h] [rbp-28h] BYREF
if ( (unsigned __int8)minja::Value::contains() )
{
minja::Value::Value((long long)&v8, a2);
v4 = minja::Value::at(this, (const minja::Value *)&v8);
a3 = minja::Value::get<long>(v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v12);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v11);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v10);
v5 = v9;
if ( v9 )
{
if ( _libc_single_threaded )
{
v6 = *(_DWORD *)(v9 + 12);
*(_DWORD *)(v9 + 12) = v6 - 1;
}
else
{
v6 = _InterlockedExchangeAdd((volatile signed __int32 *)(v9 + 12), 0xFFFFFFFF);
}
if ( v6 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v5 + 24LL))(v5, 0LL);
}
}
return a3;
}
|
get<long>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CALL 0x001c1310
TEST AL,AL
JZ 0x001c12f0
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R15
CALL 0x001bb522
LAB_001c126d:
MOV RDI,R14
MOV RSI,RBX
CALL 0x001bf96a
MOV RDI,RAX
CALL 0x001c145a
LAB_001c1280:
MOV RBX,RAX
LEA R14,[RSP + 0x40]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00184776
MOV RDI,R14
CALL 0x00188e90
LEA RDI,[RSP + 0x38]
CALL 0x0016fdfa
LEA RDI,[RSP + 0x28]
CALL 0x0016fdfa
LEA R14,[RSP + 0x18]
MOV RDI,R14
CALL 0x0016fdfa
MOV RDI,qword ptr [R14 + -0x10]
TEST RDI,RDI
JZ 0x001c12f0
MOV RAX,qword ptr [0x00264f98]
CMP byte ptr [RAX],0x0
JZ 0x001c12db
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001c12e5
LAB_001c12db:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001c12e5:
CMP EAX,0x1
JNZ 0x001c12f0
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001c12f0:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* long minja::Value::get<long>(std::__cxx11::string const&, long) const */
long __thiscall minja::Value::get<long>(Value *this,string *param_1,long param_2)
{
int *piVar1;
char cVar2;
int iVar3;
Value *this_00;
Value aVStack_68 [8];
long *local_60;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_50 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_40 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_30 [8];
data local_28 [16];
cVar2 = contains(this,param_1);
if (cVar2 != '\0') {
Value(aVStack_68,param_1);
/* try { // try from 001c126d to 001c127f has its CatchHandler @ 001c12fd */
this_00 = (Value *)at(this,aVStack_68);
param_2 = get<long>(this_00);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_28,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_28);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_50);
if (local_60 != (long *)0x0) {
if (*PTR___libc_single_threaded_00264f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_60 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_60 + 0xc);
*(int *)((long)local_60 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_60 + 0x18))();
}
}
}
return param_2;
}
|
|
66,428 |
my_hash_reset
|
eloqsql/mysys/hash.c
|
void my_hash_reset(HASH *hash)
{
DBUG_ENTER("my_hash_reset");
DBUG_PRINT("enter",("hash:%p", hash));
my_hash_free_elements(hash);
reset_dynamic(&hash->array);
/* Set row pointers so that the hash can be reused at once */
hash->blength= 1;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
my_hash_reset:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x74f1e
movq -0x8(%rbp), %rdi
callq 0x74e80
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x10(%rax)
jmp 0x74f40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_reset:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_74F1E:
mov rdi, [rbp+var_8]
call my_hash_free_elements
mov rax, [rbp+var_8]
mov dword ptr [rax+30h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 1
jmp short $+2
loc_74F40:
add rsp, 10h
pop rbp
retn
|
unsigned long long my_hash_reset(unsigned long long a1)
{
unsigned long long result; // rax
my_hash_free_elements(a1);
*(_DWORD *)(a1 + 48) = 0;
result = a1;
*(_QWORD *)(a1 + 16) = 1LL;
return result;
}
|
my_hash_reset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x00174f1e
LAB_00174f1e:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00174e80
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x1
JMP 0x00174f40
LAB_00174f40:
ADD RSP,0x10
POP RBP
RET
|
void my_hash_reset(long param_1)
{
my_hash_free_elements(param_1);
*(int4 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x10) = 1;
return;
}
|
|
66,429 |
gz_write
|
3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/gzwrite.c
|
local z_size_t gz_write(state, buf, len)
gz_statep state;
voidpc buf;
z_size_t len;
{
z_size_t put = len;
/* if len is zero, avoid unnecessary operations */
if (len == 0)
return 0;
/* allocate memory if this is the first time through */
if (state->size == 0 && gz_init(state) == -1)
return 0;
/* check for seek request */
if (state->seek) {
state->seek = 0;
if (gz_zero(state, state->skip) == -1)
return 0;
}
/* for small len, copy to input buffer, otherwise compress directly */
if (len < state->size) {
/* copy to input buffer, compress when full */
do {
unsigned have, copy;
if (state->strm.avail_in == 0)
state->strm.next_in = state->in;
have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
state->in);
copy = state->size - have;
if (copy > len)
copy = (unsigned)len;
memcpy(state->in + have, buf, copy);
state->strm.avail_in += copy;
state->x.pos += copy;
buf = (const char *)buf + copy;
len -= copy;
if (len && gz_comp(state, Z_NO_FLUSH) == -1)
return 0;
} while (len);
}
else {
/* consume whatever's left in the input buffer */
if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
return 0;
/* directly compress user buffer to file */
state->strm.next_in = (z_const Bytef *)buf;
do {
unsigned n = (unsigned)-1;
if (n > len)
n = (unsigned)len;
state->strm.avail_in = n;
state->x.pos += n;
if (gz_comp(state, Z_NO_FLUSH) == -1)
return 0;
len -= n;
} while (len);
}
/* input was all buffered or compressed */
return put;
}
|
O3
|
c
|
gz_write:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x8352
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x0, 0x28(%rdi)
jne 0x825a
movq %r14, %rdi
callq 0x86ca
cmpl $-0x1, %eax
je 0x8352
cmpl $0x0, 0x70(%r14)
je 0x827e
movl $0x0, 0x70(%r14)
movq 0x68(%r14), %rsi
movq %r14, %rdi
callq 0x8491
cmpl $-0x1, %eax
je 0x8352
movl 0x28(%r14), %eax
cmpq %rbx, %rax
jbe 0x82fb
movq %rbx, %r13
movl 0x88(%r14), %edx
testq %rdx, %rdx
je 0x82a3
movq 0x30(%r14), %rax
movq 0x80(%r14), %rcx
jmp 0x82b1
movq 0x30(%r14), %rax
movq %rax, 0x80(%r14)
movq %rax, %rcx
addq %rdx, %rcx
subq %rax, %rcx
movl 0x28(%r14), %edx
subl %ecx, %edx
cmpq %rdx, %r13
movl %r13d, %r12d
cmovael %edx, %r12d
movl %ecx, %edi
addq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x31b0
addl %r12d, 0x88(%r14)
addq %r12, 0x10(%r14)
subq %r12, %r13
je 0x8354
addq %r12, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x87c1
cmpl $-0x1, %eax
jne 0x828a
jmp 0x8352
cmpl $0x0, 0x88(%r14)
je 0x8314
movq %r14, %rdi
xorl %esi, %esi
callq 0x87c1
cmpl $-0x1, %eax
je 0x8352
movq %r15, 0x80(%r14)
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movq %rbx, %r12
cmpq %r15, %r12
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmovbq %r12, %r13
movl %r13d, 0x88(%r14)
addq %r13, 0x10(%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0x87c1
cmpl $-0x1, %eax
je 0x8352
subq %r13, %r12
jne 0x8324
jmp 0x8354
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
gz_write:
push r15
push r14
push r13
push r12
push rbx
test rdx, rdx
jz loc_8352
mov rbx, rdx
mov r15, rsi
mov r14, rdi
cmp dword ptr [rdi+28h], 0
jnz short loc_825A
mov rdi, r14
call gz_init
cmp eax, 0FFFFFFFFh
jz loc_8352
loc_825A:
cmp dword ptr [r14+70h], 0
jz short loc_827E
mov dword ptr [r14+70h], 0
mov rsi, [r14+68h]
mov rdi, r14
call gz_zero
cmp eax, 0FFFFFFFFh
jz loc_8352
loc_827E:
mov eax, [r14+28h]
cmp rax, rbx
jbe short loc_82FB
mov r13, rbx
loc_828A:
mov edx, [r14+88h]
test rdx, rdx
jz short loc_82A3
mov rax, [r14+30h]
mov rcx, [r14+80h]
jmp short loc_82B1
loc_82A3:
mov rax, [r14+30h]
mov [r14+80h], rax
mov rcx, rax
loc_82B1:
add rcx, rdx
sub rcx, rax
mov edx, [r14+28h]
sub edx, ecx
cmp r13, rdx
mov r12d, r13d
cmovnb r12d, edx
mov edi, ecx
add rdi, rax
mov rsi, r15
mov rdx, r12
call _memcpy
add [r14+88h], r12d
add [r14+10h], r12
sub r13, r12
jz short loc_8354
add r15, r12
mov rdi, r14
xor esi, esi
call gz_comp
cmp eax, 0FFFFFFFFh
jnz short loc_828A
jmp short loc_8352
loc_82FB:
cmp dword ptr [r14+88h], 0
jz short loc_8314
mov rdi, r14
xor esi, esi
call gz_comp
cmp eax, 0FFFFFFFFh
jz short loc_8352
loc_8314:
mov [r14+80h], r15
mov r15d, 0FFFFFFFFh
mov r12, rbx
loc_8324:
cmp r12, r15
mov r13d, 0FFFFFFFFh
cmovb r13, r12
mov [r14+88h], r13d
add [r14+10h], r13
mov rdi, r14
xor esi, esi
call gz_comp
cmp eax, 0FFFFFFFFh
jz short loc_8352
sub r12, r13
jnz short loc_8324
jmp short loc_8354
loc_8352:
xor ebx, ebx
loc_8354:
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
unsigned long long gz_write(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rbx
long long v4; // r15
unsigned long long v5; // r13
int v6; // edx
long long v7; // rax
long long v8; // rcx
unsigned int v9; // ecx
unsigned long long v10; // rdx
long long v11; // r12
unsigned long long v12; // r12
long long v13; // r13
if ( !a3 )
return 0LL;
v3 = a3;
v4 = a2;
if ( !*(_DWORD *)(a1 + 40) && (unsigned int)gz_init(a1) == -1 )
return 0LL;
if ( *(_DWORD *)(a1 + 112) )
{
*(_DWORD *)(a1 + 112) = 0;
if ( (unsigned int)gz_zero(a1, *(_QWORD *)(a1 + 104)) == -1 )
return 0LL;
}
if ( *(unsigned int *)(a1 + 40) <= v3 )
{
if ( !*(_DWORD *)(a1 + 136) || (unsigned int)gz_comp(a1, 0LL) != -1 )
{
*(_QWORD *)(a1 + 128) = a2;
v12 = v3;
while ( 1 )
{
v13 = 0xFFFFFFFFLL;
if ( v12 < 0xFFFFFFFF )
v13 = v12;
*(_DWORD *)(a1 + 136) = v13;
*(_QWORD *)(a1 + 16) += v13;
if ( (unsigned int)gz_comp(a1, 0LL) == -1 )
break;
v12 -= v13;
if ( !v12 )
return v3;
}
}
return 0LL;
}
v5 = v3;
while ( 1 )
{
v6 = *(_DWORD *)(a1 + 136);
v7 = *(_QWORD *)(a1 + 48);
if ( v6 )
{
v8 = *(_QWORD *)(a1 + 128);
}
else
{
*(_QWORD *)(a1 + 128) = v7;
LODWORD(v8) = v7;
}
v9 = v6 + v8 - v7;
v10 = *(_DWORD *)(a1 + 40) - v9;
v11 = (unsigned int)v5;
if ( v5 >= v10 )
v11 = (unsigned int)v10;
memcpy(v7 + v9, v4, v11);
*(_DWORD *)(a1 + 136) += v11;
*(_QWORD *)(a1 + 16) += v11;
v5 -= v11;
if ( !v5 )
break;
v4 += v11;
if ( (unsigned int)gz_comp(a1, 0LL) == -1 )
return 0LL;
}
return v3;
}
|
gz_write:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
TEST RDX,RDX
JZ 0x00108352
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CMP dword ptr [RDI + 0x28],0x0
JNZ 0x0010825a
MOV RDI,R14
CALL 0x001086ca
CMP EAX,-0x1
JZ 0x00108352
LAB_0010825a:
CMP dword ptr [R14 + 0x70],0x0
JZ 0x0010827e
MOV dword ptr [R14 + 0x70],0x0
MOV RSI,qword ptr [R14 + 0x68]
MOV RDI,R14
CALL 0x00108491
CMP EAX,-0x1
JZ 0x00108352
LAB_0010827e:
MOV EAX,dword ptr [R14 + 0x28]
CMP RAX,RBX
JBE 0x001082fb
MOV R13,RBX
LAB_0010828a:
MOV EDX,dword ptr [R14 + 0x88]
TEST RDX,RDX
JZ 0x001082a3
MOV RAX,qword ptr [R14 + 0x30]
MOV RCX,qword ptr [R14 + 0x80]
JMP 0x001082b1
LAB_001082a3:
MOV RAX,qword ptr [R14 + 0x30]
MOV qword ptr [R14 + 0x80],RAX
MOV RCX,RAX
LAB_001082b1:
ADD RCX,RDX
SUB RCX,RAX
MOV EDX,dword ptr [R14 + 0x28]
SUB EDX,ECX
CMP R13,RDX
MOV R12D,R13D
CMOVNC R12D,EDX
MOV EDI,ECX
ADD RDI,RAX
MOV RSI,R15
MOV RDX,R12
CALL 0x001031b0
ADD dword ptr [R14 + 0x88],R12D
ADD qword ptr [R14 + 0x10],R12
SUB R13,R12
JZ 0x00108354
ADD R15,R12
MOV RDI,R14
XOR ESI,ESI
CALL 0x001087c1
CMP EAX,-0x1
JNZ 0x0010828a
JMP 0x00108352
LAB_001082fb:
CMP dword ptr [R14 + 0x88],0x0
JZ 0x00108314
MOV RDI,R14
XOR ESI,ESI
CALL 0x001087c1
CMP EAX,-0x1
JZ 0x00108352
LAB_00108314:
MOV qword ptr [R14 + 0x80],R15
MOV R15D,0xffffffff
MOV R12,RBX
LAB_00108324:
CMP R12,R15
MOV R13D,0xffffffff
CMOVC R13,R12
MOV dword ptr [R14 + 0x88],R13D
ADD qword ptr [R14 + 0x10],R13
MOV RDI,R14
XOR ESI,ESI
CALL 0x001087c1
CMP EAX,-0x1
JZ 0x00108352
SUB R12,R13
JNZ 0x00108324
JMP 0x00108354
LAB_00108352:
XOR EBX,EBX
LAB_00108354:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
ulong gz_write(long param_1,void *param_2,ulong param_3)
{
int iVar1;
long lVar2;
uint uVar3;
uint uVar4;
size_t __n;
ulong uVar5;
ulong uVar6;
if ((param_3 != 0) && ((*(int *)(param_1 + 0x28) != 0 || (iVar1 = gz_init(param_1), iVar1 != -1)))
) {
if (*(int *)(param_1 + 0x70) != 0) {
*(int4 *)(param_1 + 0x70) = 0;
iVar1 = gz_zero(param_1,*(int8 *)(param_1 + 0x68));
if (iVar1 == -1) {
return 0;
}
}
uVar5 = param_3;
if (param_3 < *(uint *)(param_1 + 0x28)) {
do {
if (*(int *)(param_1 + 0x88) == 0) {
lVar2 = *(long *)(param_1 + 0x30);
*(long *)(param_1 + 0x80) = lVar2;
iVar1 = (int)lVar2;
}
else {
lVar2 = *(long *)(param_1 + 0x30);
iVar1 = (int)*(int8 *)(param_1 + 0x80);
}
uVar3 = (iVar1 + *(int *)(param_1 + 0x88)) - (int)lVar2;
uVar4 = *(int *)(param_1 + 0x28) - uVar3;
__n = uVar5 & 0xffffffff;
if (uVar4 <= uVar5) {
__n = (size_t)uVar4;
}
memcpy((void *)((ulong)uVar3 + lVar2),param_2,__n);
*(int *)(param_1 + 0x88) = *(int *)(param_1 + 0x88) + (int)__n;
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) + __n;
if (uVar5 - __n == 0) {
return param_3;
}
param_2 = (void *)((long)param_2 + __n);
iVar1 = gz_comp(param_1,0);
uVar5 = uVar5 - __n;
} while (iVar1 != -1);
}
else if ((*(int *)(param_1 + 0x88) == 0) || (iVar1 = gz_comp(param_1,0), iVar1 != -1)) {
*(void **)(param_1 + 0x80) = param_2;
while( true ) {
uVar6 = 0xffffffff;
if (uVar5 < 0xffffffff) {
uVar6 = uVar5;
}
*(int *)(param_1 + 0x88) = (int)uVar6;
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) + uVar6;
iVar1 = gz_comp(param_1,0);
if (iVar1 == -1) break;
uVar5 = uVar5 - uVar6;
if (uVar5 == 0) {
return param_3;
}
}
}
}
return 0;
}
|
|
66,430 |
my_thread_end
|
eloqsql/mysys/my_thr_init.c
|
void my_thread_end(void)
{
struct st_my_thread_var *tmp;
tmp= my_thread_var;
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_end(): tmp: %p pthread_self: %p thread_id: %ld\n",
tmp, pthread_self(), tmp ? (long) tmp->id : 0L);
#endif
/*
Remove the instrumentation for this thread.
This must be done before trashing st_my_thread_var,
because the LF_HASH depends on it.
*/
PSI_CALL_delete_current_thread();
/*
We need to disable DBUG early for this thread to ensure that the
the mutex calls doesn't enable it again
To this we have to both do DBUG_POP() and also reset THR_KEY_mysys
as the key is used by DBUG.
*/
DBUG_POP();
set_mysys_var(NULL);
if (tmp && tmp->init)
{
#if !defined(DBUG_OFF)
/* tmp->dbug is allocated inside DBUG library */
if (tmp->dbug)
{
free(tmp->dbug);
tmp->dbug=0;
}
#endif
my_thread_destory_thr_mutex(tmp);
/*
Decrement counter for number of running threads. We are using this
in my_thread_global_end() to wait until all threads have called
my_thread_end and thus freed all memory they have allocated in
my_thread_init() and DBUG_xxxx
*/
mysql_mutex_lock(&THR_LOCK_threads);
DBUG_ASSERT(THR_thread_count != 0);
if (--THR_thread_count == 0)
mysql_cond_signal(&THR_COND_threads);
mysql_mutex_unlock(&THR_LOCK_threads);
/* Trash variable so that we can detect false accesses to my_thread_var */
tmp->init= 2;
free(tmp);
}
}
|
O0
|
c
|
my_thread_end:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xfc1b0
movq %rax, -0x8(%rbp)
leaq 0x1caef8(%rip), %rax # 0x2c75a0
movq (%rax), %rax
callq *0x138(%rax)
jmp 0xfc6b3
xorl %eax, %eax
movl %eax, %edi
callq 0xfc660
cmpq $0x0, -0x8(%rbp)
je 0xfc73c
movq -0x8(%rbp), %rax
movsbl 0xe8(%rax), %eax
cmpl $0x0, %eax
je 0xfc73c
movq -0x8(%rbp), %rdi
callq 0xfc1d0
leaq 0xb8dfe5(%rip), %rdi # 0xc8a6c8
leaq 0x5e9fe(%rip), %rsi # 0x15b0e8
movl $0x175, %edx # imm = 0x175
callq 0xfc510
jmp 0xfc6f6
leaq 0xb8ddcb(%rip), %rax # 0xc8a4c8
movl (%rax), %eax
addl $-0x1, %eax
leaq 0xb8ddbf(%rip), %rcx # 0xc8a4c8
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0xfc71c
leaq 0xb8e041(%rip), %rdi # 0xc8a758
callq 0xfc750
leaq 0xb8dfa5(%rip), %rdi # 0xc8a6c8
callq 0xfc600
movq -0x8(%rbp), %rax
movb $0x2, 0xe8(%rax)
movq -0x8(%rbp), %rdi
callq 0x2a170
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_thread_end:
push rbp
mov rbp, rsp
sub rsp, 10h
call _my_thread_var
mov [rbp+var_8], rax
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+138h]
jmp short $+2
loc_FC6B3:
xor eax, eax
mov edi, eax
call set_mysys_var
cmp [rbp+var_8], 0
jz short loc_FC73C
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax+0E8h]
cmp eax, 0
jz short loc_FC73C
mov rdi, [rbp+var_8]
call my_thread_destory_thr_mutex
lea rdi, THR_LOCK_threads
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 175h
call inline_mysql_mutex_lock_26
jmp short $+2
loc_FC6F6:
lea rax, THR_thread_count
mov eax, [rax]
add eax, 0FFFFFFFFh
lea rcx, THR_thread_count
mov [rcx], eax
cmp eax, 0
jnz short loc_FC71C
lea rdi, THR_COND_threads
call inline_mysql_cond_signal_3
loc_FC71C:
lea rdi, THR_LOCK_threads
call inline_mysql_mutex_unlock_27
mov rax, [rbp+var_8]
mov byte ptr [rax+0E8h], 2
mov rdi, [rbp+var_8]
call _free
loc_FC73C:
add rsp, 10h
pop rbp
retn
|
long long my_thread_end(long long a1, const char *a2)
{
long long result; // rax
long long v3; // [rsp+8h] [rbp-8h]
v3 = my_thread_var(a1, a2);
PSI_server[39]();
result = set_mysys_var(0LL);
if ( v3 )
{
result = (unsigned int)*(char *)(v3 + 232);
if ( *(_BYTE *)(v3 + 232) )
{
my_thread_destory_thr_mutex(v3);
inline_mysql_mutex_lock_26(
(long long)&THR_LOCK_threads,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
0x175u);
if ( !--THR_thread_count )
inline_mysql_cond_signal_3(&THR_COND_threads);
inline_mysql_mutex_unlock_27((long long)&THR_LOCK_threads);
*(_BYTE *)(v3 + 232) = 2;
return free(v3);
}
}
return result;
}
|
my_thread_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CALL 0x001fc1b0
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[0x3c75a0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x138]
JMP 0x001fc6b3
LAB_001fc6b3:
XOR EAX,EAX
MOV EDI,EAX
CALL 0x001fc660
CMP qword ptr [RBP + -0x8],0x0
JZ 0x001fc73c
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + 0xe8]
CMP EAX,0x0
JZ 0x001fc73c
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001fc1d0
LEA RDI,[0xd8a6c8]
LEA RSI,[0x25b0e8]
MOV EDX,0x175
CALL 0x001fc510
JMP 0x001fc6f6
LAB_001fc6f6:
LEA RAX,[0xd8a4c8]
MOV EAX,dword ptr [RAX]
ADD EAX,-0x1
LEA RCX,[0xd8a4c8]
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JNZ 0x001fc71c
LEA RDI,[0xd8a758]
CALL 0x001fc750
LAB_001fc71c:
LEA RDI,[0xd8a6c8]
CALL 0x001fc600
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xe8],0x2
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012a170
LAB_001fc73c:
ADD RSP,0x10
POP RBP
RET
|
void my_thread_end(void)
{
void *__ptr;
__ptr = (void *)_my_thread_var();
(**(code **)(PSI_server + 0x138))();
set_mysys_var(0);
if ((__ptr != (void *)0x0) && (*(char *)((long)__ptr + 0xe8) != '\0')) {
my_thread_destory_thr_mutex(__ptr);
inline_mysql_mutex_lock
(THR_LOCK_threads,"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",0x175
);
THR_thread_count = THR_thread_count + -1;
if (THR_thread_count == 0) {
inline_mysql_cond_signal(THR_COND_threads);
}
inline_mysql_mutex_unlock(THR_LOCK_threads);
*(int1 *)((long)__ptr + 0xe8) = 2;
free(__ptr);
}
return;
}
|
|
66,431 |
my_thread_end
|
eloqsql/mysys/my_thr_init.c
|
void my_thread_end(void)
{
struct st_my_thread_var *tmp;
tmp= my_thread_var;
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_end(): tmp: %p pthread_self: %p thread_id: %ld\n",
tmp, pthread_self(), tmp ? (long) tmp->id : 0L);
#endif
/*
Remove the instrumentation for this thread.
This must be done before trashing st_my_thread_var,
because the LF_HASH depends on it.
*/
PSI_CALL_delete_current_thread();
/*
We need to disable DBUG early for this thread to ensure that the
the mutex calls doesn't enable it again
To this we have to both do DBUG_POP() and also reset THR_KEY_mysys
as the key is used by DBUG.
*/
DBUG_POP();
set_mysys_var(NULL);
if (tmp && tmp->init)
{
#if !defined(DBUG_OFF)
/* tmp->dbug is allocated inside DBUG library */
if (tmp->dbug)
{
free(tmp->dbug);
tmp->dbug=0;
}
#endif
my_thread_destory_thr_mutex(tmp);
/*
Decrement counter for number of running threads. We are using this
in my_thread_global_end() to wait until all threads have called
my_thread_end and thus freed all memory they have allocated in
my_thread_init() and DBUG_xxxx
*/
mysql_mutex_lock(&THR_LOCK_threads);
DBUG_ASSERT(THR_thread_count != 0);
if (--THR_thread_count == 0)
mysql_cond_signal(&THR_COND_threads);
mysql_mutex_unlock(&THR_LOCK_threads);
/* Trash variable so that we can detect false accesses to my_thread_var */
tmp->init= 2;
free(tmp);
}
}
|
O3
|
c
|
my_thread_end:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xb68277(%rip), %r15 # 0xc0ea74
movl (%r15), %edi
callq 0x2a860
movq %rax, %rbx
leaq 0x2e5bb9(%rip), %r14 # 0x38c3c8
movq (%r14), %rax
callq *0x138(%rax)
movl (%r15), %edi
xorl %esi, %esi
callq 0x2a2e0
testq %rbx, %rbx
je 0xa68a0
cmpb $0x0, 0xe8(%rbx)
je 0xa68a0
movq %rbx, %rdi
callq 0xa6411
leaq 0xb68169(%rip), %r15 # 0xc0e9a8
cmpq $0x0, 0x40(%r15)
jne 0xa68ab
leaq 0xb6815b(%rip), %rdi # 0xc0e9a8
callq 0x2a1f0
leaq 0xb67f4f(%rip), %rax # 0xc0e7a8
decl (%rax)
jne 0xa6879
leaq 0xb681d4(%rip), %rax # 0xc0ea38
movq 0x30(%rax), %rdi
testq %rdi, %rdi
jne 0xa68bd
leaq 0xb681c4(%rip), %rdi # 0xc0ea38
callq 0x2a5b0
movq 0x40(%r15), %rdi
testq %rdi, %rdi
jne 0xa68b2
leaq 0xb6811f(%rip), %rdi # 0xc0e9a8
callq 0x2a1c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a160
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x30b1d
jmp 0xa6852
movq (%r14), %rax
callq *0x160(%rax)
jmp 0xa6882
movq (%r14), %rax
callq *0x170(%rax)
jmp 0xa686d
|
my_thread_end:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
lea r15, THR_KEY_mysys
mov edi, [r15]
call _pthread_getspecific
mov rbx, rax
lea r14, PSI_server
mov rax, [r14]
call qword ptr [rax+138h]
mov edi, [r15]
xor esi, esi
call _pthread_setspecific
test rbx, rbx
jz short loc_A68A0
cmp byte ptr [rbx+0E8h], 0
jz short loc_A68A0
mov rdi, rbx
call my_thread_destory_thr_mutex
lea r15, THR_LOCK_threads
cmp qword ptr [r15+40h], 0
jnz short loc_A68AB
lea rdi, THR_LOCK_threads
call _pthread_mutex_lock
loc_A6852:
lea rax, THR_thread_count
dec dword ptr [rax]
jnz short loc_A6879
lea rax, THR_COND_threads
mov rdi, [rax+30h]
test rdi, rdi
jnz short loc_A68BD
loc_A686D:
lea rdi, THR_COND_threads
call _pthread_cond_signal
loc_A6879:
mov rdi, [r15+40h]
test rdi, rdi
jnz short loc_A68B2
loc_A6882:
lea rdi, THR_LOCK_threads
call _pthread_mutex_unlock
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _free
loc_A68A0:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_A68AB:
call my_thread_end_cold_1
jmp short loc_A6852
loc_A68B2:
mov rax, [r14]
call qword ptr [rax+160h]
jmp short loc_A6882
loc_A68BD:
mov rax, [r14]
call qword ptr [rax+170h]
jmp short loc_A686D
|
long long my_thread_end()
{
long long v0; // rdi
long long v1; // rbx
long long result; // rax
long long v3; // rdi
long long v4; // rdi
v0 = THR_KEY_mysys;
v1 = pthread_getspecific(THR_KEY_mysys);
((void ( *)(long long))PSI_server[39])(v0);
result = pthread_setspecific(THR_KEY_mysys, 0LL);
if ( v1 && *(_BYTE *)(v1 + 232) )
{
my_thread_destory_thr_mutex(v1);
if ( THR_LOCK_threads[8] )
my_thread_end_cold_1(v1);
else
pthread_mutex_lock(THR_LOCK_threads);
if ( !--THR_thread_count )
{
v3 = THR_COND_threads[6];
if ( v3 )
((void ( *)(long long))PSI_server[46])(v3);
pthread_cond_signal(THR_COND_threads);
}
v4 = THR_LOCK_threads[8];
if ( v4 )
((void ( *)(long long))PSI_server[44])(v4);
pthread_mutex_unlock(THR_LOCK_threads);
return free(v1);
}
return result;
}
|
my_thread_end:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
LEA R15,[0xd0ea74]
MOV EDI,dword ptr [R15]
CALL 0x0012a860
MOV RBX,RAX
LEA R14,[0x48c3c8]
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x138]
MOV EDI,dword ptr [R15]
XOR ESI,ESI
CALL 0x0012a2e0
TEST RBX,RBX
JZ 0x001a68a0
CMP byte ptr [RBX + 0xe8],0x0
JZ 0x001a68a0
MOV RDI,RBX
CALL 0x001a6411
LEA R15,[0xd0e9a8]
CMP qword ptr [R15 + 0x40],0x0
JNZ 0x001a68ab
LEA RDI,[0xd0e9a8]
CALL 0x0012a1f0
LAB_001a6852:
LEA RAX,[0xd0e7a8]
DEC dword ptr [RAX]
JNZ 0x001a6879
LEA RAX,[0xd0ea38]
MOV RDI,qword ptr [RAX + 0x30]
TEST RDI,RDI
JNZ 0x001a68bd
LAB_001a686d:
LEA RDI,[0xd0ea38]
CALL 0x0012a5b0
LAB_001a6879:
MOV RDI,qword ptr [R15 + 0x40]
TEST RDI,RDI
JNZ 0x001a68b2
LAB_001a6882:
LEA RDI,[0xd0e9a8]
CALL 0x0012a1c0
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0012a160
LAB_001a68a0:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001a68ab:
CALL 0x00130b1d
JMP 0x001a6852
LAB_001a68b2:
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x160]
JMP 0x001a6882
LAB_001a68bd:
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x170]
JMP 0x001a686d
|
void my_thread_end(void)
{
void *__ptr;
__ptr = pthread_getspecific(THR_KEY_mysys);
(**(code **)(PSI_server + 0x138))();
pthread_setspecific(THR_KEY_mysys,(void *)0x0);
if ((__ptr != (void *)0x0) && (*(char *)((long)__ptr + 0xe8) != '\0')) {
my_thread_destory_thr_mutex(__ptr);
if (THR_LOCK_threads._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_threads);
}
else {
my_thread_end_cold_1();
}
THR_thread_count = THR_thread_count + -1;
if (THR_thread_count == 0) {
if (THR_COND_threads._48_8_ != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)THR_COND_threads);
}
if (THR_LOCK_threads._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_threads);
free(__ptr);
return;
}
return;
}
|
|
66,432 |
bitmap_lock_set_next
|
eloqsql/mysys/my_bitmap.c
|
uint bitmap_lock_set_next(MY_BITMAP *map)
{
uint bit_found;
bitmap_lock(map);
bit_found= bitmap_set_next(map);
bitmap_unlock(map);
return bit_found;
}
|
O3
|
c
|
bitmap_lock_set_next:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x9db0d
cmpq $0x0, 0x40(%rdi)
jne 0x9db59
callq 0x29200
movq %rbx, %rdi
callq 0x9d2e8
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x9db37
movq (%rbx), %rax
movl %r14d, %edx
movl %r14d, %ecx
andb $0x7, %cl
movl $0x1, %esi
shll %cl, %esi
shrl $0x3, %edx
orb %sil, (%rax,%rdx)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x9db51
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
jne 0x9db6c
movq %rbx, %rdi
callq 0x291c0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3e4b5(%rip), %rsi # 0xdc015
movl $0x81, %edx
callq 0x2eb6f
jmp 0x9db0d
leaq 0x2e849d(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x9db49
|
bitmap_lock_set_next:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov rdi, [rdi+10h]
test rdi, rdi
jz short loc_9DB0D
cmp qword ptr [rdi+40h], 0
jnz short loc_9DB59
call _pthread_mutex_lock
loc_9DB0D:
mov rdi, rbx
call bitmap_get_first
mov r14d, eax
cmp eax, 0FFFFFFFFh
jz short loc_9DB37
mov rax, [rbx]
mov edx, r14d
mov ecx, r14d
and cl, 7
mov esi, 1
shl esi, cl
shr edx, 3
or [rax+rdx], sil
loc_9DB37:
mov rbx, [rbx+10h]
test rbx, rbx
jz short loc_9DB51
mov rdi, [rbx+40h]
test rdi, rdi
jnz short loc_9DB6C
loc_9DB49:
mov rdi, rbx
call _pthread_mutex_unlock
loc_9DB51:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
loc_9DB59:
lea rsi, aWorkspaceLlm4b_40; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 81h
call psi_mutex_lock
jmp short loc_9DB0D
loc_9DB6C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_9DB49
|
long long bitmap_lock_set_next(_QWORD *a1)
{
long long v2; // rdi
unsigned int first; // r14d
long long v4; // rbx
v2 = a1[2];
if ( v2 )
{
if ( *(_QWORD *)(v2 + 64) )
psi_mutex_lock(v2, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/my_bitmap.c", 0x81u);
else
pthread_mutex_lock(v2);
}
first = bitmap_get_first((long long)a1);
if ( first != -1 )
*(_BYTE *)(*a1 + (first >> 3)) |= 1 << (first & 7);
v4 = a1[2];
if ( v4 )
{
if ( *(_QWORD *)(v4 + 64) )
PSI_server[44]();
pthread_mutex_unlock(v4);
}
return first;
}
|
bitmap_lock_set_next:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x10]
TEST RDI,RDI
JZ 0x0019db0d
CMP qword ptr [RDI + 0x40],0x0
JNZ 0x0019db59
CALL 0x00129200
LAB_0019db0d:
MOV RDI,RBX
CALL 0x0019d2e8
MOV R14D,EAX
CMP EAX,-0x1
JZ 0x0019db37
MOV RAX,qword ptr [RBX]
MOV EDX,R14D
MOV ECX,R14D
AND CL,0x7
MOV ESI,0x1
SHL ESI,CL
SHR EDX,0x3
OR byte ptr [RAX + RDX*0x1],SIL
LAB_0019db37:
MOV RBX,qword ptr [RBX + 0x10]
TEST RBX,RBX
JZ 0x0019db51
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JNZ 0x0019db6c
LAB_0019db49:
MOV RDI,RBX
CALL 0x001291c0
LAB_0019db51:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
LAB_0019db59:
LEA RSI,[0x1dc015]
MOV EDX,0x81
CALL 0x0012eb6f
JMP 0x0019db0d
LAB_0019db6c:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0019db49
|
uint bitmap_lock_set_next(long *param_1)
{
byte *pbVar1;
pthread_mutex_t *ppVar2;
uint uVar3;
ppVar2 = (pthread_mutex_t *)param_1[2];
if (ppVar2 != (pthread_mutex_t *)0x0) {
if (*(long *)((long)ppVar2 + 0x40) == 0) {
pthread_mutex_lock(ppVar2);
}
else {
psi_mutex_lock(ppVar2,"/workspace/llm4binary/github2025/eloqsql/mysys/my_bitmap.c",0x81);
}
}
uVar3 = bitmap_get_first(param_1);
if (uVar3 != 0xffffffff) {
pbVar1 = (byte *)(*param_1 + (ulong)(uVar3 >> 3));
*pbVar1 = *pbVar1 | (byte)(1 << ((byte)uVar3 & 7));
}
ppVar2 = (pthread_mutex_t *)param_1[2];
if (ppVar2 != (pthread_mutex_t *)0x0) {
if (*(long *)((long)ppVar2 + 0x40) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(ppVar2);
}
return uVar3;
}
|
|
66,433 |
ok
|
eloqsql/libmariadb/unittest/mytap/tap.c
|
void
ok(int const 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 0x2fee8
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 0x2ff50
movsbl 0x51414(%rip), %eax # 0x81350
cmpl $0x0, %eax
jne 0x2ff50
movl 0x51405(%rip), %eax # 0x8134c
addl $0x1, %eax
movl %eax, 0x513fc(%rip) # 0x8134c
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2ffa0
leaq -0x30(%rbp), %rax
movsbl 0x513e5(%rip), %eax # 0x81350
cmpl $0x0, %eax
je 0x2ff87
leaq 0x3abc7(%rip), %rdi # 0x6ab3e
leaq 0x513c6(%rip), %rsi # 0x81344
addq $0xc, %rsi
callq 0x30070
callq 0x30360
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_2FEE8
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_2FEE8:
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_2FF50
movsx eax, cs:byte_81350
cmp eax, 0
jnz short loc_2FF50
mov eax, cs:dword_8134C
add eax, 1
mov cs:dword_8134C, eax
loc_2FF50:
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_81350
cmp eax, 0
jz short loc_2FF87
lea rdi, aTodo; "todo"
lea rsi, g_test
add rsi, 0Ch
call emit_dir
loc_2FF87:
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_81350 )
++dword_8134C;
vemit_tap(v5, v4, va);
if ( byte_81350 )
emit_dir("todo", &g_test + 3);
return emit_endl();
}
|
ok:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
TEST AL,AL
JZ 0x0012fee8
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_0012fee8:
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 0x0012ff50
MOVSX EAX,byte ptr [0x00181350]
CMP EAX,0x0
JNZ 0x0012ff50
MOV EAX,dword ptr [0x0018134c]
ADD EAX,0x1
MOV dword ptr [0x0018134c],EAX
LAB_0012ff50:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x30]
CALL 0x0012ffa0
LEA RAX,[RBP + -0x30]
MOVSX EAX,byte ptr [0x00181350]
CMP EAX,0x0
JZ 0x0012ff87
LEA RDI,[0x16ab3e]
LEA RSI,[0x181344]
ADD RSI,0xc
CALL 0x00130070
LAB_0012ff87:
CALL 0x00130360
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_00181350 == '\0')) {
DAT_0018134c = DAT_0018134c + 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_00181350 != '\0') {
emit_dir(&DAT_0016ab3e,&DAT_00181350);
}
emit_endl();
return;
}
|
|
66,434 |
ok
|
eloqsql/libmariadb/unittest/mytap/tap.c
|
void
ok(int const 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
subq $0xd0, %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 0x2676d
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 0x2679a
cmpb $0x0, 0x3c6de(%rip) # 0x62e70
jne 0x2679a
incl 0x3c6d2(%rip) # 0x62e6c
leaq -0x20(%rbp), %rdx
callq 0x267fd
cmpb $0x0, 0x3c6c6(%rip) # 0x62e70
je 0x267d7
movq 0x39805(%rip), %rax # 0x5ffb8
movq (%rax), %rdi
leaq 0x24ff7(%rip), %rdx # 0x4b7b4
leaq 0x24f88(%rip), %rcx # 0x4b74c
leaq 0x3c6a5(%rip), %r8 # 0x62e70
movl $0x1, %esi
xorl %eax, %eax
callq 0x14760
movq 0x397da(%rip), %rax # 0x5ffb8
movq (%rax), %rdi
leaq 0x207d7(%rip), %rdx # 0x46fbf
movl $0x1, %esi
xorl %eax, %eax
callq 0x14760
addq $0xd0, %rsp
popq %rbp
retq
|
ok:
push rbp
mov rbp, rsp
sub rsp, 0D0h
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_2676D
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_2676D:
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_2679A
cmp cs:byte_62E70, 0
jnz short loc_2679A
inc cs:dword_62E6C
loc_2679A:
lea rdx, [rbp+var_20]
call vemit_tap
cmp cs:byte_62E70, 0
jz short loc_267D7
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rdx, aSS_1; " # %s %s"
lea rcx, aTodo; "todo"
lea r8, byte_62E70
mov esi, 1
xor eax, eax
call ___fprintf_chk
loc_267D7:
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rdx, a12+3; "\n"
mov esi, 1
xor eax, eax
call ___fprintf_chk
add rsp, 0D0h
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_62E70 )
++dword_62E6C;
vemit_tap(a1, a2, v29);
if ( byte_62E70 )
__fprintf_chk(stdout, 1LL, " # %s %s", "todo", &byte_62E70);
return __fprintf_chk(stdout, 1LL, "\n");
}
|
ok:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
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 0x0012676d
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_0012676d:
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 0x0012679a
CMP byte ptr [0x00162e70],0x0
JNZ 0x0012679a
INC dword ptr [0x00162e6c]
LAB_0012679a:
LEA RDX,[RBP + -0x20]
CALL 0x001267fd
CMP byte ptr [0x00162e70],0x0
JZ 0x001267d7
MOV RAX,qword ptr [0x0015ffb8]
MOV RDI,qword ptr [RAX]
LEA RDX,[0x14b7b4]
LEA RCX,[0x14b74c]
LEA R8,[0x162e70]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00114760
LAB_001267d7:
MOV RAX,qword ptr [0x0015ffb8]
MOV RDI,qword ptr [RAX]
LEA RDX,[0x146fbf]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00114760
ADD RSP,0xd0
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)
{
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_00162e70 == '\0')) {
DAT_00162e6c = DAT_00162e6c + 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);
if (DAT_00162e70 != '\0') {
__fprintf_chk(*(int8 *)PTR_stdout_0015ffb8,1," # %s %s",&DAT_0014b74c,&DAT_00162e70);
}
__fprintf_chk(*(int8 *)PTR_stdout_0015ffb8,1,&DAT_00146fbf);
return;
}
|
|
66,435 |
my_thread_destory_thr_mutex
|
eloqsql/mysys/my_thr_init.c
|
static void my_thread_destory_thr_mutex(struct st_my_thread_var *var)
{
mysql_mutex_destroy(&var->mutex);
mysql_cond_destroy(&var->suspend);
}
|
O3
|
c
|
my_thread_destory_thr_mutex:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x62667
leaq 0x2da1b2(%rip), %rax # 0x33c808
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x80(%rbx)
movq %r14, %rdi
callq 0x360f0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
jne 0x62688
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x362c0
leaq 0x2da179(%rip), %rax # 0x33c808
movq (%rax), %rax
callq *0x68(%rax)
movq $0x0, 0x38(%rbx)
jmp 0x62678
|
my_thread_destory_thr_mutex:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
lea r14, [rdi+40h]
mov rdi, [rdi+80h]
test rdi, rdi
jz short loc_62667
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+80h], 0
loc_62667:
mov rdi, r14
call _pthread_mutex_destroy
mov rdi, [rbx+38h]
test rdi, rdi
jnz short loc_62688
loc_62678:
add rbx, 8
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _pthread_cond_destroy
loc_62688:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+68h]
mov qword ptr [rbx+38h], 0
jmp short loc_62678
|
long long my_thread_destory_thr_mutex(long long a1)
{
if ( *(_QWORD *)(a1 + 128) )
{
(*((void (**)(void))PSI_server + 9))();
*(_QWORD *)(a1 + 128) = 0LL;
}
pthread_mutex_destroy(a1 + 64);
if ( *(_QWORD *)(a1 + 56) )
{
(*((void (**)(void))PSI_server + 13))();
*(_QWORD *)(a1 + 56) = 0LL;
}
return pthread_cond_destroy(a1 + 8);
}
|
my_thread_destory_thr_mutex:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R14,[RDI + 0x40]
MOV RDI,qword ptr [RDI + 0x80]
TEST RDI,RDI
JZ 0x00162667
LEA RAX,[0x43c808]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x80],0x0
LAB_00162667:
MOV RDI,R14
CALL 0x001360f0
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JNZ 0x00162688
LAB_00162678:
ADD RBX,0x8
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x001362c0
LAB_00162688:
LEA RAX,[0x43c808]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x68]
MOV qword ptr [RBX + 0x38],0x0
JMP 0x00162678
|
void my_thread_destory_thr_mutex(long param_1)
{
if (*(long *)(param_1 + 0x80) != 0) {
(**(code **)(PSI_server + 0x48))();
*(int8 *)(param_1 + 0x80) = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x40));
if (*(long *)(param_1 + 0x38) != 0) {
(**(code **)(PSI_server + 0x68))();
*(int8 *)(param_1 + 0x38) = 0;
}
pthread_cond_destroy((pthread_cond_t *)(param_1 + 8));
return;
}
|
|
66,436 |
JS_WriteObject2
|
bluesky950520[P]quickjs/quickjs.c
|
uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValue obj,
int flags, JSSABTab *psab_tab)
{
BCWriterState ss, *s = &ss;
memset(s, 0, sizeof(*s));
s->ctx = ctx;
s->allow_bytecode = ((flags & JS_WRITE_OBJ_BYTECODE) != 0);
s->allow_sab = ((flags & JS_WRITE_OBJ_SAB) != 0);
s->allow_reference = ((flags & JS_WRITE_OBJ_REFERENCE) != 0);
s->allow_source = ((flags & JS_WRITE_OBJ_STRIP_SOURCE) == 0);
s->allow_debug = ((flags & JS_WRITE_OBJ_STRIP_DEBUG) == 0);
/* XXX: could use a different version when bytecode is included */
if (s->allow_bytecode)
s->first_atom = JS_ATOM_END;
else
s->first_atom = 1;
js_dbuf_init(ctx, &s->dbuf);
js_object_list_init(&s->object_list);
if (JS_WriteObjectRec(s, obj))
goto fail;
if (JS_WriteObjectAtoms(s))
goto fail;
js_object_list_end(ctx, &s->object_list);
js_free(ctx, s->atom_to_idx);
js_free(ctx, s->idx_to_atom);
*psize = s->dbuf.size;
if (psab_tab) {
psab_tab->tab = s->sab_tab;
psab_tab->len = s->sab_tab_len;
} else {
js_free(ctx, s->sab_tab);
}
return s->dbuf.buf;
fail:
js_object_list_end(ctx, &s->object_list);
js_free(ctx, s->atom_to_idx);
js_free(ctx, s->idx_to_atom);
dbuf_free(&s->dbuf);
*psize = 0;
if (psab_tab) {
psab_tab->tab = NULL;
psab_tab->len = 0;
}
return NULL;
}
|
O1
|
c
|
JS_WriteObject2:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, 0x8(%rsp)
movl %r8d, %r12d
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x58(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xe350
movq %r15, (%r14)
movl %r12d, %eax
andl $0x1, %eax
movl $0xfc000000, %ecx # imm = 0xFC000000
andl 0x38(%r14), %ecx
movl %r12d, %edx
andl $0x4, %edx
shll $0x6, %edx
movl %r12d, %esi
andl $0x8, %esi
shll $0xd, %esi
orl %edx, %esi
andl $0x30, %r12d
shll $0x14, %r12d
orl %esi, %r12d
orl %ecx, %r12d
orl %eax, %r12d
xorl $0x3000000, %r12d # imm = 0x3000000
testl %eax, %eax
movl $0x1, %eax
movl $0xe0, %ecx
cmovel %eax, %ecx
movl %r12d, 0x38(%r14)
movl %ecx, 0x3c(%r14)
leaq 0x60(%rsp), %r12
movq 0x18(%r15), %rsi
leaq 0x13b1f(%rip), %rdx # 0x45302
movq %r12, %rdi
callq 0x1b32b
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%r12)
movups %xmm0, 0x68(%r12)
movq %r14, %rdi
movq 0x8(%rsp), %r14
movq %rbp, %rsi
movq %r13, %rdx
callq 0x31a6a
testl %eax, %eax
jne 0x31983
movq %r15, 0x50(%rsp)
movq %rbx, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rbx
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movaps %xmm2, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x18(%rax), %rsi
leaq 0x13aaf(%rip), %rdx # 0x45302
movq %r12, %rdi
callq 0x1b32b
movq %r12, %rdi
movl $0x13, %esi
callq 0x1b4d0
movl 0xb0(%rsp), %esi
movq %r12, %rdi
callq 0x45854
cmpl $0x0, 0xb0(%rsp)
jle 0x318f6
xorl %r15d, %r15d
leaq 0x58(%rsp), %r14
leaq 0x14(%rsp), %r13
movq 0xa8(%rsp), %rax
movslq (%rax,%r15,4), %rbp
cmpq $0xdf, %rbp
jle 0x318c8
movq 0x68(%rbx), %rax
movq (%rax,%rbp,8), %rbp
movq 0x4(%rbp), %rsi
shrq $0x3e, %rsi
movq %r12, %rdi
callq 0x1b4d0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x45307
jmp 0x318e6
movq %r12, %rdi
xorl %esi, %esi
callq 0x1b4d0
movl %ebp, 0x14(%rsp)
movl $0x4, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1b422
incq %r15
movslq 0xb0(%rsp), %rax
cmpq %rax, %r15
jl 0x3188e
movslq 0x68(%rsp), %r14
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %rsi
addq %r14, %rsi
callq 0x1b375
movl %eax, %ebp
testl %eax, %eax
je 0x3191e
leaq 0x20(%rsp), %rdi
callq 0x1b62a
jmp 0x31970
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq (%rsi,%r14), %rdi
callq 0xe720
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq %r14, %rdx
callq 0xe5b0
addq %r14, 0x28(%rsp)
movq %r12, %rdi
callq 0x1b62a
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movaps 0x40(%rsp), %xmm2
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq 0x8(%rsp), %r14
movq 0x18(%rsp), %rbx
testl %ebp, %ebp
movq 0x50(%rsp), %r15
je 0x319f2
movq 0xc8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0xd8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0x98(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0xa8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq %r12, %rdi
callq 0x1b62a
movq $0x0, (%rbx)
testq %r14, %r14
je 0x319de
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0xd8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0x98(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0xa8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0x68(%rsp), %rax
movq %rax, (%rbx)
movq 0xb8(%rsp), %rsi
testq %r14, %r14
je 0x31a58
movq %rsi, (%r14)
movslq 0xc0(%rsp), %rax
movq %rax, 0x8(%r14)
jmp 0x31a60
movq %r15, %rdi
callq 0x1cb99
movq 0x60(%rsp), %rax
jmp 0x319e0
|
JS_WriteObject2:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov [rsp+118h+var_110], r9
mov r12d, r8d
mov r13, rcx
mov rbp, rdx
mov rbx, rsi
mov r15, rdi
lea r14, [rsp+118h+var_C0]
mov edx, 90h
mov rdi, r14
xor esi, esi
call _memset
mov [r14], r15
mov eax, r12d
and eax, 1
mov ecx, 0FC000000h
and ecx, [r14+38h]
mov edx, r12d
and edx, 4
shl edx, 6
mov esi, r12d
and esi, 8
shl esi, 0Dh
or esi, edx
and r12d, 30h
shl r12d, 14h
or r12d, esi
or r12d, ecx
or r12d, eax
xor r12d, 3000000h
test eax, eax
mov eax, 1
mov ecx, 0E0h
cmovz ecx, eax
mov [r14+38h], r12d
mov [r14+3Ch], ecx
lea r12, [rsp+118h+var_B8]
mov rsi, [r15+18h]
lea rdx, js_dbuf_realloc
mov rdi, r12
call dbuf_init2
xorps xmm0, xmm0
movups xmmword ptr [r12+78h], xmm0
movups xmmword ptr [r12+68h], xmm0
mov rdi, r14
mov r14, [rsp+118h+var_110]
mov rsi, rbp
mov rdx, r13
call JS_WriteObjectRec
test eax, eax
jnz loc_31983
mov [rsp+118h+var_C8], r15
mov [rsp+118h+var_100], rbx
mov rax, [rsp+118h+var_C0]
mov rbx, [rax+18h]
movups xmm0, xmmword ptr [r12]
movups xmm1, xmmword ptr [r12+10h]
movups xmm2, xmmword ptr [r12+20h]
movaps [rsp+118h+var_D8], xmm2
movaps [rsp+118h+var_E8], xmm1
movaps [rsp+118h+var_F8], xmm0
mov rsi, [rax+18h]
lea rdx, js_dbuf_realloc
mov rdi, r12
call dbuf_init2
mov rdi, r12
mov esi, 13h
call dbuf_putc
mov esi, [rsp+118h+var_68]
mov rdi, r12
call dbuf_put_leb128
cmp [rsp+118h+var_68], 0
jle short loc_318F6
xor r15d, r15d
lea r14, [rsp+118h+var_C0]
lea r13, [rsp+118h+var_104]
loc_3188E:
mov rax, [rsp+118h+var_70]
movsxd rbp, dword ptr [rax+r15*4]
cmp rbp, 0DFh
jle short loc_318C8
mov rax, [rbx+68h]
mov rbp, [rax+rbp*8]
mov rsi, [rbp+4]
shr rsi, 3Eh
mov rdi, r12
call dbuf_putc
mov rdi, r14
mov rsi, rbp
call JS_WriteString
jmp short loc_318E6
loc_318C8:
mov rdi, r12
xor esi, esi
call dbuf_putc
mov [rsp+118h+var_104], ebp
mov edx, 4
mov rdi, r12
mov rsi, r13
call dbuf_put
loc_318E6:
inc r15
movsxd rax, [rsp+118h+var_68]
cmp r15, rax
jl short loc_3188E
loc_318F6:
movsxd r14, dword ptr [rsp+118h+var_B0]
lea rdi, [rsp+118h+var_F8]
mov rsi, [rdi+8]
add rsi, r14
call dbuf_realloc
mov ebp, eax
test eax, eax
jz short loc_3191E
lea rdi, [rsp+118h+var_F8]
call dbuf_free
jmp short loc_31970
loc_3191E:
mov rsi, qword ptr [rsp+118h+var_F8]
mov rdx, qword ptr [rsp+118h+var_F8+8]
lea rdi, [rsi+r14]
call _memmove
mov rdi, qword ptr [rsp+118h+var_F8]
mov rsi, [rsp+118h+var_B8]
mov rdx, r14
call _memcpy
add qword ptr [rsp+118h+var_F8+8], r14
mov rdi, r12
call dbuf_free
movaps xmm0, [rsp+118h+var_F8]
movaps xmm1, [rsp+118h+var_E8]
movaps xmm2, [rsp+118h+var_D8]
movups xmmword ptr [r12+20h], xmm2
movups xmmword ptr [r12+10h], xmm1
movups xmmword ptr [r12], xmm0
loc_31970:
mov r14, [rsp+118h+var_110]
mov rbx, [rsp+118h+var_100]
test ebp, ebp
mov r15, [rsp+118h+var_C8]
jz short loc_319F2
loc_31983:
mov rsi, [rsp+118h+var_50]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_40]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_80]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_70]
mov rdi, r15
call js_free
mov rdi, r12
call dbuf_free
mov qword ptr [rbx], 0
test r14, r14
jz short loc_319DE
xorps xmm0, xmm0
movups xmmword ptr [r14], xmm0
loc_319DE:
xor eax, eax
loc_319E0:
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_319F2:
mov rsi, [rsp+118h+var_50]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_40]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_80]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_70]
mov rdi, r15
call js_free
mov rax, [rsp+118h+var_B0]
mov [rbx], rax
mov rsi, [rsp+118h+var_60]
test r14, r14
jz short loc_31A58
mov [r14], rsi
movsxd rax, [rsp+118h+var_58]
mov [r14+8], rax
jmp short loc_31A60
loc_31A58:
mov rdi, r15
call js_free
loc_31A60:
mov rax, [rsp+118h+var_B8]
jmp loc_319E0
|
long long JS_WriteObject2(long long a1, _QWORD *a2, long long a3, long long a4, char a5, _QWORD *a6)
{
_QWORD *v9; // rbx
long long v10; // r15
int v11; // eax
unsigned int v12; // r12d
int v13; // ecx
_OWORD *v14; // r14
long long v15; // rbx
long long i; // r15
long long v17; // rbp
long long v18; // rbp
long long v19; // r14
int v20; // ebp
int v23; // [rsp+14h] [rbp-104h] BYREF
_QWORD *v24; // [rsp+18h] [rbp-100h]
__int128 v25; // [rsp+20h] [rbp-F8h] BYREF
__int128 v26; // [rsp+30h] [rbp-E8h]
__int128 v27; // [rsp+40h] [rbp-D8h]
long long v28; // [rsp+50h] [rbp-C8h]
long long v29; // [rsp+58h] [rbp-C0h] BYREF
__int128 v30; // [rsp+60h] [rbp-B8h] BYREF
__int128 v31; // [rsp+70h] [rbp-A8h]
__int128 v32; // [rsp+80h] [rbp-98h]
unsigned int v33; // [rsp+90h] [rbp-88h]
int v34; // [rsp+94h] [rbp-84h]
long long v35; // [rsp+98h] [rbp-80h]
long long v36; // [rsp+A8h] [rbp-70h]
int v37; // [rsp+B0h] [rbp-68h]
long long v38; // [rsp+B8h] [rbp-60h]
int v39; // [rsp+C0h] [rbp-58h]
__int128 v40; // [rsp+C8h] [rbp-50h]
__int128 v41; // [rsp+D8h] [rbp-40h]
v9 = a2;
v10 = a1;
memset(&v29, 0LL, 144LL);
v29 = a1;
v11 = a5 & 1;
v12 = (v11 | v33 & 0xFC000000 | ((a5 & 4) << 6) | ((a5 & 8) << 13) | ((a5 & 0x30) << 20)) ^ 0x3000000;
v13 = 224;
if ( !v11 )
v13 = 1;
v33 = v12;
v34 = v13;
dbuf_init2((long long)&v30, *(_QWORD *)(a1 + 24), js_dbuf_realloc);
v41 = 0LL;
v40 = 0LL;
v14 = a6;
if ( (unsigned int)JS_WriteObjectRec(&v29, a3, a4) )
goto LABEL_14;
v28 = a1;
v24 = a2;
v15 = *(_QWORD *)(v29 + 24);
v27 = v32;
v26 = v31;
v25 = v30;
dbuf_init2((long long)&v30, *(_QWORD *)(v29 + 24), js_dbuf_realloc);
dbuf_putc(&v30, 19);
dbuf_put_leb128(&v30, (unsigned int)v37);
if ( v37 > 0 )
{
for ( i = 0LL; i < v37; ++i )
{
v17 = *(int *)(v36 + 4 * i);
if ( v17 <= 223 )
{
dbuf_putc(&v30, 0);
v23 = v17;
dbuf_put(&v30, (long long)&v23, 4LL);
}
else
{
v18 = *(_QWORD *)(*(_QWORD *)(v15 + 104) + 8 * v17);
dbuf_putc(&v30, *(_QWORD *)(v18 + 4) >> 62);
JS_WriteString(&v29, v18);
}
}
}
v19 = SDWORD2(v30);
v20 = dbuf_realloc((long long)&v25, SDWORD2(v30) + *((_QWORD *)&v25 + 1));
if ( v20 )
{
dbuf_free((long long)&v25);
}
else
{
memmove(v25 + v19, v25, *((_QWORD *)&v25 + 1));
memcpy(v25, v30, v19);
*((_QWORD *)&v25 + 1) += v19;
dbuf_free((long long)&v30);
v32 = v27;
v31 = v26;
v30 = v25;
}
v14 = a6;
v9 = v24;
v10 = v28;
if ( v20 )
{
LABEL_14:
js_free(v10, v40);
js_free(v10, v41);
js_free(v10, v35);
js_free(v10, v36);
dbuf_free((long long)&v30);
*v9 = 0LL;
if ( v14 )
*v14 = 0LL;
return 0LL;
}
else
{
js_free(v28, v40);
js_free(v10, v41);
js_free(v10, v35);
js_free(v10, v36);
*v9 = *((_QWORD *)&v30 + 1);
if ( a6 )
{
*a6 = v38;
a6[1] = v39;
}
else
{
js_free(v10, v38);
}
return v30;
}
}
|
JS_WriteObject2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RSP + 0x8],R9
MOV R12D,R8D
MOV R13,RCX
MOV RBP,RDX
MOV RBX,RSI
MOV R15,RDI
LEA R14,[RSP + 0x58]
MOV EDX,0x90
MOV RDI,R14
XOR ESI,ESI
CALL 0x0010e350
MOV qword ptr [R14],R15
MOV EAX,R12D
AND EAX,0x1
MOV ECX,0xfc000000
AND ECX,dword ptr [R14 + 0x38]
MOV EDX,R12D
AND EDX,0x4
SHL EDX,0x6
MOV ESI,R12D
AND ESI,0x8
SHL ESI,0xd
OR ESI,EDX
AND R12D,0x30
SHL R12D,0x14
OR R12D,ESI
OR R12D,ECX
OR R12D,EAX
XOR R12D,0x3000000
TEST EAX,EAX
MOV EAX,0x1
MOV ECX,0xe0
CMOVZ ECX,EAX
MOV dword ptr [R14 + 0x38],R12D
MOV dword ptr [R14 + 0x3c],ECX
LEA R12,[RSP + 0x60]
MOV RSI,qword ptr [R15 + 0x18]
LEA RDX,[0x145302]
MOV RDI,R12
CALL 0x0011b32b
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12 + 0x78],XMM0
MOVUPS xmmword ptr [R12 + 0x68],XMM0
MOV RDI,R14
MOV R14,qword ptr [RSP + 0x8]
MOV RSI,RBP
MOV RDX,R13
CALL 0x00131a6a
TEST EAX,EAX
JNZ 0x00131983
MOV qword ptr [RSP + 0x50],R15
MOV qword ptr [RSP + 0x18],RBX
MOV RAX,qword ptr [RSP + 0x58]
MOV RBX,qword ptr [RAX + 0x18]
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS XMM1,xmmword ptr [R12 + 0x10]
MOVUPS XMM2,xmmword ptr [R12 + 0x20]
MOVAPS xmmword ptr [RSP + 0x40],XMM2
MOVAPS xmmword ptr [RSP + 0x30],XMM1
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV RSI,qword ptr [RAX + 0x18]
LEA RDX,[0x145302]
MOV RDI,R12
CALL 0x0011b32b
MOV RDI,R12
MOV ESI,0x13
CALL 0x0011b4d0
MOV ESI,dword ptr [RSP + 0xb0]
MOV RDI,R12
CALL 0x00145854
CMP dword ptr [RSP + 0xb0],0x0
JLE 0x001318f6
XOR R15D,R15D
LEA R14,[RSP + 0x58]
LEA R13,[RSP + 0x14]
LAB_0013188e:
MOV RAX,qword ptr [RSP + 0xa8]
MOVSXD RBP,dword ptr [RAX + R15*0x4]
CMP RBP,0xdf
JLE 0x001318c8
MOV RAX,qword ptr [RBX + 0x68]
MOV RBP,qword ptr [RAX + RBP*0x8]
MOV RSI,qword ptr [RBP + 0x4]
SHR RSI,0x3e
MOV RDI,R12
CALL 0x0011b4d0
MOV RDI,R14
MOV RSI,RBP
CALL 0x00145307
JMP 0x001318e6
LAB_001318c8:
MOV RDI,R12
XOR ESI,ESI
CALL 0x0011b4d0
MOV dword ptr [RSP + 0x14],EBP
MOV EDX,0x4
MOV RDI,R12
MOV RSI,R13
CALL 0x0011b422
LAB_001318e6:
INC R15
MOVSXD RAX,dword ptr [RSP + 0xb0]
CMP R15,RAX
JL 0x0013188e
LAB_001318f6:
MOVSXD R14,dword ptr [RSP + 0x68]
LEA RDI,[RSP + 0x20]
MOV RSI,qword ptr [RDI + 0x8]
ADD RSI,R14
CALL 0x0011b375
MOV EBP,EAX
TEST EAX,EAX
JZ 0x0013191e
LEA RDI,[RSP + 0x20]
CALL 0x0011b62a
JMP 0x00131970
LAB_0013191e:
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LEA RDI,[RSI + R14*0x1]
CALL 0x0010e720
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,R14
CALL 0x0010e5b0
ADD qword ptr [RSP + 0x28],R14
MOV RDI,R12
CALL 0x0011b62a
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVAPS XMM1,xmmword ptr [RSP + 0x30]
MOVAPS XMM2,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [R12 + 0x20],XMM2
MOVUPS xmmword ptr [R12 + 0x10],XMM1
MOVUPS xmmword ptr [R12],XMM0
LAB_00131970:
MOV R14,qword ptr [RSP + 0x8]
MOV RBX,qword ptr [RSP + 0x18]
TEST EBP,EBP
MOV R15,qword ptr [RSP + 0x50]
JZ 0x001319f2
LAB_00131983:
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDI,R15
CALL 0x0011cb99
MOV RSI,qword ptr [RSP + 0xd8]
MOV RDI,R15
CALL 0x0011cb99
MOV RSI,qword ptr [RSP + 0x98]
MOV RDI,R15
CALL 0x0011cb99
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDI,R15
CALL 0x0011cb99
MOV RDI,R12
CALL 0x0011b62a
MOV qword ptr [RBX],0x0
TEST R14,R14
JZ 0x001319de
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14],XMM0
LAB_001319de:
XOR EAX,EAX
LAB_001319e0:
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001319f2:
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDI,R15
CALL 0x0011cb99
MOV RSI,qword ptr [RSP + 0xd8]
MOV RDI,R15
CALL 0x0011cb99
MOV RSI,qword ptr [RSP + 0x98]
MOV RDI,R15
CALL 0x0011cb99
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDI,R15
CALL 0x0011cb99
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [RSP + 0xb8]
TEST R14,R14
JZ 0x00131a58
MOV qword ptr [R14],RSI
MOVSXD RAX,dword ptr [RSP + 0xc0]
MOV qword ptr [R14 + 0x8],RAX
JMP 0x00131a60
LAB_00131a58:
MOV RDI,R15
CALL 0x0011cb99
LAB_00131a60:
MOV RAX,qword ptr [RSP + 0x60]
JMP 0x001319e0
|
int8
JS_WriteObject2(long param_1,int8 *param_2,int8 param_3,int8 param_4,uint param_5,
int8 *param_6)
{
long lVar1;
int8 *puVar2;
int iVar3;
size_t __n;
long lVar4;
int local_104;
int8 *local_100;
int4 local_f8;
int4 uStack_f4;
int8 uStack_f0;
int4 local_e8;
int4 uStack_e4;
int4 uStack_e0;
int4 uStack_dc;
int4 local_d8;
int4 uStack_d4;
int4 uStack_d0;
int4 uStack_cc;
long local_c8;
long local_c0;
int4 local_b8;
int4 uStack_b4;
int iStack_b0;
int4 uStack_ac;
int8 local_a8;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
uint local_88;
int4 local_84;
int8 local_80;
long local_70;
int local_68;
int8 local_60;
int local_58;
int8 local_50;
int8 uStack_48;
int8 local_40;
int8 uStack_38;
memset(&local_c0,0,0x90);
local_88 = ((param_5 & 0x30) << 0x14 | (param_5 & 8) << 0xd | (param_5 & 4) << 6 |
local_88 & 0xfc000000 | param_5 & 1) ^ 0x3000000;
local_84 = 0xe0;
if ((param_5 & 1) == 0) {
local_84 = 1;
}
local_c0 = param_1;
dbuf_init2(&local_b8,*(int8 *)(param_1 + 0x18),js_dbuf_realloc);
local_40 = 0;
uStack_38 = 0;
local_50 = 0;
uStack_48 = 0;
iVar3 = JS_WriteObjectRec(&local_c0,param_3,param_4);
if (iVar3 == 0) {
lVar1 = *(long *)(local_c0 + 0x18);
local_d8 = (int4)local_98;
uStack_d4 = local_98._4_4_;
uStack_d0 = (int4)uStack_90;
uStack_cc = uStack_90._4_4_;
local_e8 = (int4)local_a8;
uStack_e4 = local_a8._4_4_;
uStack_e0 = (int4)uStack_a0;
uStack_dc = uStack_a0._4_4_;
local_f8 = local_b8;
uStack_f4 = uStack_b4;
uStack_f0 = CONCAT44(uStack_ac,iStack_b0);
local_100 = param_2;
local_c8 = param_1;
dbuf_init2(&local_b8,*(int8 *)(local_c0 + 0x18),js_dbuf_realloc);
dbuf_putc(&local_b8,0x13);
dbuf_put_leb128(&local_b8,local_68);
if (0 < local_68) {
lVar4 = 0;
do {
iVar3 = *(int *)(local_70 + lVar4 * 4);
if ((long)iVar3 < 0xe0) {
dbuf_putc(&local_b8,0);
local_104 = iVar3;
dbuf_put(&local_b8,&local_104,4);
}
else {
dbuf_putc(&local_b8,
*(ulong *)(*(long *)(*(long *)(lVar1 + 0x68) + (long)iVar3 * 8) + 4) >> 0x3e);
JS_WriteString(&local_c0);
}
lVar4 = lVar4 + 1;
} while (lVar4 < local_68);
}
__n = (size_t)iStack_b0;
iVar3 = dbuf_realloc(&local_f8,uStack_f0 + __n);
if (iVar3 == 0) {
memmove((void *)((long)CONCAT44(uStack_f4,local_f8) + __n),
(void *)CONCAT44(uStack_f4,local_f8),uStack_f0);
memcpy((void *)CONCAT44(uStack_f4,local_f8),(void *)CONCAT44(uStack_b4,local_b8),__n);
uStack_f0 = uStack_f0 + __n;
dbuf_free(&local_b8);
lVar1 = local_c8;
puVar2 = local_100;
local_a8 = CONCAT44(uStack_e4,local_e8);
uStack_a0 = CONCAT44(uStack_dc,uStack_e0);
local_98 = CONCAT44(uStack_d4,local_d8);
uStack_90 = CONCAT44(uStack_cc,uStack_d0);
local_b8 = local_f8;
uStack_b4 = uStack_f4;
iStack_b0 = (int4)uStack_f0;
uStack_ac = uStack_f0._4_4_;
js_free(local_c8,local_50);
js_free(lVar1,local_40);
js_free(lVar1,local_80);
js_free(lVar1,local_70);
*puVar2 = CONCAT44(uStack_ac,iStack_b0);
if (param_6 == (int8 *)0x0) {
js_free(lVar1);
}
else {
*param_6 = local_60;
param_6[1] = (long)local_58;
}
return CONCAT44(uStack_b4,local_b8);
}
dbuf_free(&local_f8);
param_2 = local_100;
param_1 = local_c8;
}
js_free(param_1,local_50);
js_free(param_1,local_40);
js_free(param_1,local_80);
js_free(param_1,local_70);
dbuf_free(&local_b8);
*param_2 = 0;
if (param_6 != (int8 *)0x0) {
*param_6 = 0;
param_6[1] = 0;
}
return 0;
}
|
|
66,437 |
JS_WriteObject2
|
bluesky950520[P]quickjs/quickjs.c
|
uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValue obj,
int flags, JSSABTab *psab_tab)
{
BCWriterState ss, *s = &ss;
memset(s, 0, sizeof(*s));
s->ctx = ctx;
s->allow_bytecode = ((flags & JS_WRITE_OBJ_BYTECODE) != 0);
s->allow_sab = ((flags & JS_WRITE_OBJ_SAB) != 0);
s->allow_reference = ((flags & JS_WRITE_OBJ_REFERENCE) != 0);
s->allow_source = ((flags & JS_WRITE_OBJ_STRIP_SOURCE) == 0);
s->allow_debug = ((flags & JS_WRITE_OBJ_STRIP_DEBUG) == 0);
/* XXX: could use a different version when bytecode is included */
if (s->allow_bytecode)
s->first_atom = JS_ATOM_END;
else
s->first_atom = 1;
js_dbuf_init(ctx, &s->dbuf);
js_object_list_init(&s->object_list);
if (JS_WriteObjectRec(s, obj))
goto fail;
if (JS_WriteObjectAtoms(s))
goto fail;
js_object_list_end(ctx, &s->object_list);
js_free(ctx, s->atom_to_idx);
js_free(ctx, s->idx_to_atom);
*psize = s->dbuf.size;
if (psab_tab) {
psab_tab->tab = s->sab_tab;
psab_tab->len = s->sab_tab_len;
} else {
js_free(ctx, s->sab_tab);
}
return s->dbuf.buf;
fail:
js_object_list_end(ctx, &s->object_list);
js_free(ctx, s->atom_to_idx);
js_free(ctx, s->idx_to_atom);
dbuf_free(&s->dbuf);
*psize = 0;
if (psab_tab) {
psab_tab->tab = NULL;
psab_tab->len = 0;
}
return NULL;
}
|
O2
|
c
|
JS_WriteObject2:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, %rbx
movl %r8d, %r13d
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbp
leaq 0x60(%rsp), %r12
movl $0x88, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0xe360
movq %rbp, -0x8(%r12)
movl %r13d, %eax
andl $0x1, %eax
movl %r13d, %ecx
andl $0x4, %ecx
shll $0x6, %ecx
movl %r13d, %edx
andl $0x8, %edx
shll $0xd, %edx
orl %ecx, %edx
andl $0x30, %r13d
shll $0x14, %r13d
orl %edx, %r13d
orl %eax, %r13d
xorl $0x3000000, %r13d # imm = 0x3000000
movl %r13d, 0x30(%r12)
testl %eax, %eax
pushq $0x1
popq %rax
movl $0xe0, %ecx
cmovel %eax, %ecx
movl %ecx, 0x34(%r12)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x29e23
leaq 0xc8(%rsp), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x29e39
testl %eax, %eax
jne 0x29d04
movq %rbp, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
leaq 0x58(%rsp), %rbp
movq (%rbp), %rdi
movq 0x18(%rdi), %rbx
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movaps %xmm2, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %r12, %rsi
callq 0x29e23
pushq $0x13
popq %rsi
movq %r12, %rdi
callq 0x15d33
movl 0x58(%rbp), %esi
movq %r12, %rdi
callq 0x3cf8f
xorl %r13d, %r13d
movslq 0xb0(%rsp), %rax
cmpq %rax, %r13
jge 0x29cc9
movq 0xa8(%rsp), %rax
movslq (%rax,%r13,4), %r14
cmpq $0xdf, %r14
jle 0x29caf
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %r14
movq 0x4(%r14), %rsi
shrq $0x3e, %rsi
movq %r12, %rdi
callq 0x15d33
movq %rbp, %rdi
movq %r14, %rsi
callq 0x3ceda
jmp 0x29cc4
movq %r12, %rdi
xorl %esi, %esi
callq 0x15d33
movq %r12, %rdi
movl %r14d, %esi
callq 0x3d14f
incq %r13
jmp 0x29c68
movslq 0x68(%rsp), %r14
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %rsi
addq %r14, %rsi
callq 0x15bdf
testl %eax, %eax
je 0x29d5a
leaq 0x20(%rsp), %rdi
callq 0x15e89
movq 0x8(%rsp), %rbx
movq 0x18(%rsp), %r15
leaq 0xc8(%rsp), %r13
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2abca
movq 0x98(%rsp), %rsi
movq %rbp, %rdi
callq 0x1726e
movq 0xa8(%rsp), %rsi
movq %rbp, %rdi
callq 0x1726e
movq %r12, %rdi
callq 0x15e89
andq $0x0, (%r15)
testq %rbx, %rbx
je 0x29d46
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq (%rsi,%r14), %rdi
callq 0xe740
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq %r14, %rdx
callq 0xe5c0
addq %r14, 0x28(%rsp)
movq %r12, %rdi
callq 0x15e89
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movaps 0x40(%rsp), %xmm2
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
leaq 0xc8(%rsp), %rsi
callq 0x2abca
movq 0x98(%rsp), %rsi
movq %rbx, %rdi
callq 0x1726e
movq 0xa8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1726e
movq 0x68(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq 0xb8(%rsp), %rsi
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x29e11
movq %rsi, (%rcx)
movslq 0xc0(%rsp), %rax
movq %rax, 0x8(%rcx)
jmp 0x29e19
movq %rbx, %rdi
callq 0x1726e
movq 0x60(%rsp), %rax
jmp 0x29d48
|
JS_WriteObject2:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov rbx, r9
mov r13d, r8d
mov [rsp+118h+var_110], rcx
mov r14, rdx
mov r15, rsi
mov rbp, rdi
lea r12, [rsp+118h+var_B8]
mov edx, 88h
mov rdi, r12
xor esi, esi
call _memset
mov [r12-8], rbp
mov eax, r13d
and eax, 1
mov ecx, r13d
and ecx, 4
shl ecx, 6
mov edx, r13d
and edx, 8
shl edx, 0Dh
or edx, ecx
and r13d, 30h
shl r13d, 14h
or r13d, edx
or r13d, eax
xor r13d, 3000000h
mov [r12+30h], r13d
test eax, eax
push 1
pop rax
mov ecx, 0E0h
cmovz ecx, eax
mov [r12+34h], ecx
mov rdi, rbp
mov rsi, r12
call js_dbuf_init
lea r13, [rsp+118h+var_50]
xorps xmm0, xmm0
movups xmmword ptr [r13+10h], xmm0
movups xmmword ptr [r13+0], xmm0
lea rdi, [rsp+118h+var_C0]
mov rsi, r14
mov rdx, [rsp+118h+var_110]
call JS_WriteObjectRec
test eax, eax
jnz loc_29D04
mov [rsp+118h+var_108], rbp
mov [rsp+118h+var_100], r15
mov [rsp+118h+var_110], rbx
lea rbp, [rsp+118h+var_C0]
mov rdi, [rbp+0]
mov rbx, [rdi+18h]
movups xmm0, xmmword ptr [r12]
movups xmm1, xmmword ptr [r12+10h]
movups xmm2, xmmword ptr [r12+20h]
movaps [rsp+118h+var_D8], xmm2
movaps [rsp+118h+var_E8], xmm1
movaps [rsp+118h+var_F8], xmm0
mov rsi, r12
call js_dbuf_init
push 13h
pop rsi
mov rdi, r12
call dbuf_putc
mov esi, [rbp+58h]
mov rdi, r12
call dbuf_put_leb128
xor r13d, r13d
loc_29C68:
movsxd rax, [rsp+118h+var_68]
cmp r13, rax
jge short loc_29CC9
mov rax, [rsp+118h+var_70]
movsxd r14, dword ptr [rax+r13*4]
cmp r14, 0DFh
jle short loc_29CAF
mov rax, [rbx+68h]
mov r14, [rax+r14*8]
mov rsi, [r14+4]
shr rsi, 3Eh
mov rdi, r12
call dbuf_putc
mov rdi, rbp
mov rsi, r14
call JS_WriteString
jmp short loc_29CC4
loc_29CAF:
mov rdi, r12
xor esi, esi
call dbuf_putc
mov rdi, r12
mov esi, r14d
call dbuf_put_u32
loc_29CC4:
inc r13
jmp short loc_29C68
loc_29CC9:
movsxd r14, dword ptr [rsp+118h+var_B0]
lea rdi, [rsp+118h+var_F8]
mov rsi, [rdi+8]
add rsi, r14
call dbuf_realloc
test eax, eax
jz short loc_29D5A
lea rdi, [rsp+118h+var_F8]
call dbuf_free
mov rbx, [rsp+118h+var_110]
mov r15, [rsp+118h+var_100]
lea r13, [rsp+118h+var_50]
mov rbp, [rsp+118h+var_108]
loc_29D04:
mov rdi, rbp
mov rsi, r13
call js_object_list_end
mov rsi, [rsp+118h+var_80]
mov rdi, rbp
call js_free
mov rsi, [rsp+118h+var_70]
mov rdi, rbp
call js_free
mov rdi, r12
call dbuf_free
and qword ptr [r15], 0
test rbx, rbx
jz short loc_29D46
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_29D46:
xor eax, eax
loc_29D48:
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_29D5A:
mov rsi, qword ptr [rsp+118h+var_F8]
mov rdx, qword ptr [rsp+118h+var_F8+8]
lea rdi, [rsi+r14]
call _memmove
mov rdi, qword ptr [rsp+118h+var_F8]
mov rsi, [rsp+118h+var_B8]
mov rdx, r14
call _memcpy
add qword ptr [rsp+118h+var_F8+8], r14
mov rdi, r12
call dbuf_free
movaps xmm0, [rsp+118h+var_F8]
movaps xmm1, [rsp+118h+var_E8]
movaps xmm2, [rsp+118h+var_D8]
movups xmmword ptr [r12+20h], xmm2
movups xmmword ptr [r12+10h], xmm1
movups xmmword ptr [r12], xmm0
mov rbx, [rsp+118h+var_108]
mov rdi, rbx
lea rsi, [rsp+118h+var_50]
call js_object_list_end
mov rsi, [rsp+118h+var_80]
mov rdi, rbx
call js_free
mov rsi, [rsp+118h+var_70]
mov rdi, rbx
call js_free
mov rax, [rsp+118h+var_B0]
mov rcx, [rsp+118h+var_100]
mov [rcx], rax
mov rsi, [rsp+118h+var_60]
mov rcx, [rsp+118h+var_110]
test rcx, rcx
jz short loc_29E11
mov [rcx], rsi
movsxd rax, [rsp+118h+var_58]
mov [rcx+8], rax
jmp short loc_29E19
loc_29E11:
mov rdi, rbx
call js_free
loc_29E19:
mov rax, [rsp+118h+var_B8]
jmp loc_29D48
|
long long JS_WriteObject2(long long a1, _QWORD *a2, long long a3, long long a4, char a5, _OWORD *a6)
{
long long v9; // rbp
int v10; // ecx
long long v11; // rbx
long long i; // r13
long long v13; // r14
long long v14; // r14
long long v15; // r14
_QWORD *v18; // [rsp+8h] [rbp-110h]
__int128 v19; // [rsp+20h] [rbp-F8h] BYREF
__int128 v20; // [rsp+30h] [rbp-E8h]
__int128 v21; // [rsp+40h] [rbp-D8h]
long long v22; // [rsp+58h] [rbp-C0h] BYREF
__int128 v23; // [rsp+60h] [rbp-B8h] BYREF
__int128 v24; // [rsp+70h] [rbp-A8h]
__int128 v25; // [rsp+80h] [rbp-98h]
int v26; // [rsp+90h] [rbp-88h]
int v27; // [rsp+94h] [rbp-84h]
long long v28; // [rsp+98h] [rbp-80h]
long long v29; // [rsp+A8h] [rbp-70h]
unsigned int v30; // [rsp+B0h] [rbp-68h]
long long v31; // [rsp+B8h] [rbp-60h]
int v32; // [rsp+C0h] [rbp-58h]
_BYTE v33[80]; // [rsp+C8h] [rbp-50h] BYREF
v9 = a1;
memset(&v23, 0LL, 136LL);
v22 = a1;
v26 = (a5 & 1 | ((a5 & 4) << 6) | ((a5 & 8) << 13) | ((a5 & 0x30) << 20)) ^ 0x3000000;
v10 = 224;
if ( (a5 & 1) == 0 )
v10 = 1;
v27 = v10;
js_dbuf_init(a1, &v23);
memset(v33, 0, 32);
if ( !(unsigned int)JS_WriteObjectRec(&v22, a3, a4) )
{
v18 = a6;
v11 = *(_QWORD *)(v22 + 24);
v21 = v25;
v20 = v24;
v19 = v23;
js_dbuf_init(v22, &v23);
dbuf_putc(&v23, 19);
dbuf_put_leb128(&v23, v30);
for ( i = 0LL; i < (int)v30; ++i )
{
v13 = *(int *)(v29 + 4 * i);
if ( v13 <= 223 )
{
dbuf_putc(&v23, 0);
dbuf_put_u32(&v23, (unsigned int)v13);
}
else
{
v14 = *(_QWORD *)(*(_QWORD *)(v11 + 104) + 8 * v13);
dbuf_putc(&v23, *(_QWORD *)(v14 + 4) >> 62);
JS_WriteString(&v22, v14);
}
}
v15 = SDWORD2(v23);
if ( !(unsigned int)dbuf_realloc((long long)&v19, SDWORD2(v23) + *((_QWORD *)&v19 + 1)) )
{
memmove(v19 + v15, v19, *((_QWORD *)&v19 + 1));
memcpy(v19, v23, v15);
*((_QWORD *)&v19 + 1) += v15;
dbuf_free((long long)&v23);
v25 = v21;
v24 = v20;
v23 = v19;
js_object_list_end(a1, v33);
js_free(a1, v28);
js_free(a1, v29);
*a2 = *((_QWORD *)&v23 + 1);
if ( v18 )
{
*v18 = v31;
v18[1] = v32;
}
else
{
js_free(a1, v31);
}
return v23;
}
dbuf_free((long long)&v19);
a6 = v18;
v9 = a1;
}
js_object_list_end(v9, v33);
js_free(v9, v28);
js_free(v9, v29);
dbuf_free((long long)&v23);
*a2 = 0LL;
if ( a6 )
*a6 = 0LL;
return 0LL;
}
|
JS_WriteObject2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV RBX,R9
MOV R13D,R8D
MOV qword ptr [RSP + 0x8],RCX
MOV R14,RDX
MOV R15,RSI
MOV RBP,RDI
LEA R12,[RSP + 0x60]
MOV EDX,0x88
MOV RDI,R12
XOR ESI,ESI
CALL 0x0010e360
MOV qword ptr [R12 + -0x8],RBP
MOV EAX,R13D
AND EAX,0x1
MOV ECX,R13D
AND ECX,0x4
SHL ECX,0x6
MOV EDX,R13D
AND EDX,0x8
SHL EDX,0xd
OR EDX,ECX
AND R13D,0x30
SHL R13D,0x14
OR R13D,EDX
OR R13D,EAX
XOR R13D,0x3000000
MOV dword ptr [R12 + 0x30],R13D
TEST EAX,EAX
PUSH 0x1
POP RAX
MOV ECX,0xe0
CMOVZ ECX,EAX
MOV dword ptr [R12 + 0x34],ECX
MOV RDI,RBP
MOV RSI,R12
CALL 0x00129e23
LEA R13,[RSP + 0xc8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x10],XMM0
MOVUPS xmmword ptr [R13],XMM0
LEA RDI,[RSP + 0x58]
MOV RSI,R14
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x00129e39
TEST EAX,EAX
JNZ 0x00129d04
MOV qword ptr [RSP + 0x10],RBP
MOV qword ptr [RSP + 0x18],R15
MOV qword ptr [RSP + 0x8],RBX
LEA RBP,[RSP + 0x58]
MOV RDI,qword ptr [RBP]
MOV RBX,qword ptr [RDI + 0x18]
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS XMM1,xmmword ptr [R12 + 0x10]
MOVUPS XMM2,xmmword ptr [R12 + 0x20]
MOVAPS xmmword ptr [RSP + 0x40],XMM2
MOVAPS xmmword ptr [RSP + 0x30],XMM1
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV RSI,R12
CALL 0x00129e23
PUSH 0x13
POP RSI
MOV RDI,R12
CALL 0x00115d33
MOV ESI,dword ptr [RBP + 0x58]
MOV RDI,R12
CALL 0x0013cf8f
XOR R13D,R13D
LAB_00129c68:
MOVSXD RAX,dword ptr [RSP + 0xb0]
CMP R13,RAX
JGE 0x00129cc9
MOV RAX,qword ptr [RSP + 0xa8]
MOVSXD R14,dword ptr [RAX + R13*0x4]
CMP R14,0xdf
JLE 0x00129caf
MOV RAX,qword ptr [RBX + 0x68]
MOV R14,qword ptr [RAX + R14*0x8]
MOV RSI,qword ptr [R14 + 0x4]
SHR RSI,0x3e
MOV RDI,R12
CALL 0x00115d33
MOV RDI,RBP
MOV RSI,R14
CALL 0x0013ceda
JMP 0x00129cc4
LAB_00129caf:
MOV RDI,R12
XOR ESI,ESI
CALL 0x00115d33
MOV RDI,R12
MOV ESI,R14D
CALL 0x0013d14f
LAB_00129cc4:
INC R13
JMP 0x00129c68
LAB_00129cc9:
MOVSXD R14,dword ptr [RSP + 0x68]
LEA RDI,[RSP + 0x20]
MOV RSI,qword ptr [RDI + 0x8]
ADD RSI,R14
CALL 0x00115bdf
TEST EAX,EAX
JZ 0x00129d5a
LEA RDI,[RSP + 0x20]
CALL 0x00115e89
MOV RBX,qword ptr [RSP + 0x8]
MOV R15,qword ptr [RSP + 0x18]
LEA R13,[RSP + 0xc8]
MOV RBP,qword ptr [RSP + 0x10]
LAB_00129d04:
MOV RDI,RBP
MOV RSI,R13
CALL 0x0012abca
MOV RSI,qword ptr [RSP + 0x98]
MOV RDI,RBP
CALL 0x0011726e
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDI,RBP
CALL 0x0011726e
MOV RDI,R12
CALL 0x00115e89
AND qword ptr [R15],0x0
TEST RBX,RBX
JZ 0x00129d46
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_00129d46:
XOR EAX,EAX
LAB_00129d48:
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00129d5a:
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LEA RDI,[RSI + R14*0x1]
CALL 0x0010e740
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,R14
CALL 0x0010e5c0
ADD qword ptr [RSP + 0x28],R14
MOV RDI,R12
CALL 0x00115e89
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVAPS XMM1,xmmword ptr [RSP + 0x30]
MOVAPS XMM2,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [R12 + 0x20],XMM2
MOVUPS xmmword ptr [R12 + 0x10],XMM1
MOVUPS xmmword ptr [R12],XMM0
MOV RBX,qword ptr [RSP + 0x10]
MOV RDI,RBX
LEA RSI,[RSP + 0xc8]
CALL 0x0012abca
MOV RSI,qword ptr [RSP + 0x98]
MOV RDI,RBX
CALL 0x0011726e
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDI,RBX
CALL 0x0011726e
MOV RAX,qword ptr [RSP + 0x68]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RCX],RAX
MOV RSI,qword ptr [RSP + 0xb8]
MOV RCX,qword ptr [RSP + 0x8]
TEST RCX,RCX
JZ 0x00129e11
MOV qword ptr [RCX],RSI
MOVSXD RAX,dword ptr [RSP + 0xc0]
MOV qword ptr [RCX + 0x8],RAX
JMP 0x00129e19
LAB_00129e11:
MOV RDI,RBX
CALL 0x0011726e
LAB_00129e19:
MOV RAX,qword ptr [RSP + 0x60]
JMP 0x00129d48
|
int8
JS_WriteObject2(long param_1,int8 *param_2,int8 param_3,int8 param_4,uint param_5,
int8 *param_6)
{
long lVar1;
int iVar2;
long lVar3;
long lVar4;
size_t __n;
int4 local_f8;
int4 uStack_f4;
int8 uStack_f0;
int4 local_e8;
int4 uStack_e4;
int4 uStack_e0;
int4 uStack_dc;
int4 local_d8;
int4 uStack_d4;
int4 uStack_d0;
int4 uStack_cc;
long local_c0;
int4 local_b8;
int4 uStack_b4;
int iStack_b0;
int4 uStack_ac;
int4 local_a8;
int4 uStack_a4;
int4 uStack_a0;
int4 uStack_9c;
int4 local_98;
int4 uStack_94;
int4 uStack_90;
int4 uStack_8c;
uint local_88;
int4 local_84;
int8 local_80;
long local_70;
int local_68;
int8 local_60;
int local_58;
int8 local_50;
int8 uStack_48;
int8 local_40;
int8 uStack_38;
memset(&local_b8,0,0x88);
local_88 = ((param_5 & 0x30) << 0x14 | (param_5 & 8) << 0xd | (param_5 & 4) << 6 | param_5 & 1) ^
0x3000000;
local_84 = 0xe0;
if ((param_5 & 1) == 0) {
local_84 = 1;
}
local_c0 = param_1;
js_dbuf_init(param_1,&local_b8);
local_40 = 0;
uStack_38 = 0;
local_50 = 0;
uStack_48 = 0;
iVar2 = JS_WriteObjectRec(&local_c0,param_3,param_4);
if (iVar2 == 0) {
lVar1 = *(long *)(local_c0 + 0x18);
local_d8 = local_98;
uStack_d4 = uStack_94;
uStack_d0 = uStack_90;
uStack_cc = uStack_8c;
local_e8 = local_a8;
uStack_e4 = uStack_a4;
uStack_e0 = uStack_a0;
uStack_dc = uStack_9c;
local_f8 = local_b8;
uStack_f4 = uStack_b4;
uStack_f0 = CONCAT44(uStack_ac,iStack_b0);
js_dbuf_init(local_c0,&local_b8);
dbuf_putc(&local_b8,0x13);
dbuf_put_leb128(&local_b8,local_68);
for (lVar3 = 0; lVar3 < local_68; lVar3 = lVar3 + 1) {
lVar4 = (long)*(int *)(local_70 + lVar3 * 4);
if (lVar4 < 0xe0) {
dbuf_putc(&local_b8,0);
dbuf_put_u32(&local_b8);
}
else {
dbuf_putc(&local_b8,*(ulong *)(*(long *)(*(long *)(lVar1 + 0x68) + lVar4 * 8) + 4) >> 0x3e);
JS_WriteString(&local_c0);
}
}
__n = (size_t)iStack_b0;
iVar2 = dbuf_realloc(&local_f8,uStack_f0 + __n);
if (iVar2 == 0) {
memmove((void *)((long)CONCAT44(uStack_f4,local_f8) + __n),
(void *)CONCAT44(uStack_f4,local_f8),uStack_f0);
memcpy((void *)CONCAT44(uStack_f4,local_f8),(void *)CONCAT44(uStack_b4,local_b8),__n);
uStack_f0 = uStack_f0 + __n;
dbuf_free(&local_b8);
local_98 = local_d8;
uStack_94 = uStack_d4;
uStack_90 = uStack_d0;
uStack_8c = uStack_cc;
local_a8 = local_e8;
uStack_a4 = uStack_e4;
uStack_a0 = uStack_e0;
uStack_9c = uStack_dc;
local_b8 = local_f8;
uStack_b4 = uStack_f4;
iStack_b0 = (int4)uStack_f0;
uStack_ac = uStack_f0._4_4_;
js_object_list_end(param_1,&local_50);
js_free(param_1,local_80);
js_free(param_1,local_70);
*param_2 = CONCAT44(uStack_ac,iStack_b0);
if (param_6 == (int8 *)0x0) {
js_free(param_1);
}
else {
*param_6 = local_60;
param_6[1] = (long)local_58;
}
return CONCAT44(uStack_b4,local_b8);
}
dbuf_free(&local_f8);
}
js_object_list_end(param_1,&local_50);
js_free(param_1,local_80);
js_free(param_1,local_70);
dbuf_free(&local_b8);
*param_2 = 0;
if (param_6 != (int8 *)0x0) {
*param_6 = 0;
param_6[1] = 0;
}
return 0;
}
|
|
66,438 |
ggml_add_impl
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
static struct ggml_tensor * ggml_add_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
bool inplace) {
GGML_ASSERT(ggml_can_repeat(b, a));
bool is_node = false;
if (!inplace && (a->grad || b->grad)) {
// TODO: support backward pass for broadcasting
GGML_ASSERT(ggml_are_same_shape(a, b));
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
result->op = GGML_OP_ADD;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
}
|
O1
|
c
|
ggml_add_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rsi), %rsi
movq 0x10(%rdx), %rdi
movq %rsi, %rax
cqto
idivq %rdi
testq %rdx, %rdx
jne 0x90dc1
movq 0x18(%r14), %rax
cqto
idivq 0x18(%rbx)
testq %rdx, %rdx
jne 0x90dc1
movq 0x20(%r14), %rax
cqto
idivq 0x20(%rbx)
testq %rdx, %rdx
jne 0x90dc1
movq 0x28(%r14), %rax
cqto
idivq 0x28(%rbx)
testq %rdx, %rdx
jne 0x90dc1
testb %cl, %cl
je 0x90cf9
xorl %ebp, %ebp
jmp 0x90d43
cmpq $0x0, 0x98(%r14)
jne 0x90d0d
cmpq $0x0, 0x98(%rbx)
je 0x90cf5
cmpq %rdi, %rsi
jne 0x90dc6
movq 0x18(%r14), %rax
cmpq 0x18(%rbx), %rax
jne 0x90dc6
movq 0x20(%r14), %rax
cmpq 0x20(%rbx), %rax
jne 0x90dc6
movq 0x28(%r14), %rax
movb $0x1, %bpl
cmpq 0x28(%rbx), %rax
jne 0x90dc6
testb %cl, %cl
je 0x90d54
movq %r15, %rdi
movq %r14, %rsi
callq 0x90b1a
jmp 0x90d6e
leaq 0x10(%r14), %rcx
movl (%r14), %esi
movq %r15, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e8b7
movq %rax, %r12
movl $0x2, 0x50(%rax)
testb %bpl, %bpl
je 0x90d9b
movl (%r12), %esi
leaq 0x10(%r12), %rcx
movq %r15, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e8b7
jmp 0x90d9d
xorl %eax, %eax
movq %rax, 0x98(%r12)
movq %r14, 0xa0(%r12)
movq %rbx, 0xa8(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xcb09
callq 0xcb4e
|
ggml_add_impl:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rsi, [rsi+10h]
mov rdi, [rdx+10h]
mov rax, rsi
cqo
idiv rdi
test rdx, rdx
jnz loc_90DC1
mov rax, [r14+18h]
cqo
idiv qword ptr [rbx+18h]
test rdx, rdx
jnz loc_90DC1
mov rax, [r14+20h]
cqo
idiv qword ptr [rbx+20h]
test rdx, rdx
jnz loc_90DC1
mov rax, [r14+28h]
cqo
idiv qword ptr [rbx+28h]
test rdx, rdx
jnz loc_90DC1
test cl, cl
jz short loc_90CF9
loc_90CF5:
xor ebp, ebp
jmp short loc_90D43
loc_90CF9:
cmp qword ptr [r14+98h], 0
jnz short loc_90D0D
cmp qword ptr [rbx+98h], 0
jz short loc_90CF5
loc_90D0D:
cmp rsi, rdi
jnz loc_90DC6
mov rax, [r14+18h]
cmp rax, [rbx+18h]
jnz loc_90DC6
mov rax, [r14+20h]
cmp rax, [rbx+20h]
jnz loc_90DC6
mov rax, [r14+28h]
mov bpl, 1
cmp rax, [rbx+28h]
jnz loc_90DC6
loc_90D43:
test cl, cl
jz short loc_90D54
mov rdi, r15
mov rsi, r14
call ggml_view_tensor
jmp short loc_90D6E
loc_90D54:
lea rcx, [r14+10h]
mov esi, [r14]
mov rdi, r15
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_90D6E:
mov r12, rax
mov dword ptr [rax+50h], 2
test bpl, bpl
jz short loc_90D9B
mov esi, [r12]
lea rcx, [r12+10h]
mov rdi, r15
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
jmp short loc_90D9D
loc_90D9B:
xor eax, eax
loc_90D9D:
mov [r12+98h], rax
mov [r12+0A0h], r14
mov [r12+0A8h], rbx
mov rax, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_90DC1:
call ggml_add_impl_cold_1
loc_90DC6:
call ggml_add_impl_cold_2
|
_QWORD * ggml_add_impl(
long long a1,
long long a2,
_QWORD *a3,
char a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
long long v15; // rsi
long long v16; // rdi
char v17; // bp
long long v18; // rax
_QWORD *v19; // r12
long long v20; // rax
v15 = *(_QWORD *)(a2 + 16);
v16 = a3[2];
if ( v15 % v16 || *(long long *)(a2 + 24) % a3[3] || *(long long *)(a2 + 32) % a3[4] || *(long long *)(a2 + 40) % a3[5] )
ggml_add_impl_cold_1();
if ( !a4 && (*(_QWORD *)(a2 + 152) || a3[19]) )
{
if ( v15 != v16
|| *(_QWORD *)(a2 + 24) != a3[3]
|| *(_QWORD *)(a2 + 32) != a3[4]
|| (v17 = 1, *(_QWORD *)(a2 + 40) != a3[5]) )
{
ggml_add_impl_cold_2();
}
}
else
{
v17 = 0;
}
if ( a4 )
v18 = ggml_view_tensor(a1, a2, a5, a6, a7, a8, a9, a10, a11, a12);
else
v18 = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, (_QWORD *)(a2 + 16), 0LL, 0LL, a5, a6);
v19 = (_QWORD *)v18;
*(_DWORD *)(v18 + 80) = 2;
if ( v17 )
v20 = ggml_new_tensor_impl(a1, *(_DWORD *)v18, 4, (_QWORD *)(v18 + 16), 0LL, 0LL, a5, a6);
else
v20 = 0LL;
v19[19] = v20;
v19[20] = a2;
v19[21] = a3;
return v19;
}
| |||
66,439 |
ggml_add_impl
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
static struct ggml_tensor * ggml_add_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
bool inplace) {
GGML_ASSERT(ggml_can_repeat(b, a));
bool is_node = false;
if (!inplace && (a->grad || b->grad)) {
// TODO: support backward pass for broadcasting
GGML_ASSERT(ggml_are_same_shape(a, b));
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
result->op = GGML_OP_ADD;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
}
|
O2
|
c
|
ggml_add_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x6a83d
testb %al, %al
je 0x69b11
testb %bpl, %bpl
je 0x69a96
movq %r15, %rdi
movq %r14, %rsi
callq 0x69922
movq %rax, %r12
movl $0x2, 0x50(%rax)
jmp 0x69ae7
cmpq $0x0, 0x98(%r14)
jne 0x69aaa
cmpq $0x0, 0x98(%rbx)
je 0x69b0d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x67e29
movb $0x1, %bpl
testb %al, %al
je 0x69b46
movq %r15, %rdi
movq %r14, %rsi
callq 0x68a65
movq %rax, %r12
movl $0x2, 0x50(%rax)
testb %bpl, %bpl
je 0x69ae7
movq %r15, %rdi
movq %r12, %rsi
callq 0x68a65
jmp 0x69ae9
xorl %eax, %eax
movq %rax, 0x98(%r12)
movq %r14, 0xa0(%r12)
movq %rbx, 0xa8(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x69ac0
movq 0x6c430(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6c481(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x306ed(%rip), %rsi # 0x9a21e
leaq 0x37d46(%rip), %rdx # 0xa187e
leaq 0x3803a(%rip), %r8 # 0xa1b79
movl $0xc6a, %ecx # imm = 0xC6A
jmp 0x69b79
movq 0x6c3fb(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6c44c(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x306b8(%rip), %rsi # 0x9a21e
leaq 0x37d11(%rip), %rdx # 0xa187e
leaq 0x38632(%rip), %r8 # 0xa21a6
movl $0xc70, %ecx # imm = 0xC70
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
|
ggml_add_impl:
push rbp
push r15
push r14
push r12
push rbx
mov ebp, ecx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rdx
call ggml_can_repeat
test al, al
jz loc_69B11
test bpl, bpl
jz short loc_69A96
mov rdi, r15
mov rsi, r14
call ggml_view_tensor
mov r12, rax
mov dword ptr [rax+50h], 2
jmp short loc_69AE7
loc_69A96:
cmp qword ptr [r14+98h], 0
jnz short loc_69AAA
cmp qword ptr [rbx+98h], 0
jz short loc_69B0D
loc_69AAA:
mov rdi, r14
mov rsi, rbx
call ggml_are_same_shape
mov bpl, 1
test al, al
jz loc_69B46
loc_69AC0:
mov rdi, r15
mov rsi, r14
call ggml_dup_tensor
mov r12, rax
mov dword ptr [rax+50h], 2
test bpl, bpl
jz short loc_69AE7
mov rdi, r15
mov rsi, r12
call ggml_dup_tensor
jmp short loc_69AE9
loc_69AE7:
xor eax, eax
loc_69AE9:
mov [r12+98h], rax
mov [r12+0A0h], r14
mov [r12+0A8h], rbx
mov rax, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_69B0D:
xor ebp, ebp
jmp short loc_69AC0
loc_69B11:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aGgmlCanRepeatB; "ggml_can_repeat(b, a)"
mov ecx, 0C6Ah
jmp short loc_69B79
loc_69B46:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aGgmlAreSameSha; "ggml_are_same_shape(a, b)"
mov ecx, 0C70h
loc_69B79:
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
|
long long ggml_add_impl(
long long a1,
unsigned int *a2,
_QWORD *a3,
char a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
double v14; // xmm4_8
double v15; // xmm5_8
long long v16; // r12
char v17; // bp
unsigned int *v18; // rax
long long v19; // rax
long long v21; // rdi
if ( !(unsigned __int8)ggml_can_repeat(a3) )
{
fflush(stdout);
v21 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
3178LL,
"ggml_can_repeat(b, a)");
goto LABEL_14;
}
if ( a4 )
{
v16 = ggml_view_tensor(a1, (long long)a2, a5, a6, a7, a8, v14, v15, a11, a12);
*(_DWORD *)(v16 + 80) = 2;
LABEL_9:
v19 = 0LL;
goto LABEL_10;
}
if ( *((_QWORD *)a2 + 19) || a3[19] )
{
v17 = 1;
if ( ggml_are_same_shape(a2, a3) )
goto LABEL_7;
fflush(stdout);
v21 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
3184LL,
"ggml_are_same_shape(a, b)");
LABEL_14:
ggml_print_backtrace();
abort(v21);
}
v17 = 0;
LABEL_7:
v18 = (unsigned int *)ggml_dup_tensor(a1, a2);
v16 = (long long)v18;
v18[20] = 2;
if ( !v17 )
goto LABEL_9;
v19 = ggml_dup_tensor(a1, v18);
LABEL_10:
*(_QWORD *)(v16 + 152) = v19;
*(_QWORD *)(v16 + 160) = a2;
*(_QWORD *)(v16 + 168) = a3;
return v16;
}
|
ggml_add_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBP,ECX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RDX
CALL 0x0016a83d
TEST AL,AL
JZ 0x00169b11
TEST BPL,BPL
JZ 0x00169a96
MOV RDI,R15
MOV RSI,R14
CALL 0x00169922
MOV R12,RAX
MOV dword ptr [RAX + 0x50],0x2
JMP 0x00169ae7
LAB_00169a96:
CMP qword ptr [R14 + 0x98],0x0
JNZ 0x00169aaa
CMP qword ptr [RBX + 0x98],0x0
JZ 0x00169b0d
LAB_00169aaa:
MOV RDI,R14
MOV RSI,RBX
CALL 0x00167e29
MOV BPL,0x1
TEST AL,AL
JZ 0x00169b46
LAB_00169ac0:
MOV RDI,R15
MOV RSI,R14
CALL 0x00168a65
MOV R12,RAX
MOV dword ptr [RAX + 0x50],0x2
TEST BPL,BPL
JZ 0x00169ae7
MOV RDI,R15
MOV RSI,R12
CALL 0x00168a65
JMP 0x00169ae9
LAB_00169ae7:
XOR EAX,EAX
LAB_00169ae9:
MOV qword ptr [R12 + 0x98],RAX
MOV qword ptr [R12 + 0xa0],R14
MOV qword ptr [R12 + 0xa8],RBX
MOV RAX,R12
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00169b0d:
XOR EBP,EBP
JMP 0x00169ac0
LAB_00169b11:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1b79]
MOV ECX,0xc6a
JMP 0x00169b79
LAB_00169b46:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a21a6]
MOV ECX,0xc70
LAB_00169b79:
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
long ggml_add_impl(int8 param_1,long param_2,long param_3,char param_4)
{
bool bVar1;
char cVar2;
long lVar3;
int8 uVar4;
FILE *__stream;
char *pcVar5;
cVar2 = ggml_can_repeat(param_3);
if (cVar2 == '\0') {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar5 = "ggml_can_repeat(b, a)";
uVar4 = 0xc6a;
LAB_00169b79:
fprintf(__stream,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
uVar4,pcVar5);
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
if (param_4 == '\0') {
if ((*(long *)(param_2 + 0x98) == 0) && (*(long *)(param_3 + 0x98) == 0)) {
bVar1 = false;
}
else {
cVar2 = ggml_are_same_shape(param_2,param_3);
bVar1 = true;
if (cVar2 == '\0') {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar5 = "ggml_are_same_shape(a, b)";
uVar4 = 0xc70;
goto LAB_00169b79;
}
}
lVar3 = ggml_dup_tensor(param_1,param_2);
*(int4 *)(lVar3 + 0x50) = 2;
if (bVar1) {
uVar4 = ggml_dup_tensor(param_1,lVar3);
goto LAB_00169ae9;
}
}
else {
lVar3 = ggml_view_tensor(param_1,param_2);
*(int4 *)(lVar3 + 0x50) = 2;
}
uVar4 = 0;
LAB_00169ae9:
*(int8 *)(lVar3 + 0x98) = uVar4;
*(long *)(lVar3 + 0xa0) = param_2;
*(long *)(lVar3 + 0xa8) = param_3;
return lVar3;
}
|
|
66,440 |
quorem
|
eloqsql/libmariadb/libmariadb/ma_dtoa.c
|
static int quorem(Bigint *b, Bigint *S)
{
int n;
ULong *bx, *bxe, q, *sx, *sxe;
ULLong borrow, carry, y, ys;
n= S->wds;
if (b->wds < n)
return 0;
sx= S->p.x;
sxe= sx + --n;
bx= b->p.x;
bxe= bx + n;
q= *bxe / (*sxe + 1); /* ensure q <= true quotient */
if (q)
{
borrow= 0;
carry= 0;
do
{
ys= *sx++ * (ULLong)q + carry;
carry= ys >> 32;
y= *bx - (ys & FFFFFFFF) - borrow;
borrow= y >> 32 & (ULong)1;
*bx++= (ULong) (y & FFFFFFFF);
}
while (sx <= sxe);
if (!*bxe)
{
bx= b->p.x;
while (--bxe > bx && !*bxe)
--n;
b->wds= n;
}
}
if (cmp(b, S) >= 0)
{
q++;
borrow= 0;
carry= 0;
bx= b->p.x;
sx= S->p.x;
do
{
ys= *sx++ + carry;
carry= ys >> 32;
y= *bx - (ys & FFFFFFFF) - borrow;
borrow= y >> 32 & (ULong)1;
*bx++= (ULong) (y & FFFFFFFF);
}
while (sx <= sxe);
bx= b->p.x;
bxe= bx + n;
if (!*bxe)
{
while (--bxe > bx && !*bxe)
--n;
b->wds= n;
}
}
return q;
}
|
O0
|
c
|
quorem:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4f8d2
movl $0x0, -0x4(%rbp)
jmp 0x4fb63
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq -0x48(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x4fa2a
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
movl -0x34(%rbp), %ecx
imulq %rcx, %rax
addq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movabsq $0xffffffff, %rcx # imm = 0xFFFFFFFF
andq -0x68(%rbp), %rcx
subq %rcx, %rax
subq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x50(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x60(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0x4f946
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4fa28
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
addq $-0x4, %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x69(%rbp)
jbe 0x4fa0a
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x4fa13
jmp 0x4fa1e
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f9e4
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x4fa2a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4f580
cmpl $0x0, %eax
jl 0x4fb5d
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
addq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movabsq $0xffffffff, %rcx # imm = 0xFFFFFFFF
andq -0x68(%rbp), %rcx
subq %rcx, %rax
subq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x50(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x60(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0x4fa6f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4fb5b
jmp 0x4fb17
movq -0x30(%rbp), %rcx
addq $-0x4, %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x6a(%rbp)
jbe 0x4fb3d
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x6a(%rbp)
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0x4fb46
jmp 0x4fb51
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4fb17
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x4fb5d
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
|
quorem:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
mov eax, [rax+14h]
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov eax, [rax+14h]
cmp eax, [rbp+var_1C]
jge short loc_4F8D2
mov [rbp+var_4], 0
jmp loc_4FB63
loc_4F8D2:
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov ecx, [rbp+var_1C]
add ecx, 0FFFFFFFFh
mov [rbp+var_1C], ecx
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_1C]
shl rcx, 2
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov eax, [rax]
mov rcx, [rbp+var_48]
mov ecx, [rcx]
add ecx, 1
xor edx, edx
div ecx
mov [rbp+var_34], eax
cmp [rbp+var_34], 0
jz loc_4FA2A
mov [rbp+var_50], 0
mov [rbp+var_58], 0
loc_4F946:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov eax, [rax]
mov ecx, [rbp+var_34]
imul rax, rcx
add rax, [rbp+var_58]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
shr rax, 20h
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov eax, [rax]
mov rcx, 0FFFFFFFFh
and rcx, [rbp+var_68]
sub rax, rcx
sub rax, [rbp+var_50]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
shr rax, 20h
and rax, 1
mov [rbp+var_50], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_60]
mov ecx, eax
mov rax, [rbp+var_28]
mov rdx, rax
add rdx, 4
mov [rbp+var_28], rdx
mov [rax], ecx
mov rax, [rbp+var_40]
cmp rax, [rbp+var_48]
jbe loc_4F946
mov rax, [rbp+var_30]
cmp dword ptr [rax], 0
jnz short loc_4FA28
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
loc_4F9E4:
mov rcx, [rbp+var_30]
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_30], rcx
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_69], al
jbe short loc_4FA0A
mov rax, [rbp+var_30]
cmp dword ptr [rax], 0
setnz al
xor al, 0FFh
mov [rbp+var_69], al
loc_4FA0A:
mov al, [rbp+var_69]
test al, 1
jnz short loc_4FA13
jmp short loc_4FA1E
loc_4FA13:
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
jmp short loc_4F9E4
loc_4FA1E:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
loc_4FA28:
jmp short $+2
loc_4FA2A:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call cmp
cmp eax, 0
jl loc_4FB5D
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
mov [rbp+var_50], 0
mov [rbp+var_58], 0
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_40], rax
loc_4FA6F:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov eax, [rax]
add rax, [rbp+var_58]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
shr rax, 20h
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov eax, [rax]
mov rcx, 0FFFFFFFFh
and rcx, [rbp+var_68]
sub rax, rcx
sub rax, [rbp+var_50]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
shr rax, 20h
and rax, 1
mov [rbp+var_50], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_60]
mov ecx, eax
mov rax, [rbp+var_28]
mov rdx, rax
add rdx, 4
mov [rbp+var_28], rdx
mov [rax], ecx
mov rax, [rbp+var_40]
cmp rax, [rbp+var_48]
jbe short loc_4FA6F
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_1C]
shl rcx, 2
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
cmp dword ptr [rax], 0
jnz short loc_4FB5B
jmp short $+2
loc_4FB17:
mov rcx, [rbp+var_30]
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_30], rcx
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_6A], al
jbe short loc_4FB3D
mov rax, [rbp+var_30]
cmp dword ptr [rax], 0
setnz al
xor al, 0FFh
mov [rbp+var_6A], al
loc_4FB3D:
mov al, [rbp+var_6A]
test al, 1
jnz short loc_4FB46
jmp short loc_4FB51
loc_4FB46:
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
jmp short loc_4FB17
loc_4FB51:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
loc_4FB5B:
jmp short $+2
loc_4FB5D:
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
loc_4FB63:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
|
long long quorem(long long a1, long long a2)
{
unsigned int *v2; // rax
unsigned int *v3; // rax
unsigned int *v4; // rax
unsigned int *v5; // rax
char v7; // [rsp+6h] [rbp-6Ah]
char v8; // [rsp+7h] [rbp-69h]
unsigned long long v9; // [rsp+8h] [rbp-68h]
unsigned long long v10; // [rsp+8h] [rbp-68h]
unsigned long long v11; // [rsp+10h] [rbp-60h]
unsigned long long v12; // [rsp+10h] [rbp-60h]
unsigned long long v13; // [rsp+18h] [rbp-58h]
unsigned long long v14; // [rsp+18h] [rbp-58h]
long long v15; // [rsp+20h] [rbp-50h]
long long v16; // [rsp+20h] [rbp-50h]
unsigned int *v17; // [rsp+28h] [rbp-48h]
unsigned int *v18; // [rsp+30h] [rbp-40h]
unsigned int *v19; // [rsp+30h] [rbp-40h]
unsigned int v20; // [rsp+3Ch] [rbp-34h]
_DWORD *v21; // [rsp+40h] [rbp-30h]
_DWORD *v22; // [rsp+40h] [rbp-30h]
unsigned int *v23; // [rsp+48h] [rbp-28h]
unsigned int *v24; // [rsp+48h] [rbp-28h]
int v25; // [rsp+54h] [rbp-1Ch]
int v26; // [rsp+54h] [rbp-1Ch]
v25 = *(_DWORD *)(a2 + 20);
if ( *(_DWORD *)(a1 + 20) >= v25 )
{
v18 = *(unsigned int **)a2;
v26 = v25 - 1;
v17 = (unsigned int *)(4LL * v26 + *(_QWORD *)a2);
v23 = *(unsigned int **)a1;
v21 = (_DWORD *)(4LL * v26 + *(_QWORD *)a1);
v20 = *v21 / (*v17 + 1);
if ( v20 )
{
v15 = 0LL;
v13 = 0LL;
do
{
v2 = v18++;
v9 = v13 + v20 * (unsigned long long)*v2;
v13 = HIDWORD(v9);
v11 = *v23 - (unsigned long long)(unsigned int)v9 - v15;
v15 = HIDWORD(v11) & 1;
v3 = v23++;
*v3 = v11;
}
while ( v18 <= v17 );
if ( !*v21 )
{
while ( 1 )
{
--v21;
v8 = 0;
if ( (unsigned long long)v21 > *(_QWORD *)a1 )
v8 = ~(*v21 != 0);
if ( (v8 & 1) == 0 )
break;
--v26;
}
*(_DWORD *)(a1 + 20) = v26;
}
}
if ( (int)cmp(a1, a2) >= 0 )
{
++v20;
v16 = 0LL;
v14 = 0LL;
v24 = *(unsigned int **)a1;
v19 = *(unsigned int **)a2;
do
{
v4 = v19++;
v10 = v14 + *v4;
v14 = HIDWORD(v10);
v12 = *v24 - (unsigned long long)(unsigned int)v10 - v16;
v16 = HIDWORD(v12) & 1;
v5 = v24++;
*v5 = v12;
}
while ( v19 <= v17 );
v22 = (_DWORD *)(4LL * v26 + *(_QWORD *)a1);
if ( !*v22 )
{
while ( 1 )
{
--v22;
v7 = 0;
if ( (unsigned long long)v22 > *(_QWORD *)a1 )
v7 = ~(*v22 != 0);
if ( (v7 & 1) == 0 )
break;
--v26;
}
*(_DWORD *)(a1 + 20) = v26;
}
}
return v20;
}
else
{
return 0;
}
}
|
quorem:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x0014f8d2
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014fb63
LAB_0014f8d2:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,-0x1
MOV dword ptr [RBP + -0x1c],ECX
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x1c]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RCX]
ADD ECX,0x1
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0x34],EAX
CMP dword ptr [RBP + -0x34],0x0
JZ 0x0014fa2a
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x58],0x0
LAB_0014f946:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x34]
IMUL RAX,RCX
ADD RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
SHR RAX,0x20
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV RCX,0xffffffff
AND RCX,qword ptr [RBP + -0x68]
SUB RAX,RCX
SUB RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
SHR RAX,0x20
AND RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x60]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x0014f946
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX],0x0
JNZ 0x0014fa28
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
LAB_0014f9e4:
MOV RCX,qword ptr [RBP + -0x30]
ADD RCX,-0x4
MOV qword ptr [RBP + -0x30],RCX
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x69],AL
JBE 0x0014fa0a
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x69],AL
LAB_0014fa0a:
MOV AL,byte ptr [RBP + -0x69]
TEST AL,0x1
JNZ 0x0014fa13
JMP 0x0014fa1e
LAB_0014fa13:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0014f9e4
LAB_0014fa1e:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
LAB_0014fa28:
JMP 0x0014fa2a
LAB_0014fa2a:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0014f580
CMP EAX,0x0
JL 0x0014fb5d
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
LAB_0014fa6f:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RAX]
ADD RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
SHR RAX,0x20
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV RCX,0xffffffff
AND RCX,qword ptr [RBP + -0x68]
SUB RAX,RCX
SUB RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
SHR RAX,0x20
AND RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x60]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x0014fa6f
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x1c]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX],0x0
JNZ 0x0014fb5b
JMP 0x0014fb17
LAB_0014fb17:
MOV RCX,qword ptr [RBP + -0x30]
ADD RCX,-0x4
MOV qword ptr [RBP + -0x30],RCX
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x6a],AL
JBE 0x0014fb3d
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x6a],AL
LAB_0014fb3d:
MOV AL,byte ptr [RBP + -0x6a]
TEST AL,0x1
JNZ 0x0014fb46
JMP 0x0014fb51
LAB_0014fb46:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0014fb17
LAB_0014fb51:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
LAB_0014fb5b:
JMP 0x0014fb5d
LAB_0014fb5d:
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
LAB_0014fb63:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
uint quorem(int8 *param_1,int8 *param_2)
{
int iVar1;
uint *puVar2;
ulong uVar3;
uint *puVar4;
bool bVar5;
ulong local_60;
ulong local_58;
uint *local_48;
uint local_3c;
uint *local_38;
uint *local_30;
int local_24;
uint local_c;
if (*(int *)((long)param_1 + 0x14) < *(int *)((long)param_2 + 0x14)) {
local_c = 0;
}
else {
local_24 = *(int *)((long)param_2 + 0x14) + -1;
puVar2 = (uint *)*param_2 + local_24;
local_38 = (uint *)*param_1 + local_24;
local_3c = *local_38 / (*puVar2 + 1);
if (local_3c != 0) {
local_58 = 0;
local_60 = 0;
local_48 = (uint *)*param_2;
local_30 = (uint *)*param_1;
do {
puVar4 = local_48 + 1;
uVar3 = (ulong)*local_48 * (ulong)local_3c + local_60;
local_60 = uVar3 >> 0x20;
uVar3 = ((ulong)*local_30 - (uVar3 & 0xffffffff)) - local_58;
local_58 = uVar3 >> 0x20 & 1;
*local_30 = (uint)uVar3;
local_48 = puVar4;
local_30 = local_30 + 1;
} while (puVar4 <= puVar2);
if (*local_38 == 0) {
while( true ) {
local_38 = local_38 + -1;
bVar5 = false;
if ((uint *)*param_1 < local_38) {
bVar5 = *local_38 == 0;
}
if (!bVar5) break;
local_24 = local_24 + -1;
}
*(int *)((long)param_1 + 0x14) = local_24;
}
}
iVar1 = cmp(param_1,param_2);
if (-1 < iVar1) {
local_3c = local_3c + 1;
local_58 = 0;
local_60 = 0;
local_48 = (uint *)*param_2;
local_30 = (uint *)*param_1;
do {
puVar4 = local_48 + 1;
uVar3 = *local_48 + local_60;
local_60 = uVar3 >> 0x20;
uVar3 = ((ulong)*local_30 - (uVar3 & 0xffffffff)) - local_58;
local_58 = uVar3 >> 0x20 & 1;
*local_30 = (uint)uVar3;
local_48 = puVar4;
local_30 = local_30 + 1;
} while (puVar4 <= puVar2);
local_38 = (uint *)((int *)*param_1 + local_24);
if (*local_38 == 0) {
while( true ) {
local_38 = local_38 + -1;
bVar5 = false;
if ((int *)*param_1 < local_38) {
bVar5 = *local_38 == 0;
}
if (!bVar5) break;
local_24 = local_24 + -1;
}
*(int *)((long)param_1 + 0x14) = local_24;
}
}
local_c = local_3c;
}
return local_c;
}
|
|
66,441 |
lf_pinbox_get_pins
|
eloqsql/mysys/lf_alloc-pin.c
|
LF_PINS *lf_pinbox_get_pins(LF_PINBOX *pinbox)
{
uint32 pins, next, top_ver;
LF_PINS *el;
/*
We have an array of max. 64k elements.
The highest index currently allocated is pinbox->pins_in_array.
Freed elements are in a lifo stack, pinstack_top_ver.
pinstack_top_ver is 32 bits; 16 low bits are the index in the
array, to the first element of the list. 16 high bits are a version
(every time the 16 low bits are updated, the 16 high bits are
incremented). Versioning prevents the ABA problem.
*/
top_ver= pinbox->pinstack_top_ver;
do
{
if (!(pins= top_ver % LF_PINBOX_MAX_PINS))
{
/* the stack of free elements is empty */
pins= my_atomic_add32((int32 volatile*) &pinbox->pins_in_array, 1)+1;
if (unlikely(pins >= LF_PINBOX_MAX_PINS))
return 0;
/*
note that the first allocated element has index 1 (pins==1).
index 0 is reserved to mean "NULL pointer"
*/
el= (LF_PINS *)lf_dynarray_lvalue(&pinbox->pinarray, pins);
if (unlikely(!el))
return 0;
break;
}
el= (LF_PINS *)lf_dynarray_value(&pinbox->pinarray, pins);
next= el->link;
} while (!my_atomic_cas32((int32 volatile*) &pinbox->pinstack_top_ver,
(int32*) &top_ver,
top_ver-pins+next+LF_PINBOX_MAX_PINS));
/*
set el->link to the index of el in the dynarray (el->link has two usages:
- if element is allocated, it's its own index
- if element is free, it's its next element in the free stack
*/
el->link= pins;
el->purgatory_count= 0;
el->pinbox= pinbox;
return el;
}
|
O3
|
c
|
lf_pinbox_get_pins:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x3c(%rdi), %r15d
movl %r15d, %r14d
andl $0xffff, %r14d # imm = 0xFFFF
je 0x2f273
movq %rbx, %rdi
movl %r14d, %esi
callq 0xa6a04
movq %rax, %rcx
movl 0x34(%rax), %eax
movl %r15d, %edx
andl $0xffff0000, %edx # imm = 0xFFFF0000
addl %eax, %edx
addl $0x10000, %edx # imm = 0x10000
movl %r15d, %eax
lock
cmpxchgl %edx, 0x3c(%rbx)
movl %eax, %r15d
jne 0x2f236
jmp 0x2f29c
pushq $0x1
popq %r14
lock
xaddl %r14d, 0x40(%rbx)
incl %r14d
cmpl $0xffff, %r14d # imm = 0xFFFF
ja 0x2f2b6
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2f2ba
testq %rax, %rax
je 0x2f2b6
movq %rax, %rcx
movl %r14d, 0x34(%rcx)
andl $0x0, 0x30(%rcx)
movq %rbx, 0x20(%rcx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
jmp 0x2f2a8
|
lf_pinbox_get_pins:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r15d, [rdi+3Ch]
loc_2F236:
mov r14d, r15d
and r14d, 0FFFFh
jz short loc_2F273
mov rdi, rbx
mov esi, r14d
call lf_dynarray_value
mov rcx, rax
mov eax, [rax+34h]
mov edx, r15d
and edx, 0FFFF0000h
add edx, eax
add edx, 10000h
mov eax, r15d
lock cmpxchg [rbx+3Ch], edx
mov r15d, eax
jnz short loc_2F236
jmp short loc_2F29C
loc_2F273:
push 1
pop r14
lock xadd [rbx+40h], r14d
inc r14d
cmp r14d, 0FFFFh
ja short loc_2F2B6
mov rdi, rbx
mov esi, r14d
call lf_dynarray_lvalue
test rax, rax
jz short loc_2F2B6
mov rcx, rax
loc_2F29C:
mov [rcx+34h], r14d
and dword ptr [rcx+30h], 0
mov [rcx+20h], rbx
loc_2F2A8:
mov rax, rcx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2F2B6:
xor ecx, ecx
jmp short loc_2F2A8
|
long long lf_pinbox_get_pins(long long a1)
{
signed __int32 v1; // r15d
unsigned __int32 v2; // r14d
long long v3; // rcx
bool v4; // zf
signed __int32 v5; // eax
long long v6; // rax
v1 = *(_DWORD *)(a1 + 60);
while ( 1 )
{
v2 = (unsigned __int16)v1;
if ( !(_WORD)v1 )
break;
v3 = lf_dynarray_value(a1, (unsigned __int16)v1);
v5 = _InterlockedCompareExchange(
(volatile signed __int32 *)(a1 + 60),
*(_DWORD *)(v3 + 52) + (v1 & 0xFFFF0000) + 0x10000,
v1);
v4 = v1 == v5;
v1 = v5;
if ( v4 )
goto LABEL_8;
}
v2 = _InterlockedIncrement((volatile signed __int32 *)(a1 + 64));
if ( v2 <= 0xFFFF )
{
v6 = lf_dynarray_lvalue(a1, v2);
if ( v6 )
{
v3 = v6;
LABEL_8:
*(_DWORD *)(v3 + 52) = v2;
*(_DWORD *)(v3 + 48) = 0;
*(_QWORD *)(v3 + 32) = a1;
return v3;
}
}
return 0LL;
}
|
lf_pinbox_get_pins:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R15D,dword ptr [RDI + 0x3c]
LAB_0012f236:
MOV R14D,R15D
AND R14D,0xffff
JZ 0x0012f273
MOV RDI,RBX
MOV ESI,R14D
CALL 0x001a6a04
MOV RCX,RAX
MOV EAX,dword ptr [RAX + 0x34]
MOV EDX,R15D
AND EDX,0xffff0000
ADD EDX,EAX
ADD EDX,0x10000
MOV EAX,R15D
CMPXCHG.LOCK dword ptr [RBX + 0x3c],EDX
MOV R15D,EAX
JNZ 0x0012f236
JMP 0x0012f29c
LAB_0012f273:
PUSH 0x1
POP R14
XADD.LOCK dword ptr [RBX + 0x40],R14D
INC R14D
CMP R14D,0xffff
JA 0x0012f2b6
MOV RDI,RBX
MOV ESI,R14D
CALL 0x0012f2ba
TEST RAX,RAX
JZ 0x0012f2b6
MOV RCX,RAX
LAB_0012f29c:
MOV dword ptr [RCX + 0x34],R14D
AND dword ptr [RCX + 0x30],0x0
MOV qword ptr [RCX + 0x20],RBX
LAB_0012f2a8:
MOV RAX,RCX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0012f2b6:
XOR ECX,ECX
JMP 0x0012f2a8
|
long lf_pinbox_get_pins(long param_1)
{
int *piVar1;
uint uVar2;
int iVar3;
long lVar4;
uint uVar5;
uint uVar6;
bool bVar7;
uVar6 = *(uint *)(param_1 + 0x3c);
do {
uVar5 = uVar6 & 0xffff;
if (uVar5 == 0) {
LOCK();
piVar1 = (int *)(param_1 + 0x40);
iVar3 = *piVar1;
*piVar1 = *piVar1 + 1;
UNLOCK();
uVar5 = iVar3 + 1;
if ((0xffff < uVar5) || (lVar4 = lf_dynarray_lvalue(param_1,uVar5), lVar4 == 0)) {
return 0;
}
break;
}
lVar4 = lf_dynarray_value(param_1,uVar5);
LOCK();
uVar2 = *(uint *)(param_1 + 0x3c);
bVar7 = uVar6 == uVar2;
if (bVar7) {
*(uint *)(param_1 + 0x3c) = (uVar6 & 0xffff0000) + *(int *)(lVar4 + 0x34) + 0x10000;
uVar2 = uVar6;
}
uVar6 = uVar2;
UNLOCK();
} while (!bVar7);
*(uint *)(lVar4 + 0x34) = uVar5;
*(int4 *)(lVar4 + 0x30) = 0;
*(long *)(lVar4 + 0x20) = param_1;
return lVar4;
}
|
|
66,442 |
my_wc_mb_euc_kr
|
eloqsql/strings/ctype-euc_kr.c
|
static int
my_wc_mb_euc_kr(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((uint) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_ksc5601_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
}
|
O3
|
c
|
my_wc_mb_euc_kr:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xc5a9e
cmpl $0x7f, %esi
ja 0xc5a9f
movb %sil, (%rdx)
movl $0x1, %eax
retq
leal -0xa1(%rsi), %eax
cmpl $0xc6, %eax
ja 0xc5aba
movl %eax, %eax
leaq 0xd887b(%rip), %rsi # 0x19e330
jmp 0xc5bb2
leal -0x2c7(%rsi), %eax
cmpl $0x18a, %eax # imm = 0x18A
ja 0xc5ad5
movl %eax, %eax
leaq 0xd89f0(%rip), %rsi # 0x19e4c0
jmp 0xc5bb2
leal -0x2015(%rsi), %eax
cmpl $0x2fd, %eax # imm = 0x2FD
ja 0xc5af0
movl %eax, %eax
leaq 0xd8cf5(%rip), %rsi # 0x19e7e0
jmp 0xc5bb2
leal -0x2460(%rsi), %eax
cmpl $0x20d, %eax # imm = 0x20D
ja 0xc5b0b
movl %eax, %eax
leaq 0xd92da(%rip), %rsi # 0x19ede0
jmp 0xc5bb2
leal -0x3000(%rsi), %eax
cmpl $0x27f, %eax # imm = 0x27F
ja 0xc5b26
movl %eax, %eax
leaq 0xd96df(%rip), %rsi # 0x19f200
jmp 0xc5bb2
leal -0x3380(%rsi), %eax
cmpl $0x5d, %eax
ja 0xc5b3c
movl %eax, %eax
leaq 0xd9bc6(%rip), %rsi # 0x19f700
jmp 0xc5bb2
leal -0x4e00(%rsi), %eax
cmpl $0x467f, %eax # imm = 0x467F
ja 0xc5b54
movl %eax, %eax
leaq 0xd9c6e(%rip), %rsi # 0x19f7c0
jmp 0xc5bb2
leal -0x9577(%rsi), %eax
cmpl $0xa25, %eax # imm = 0xA25
ja 0xc5b6c
movl %eax, %eax
leaq 0xe2956(%rip), %rsi # 0x1a84c0
jmp 0xc5bb2
leal -0xac00(%rsi), %eax
cmpl $0x2ba3, %eax # imm = 0x2BA3
ja 0xc5b84
movl %eax, %eax
leaq 0xe3d8e(%rip), %rsi # 0x1a9910
jmp 0xc5bb2
leal -0xf900(%rsi), %eax
cmpl $0x10b, %eax # imm = 0x10B
ja 0xc5b9c
movl %eax, %eax
leaq 0xe94c6(%rip), %rsi # 0x1af060
jmp 0xc5bb2
leal -0xff01(%rsi), %eax
cmpl $0xe5, %eax
ja 0xc5be2
movl %eax, %eax
leaq 0xe96ce(%rip), %rsi # 0x1af280
leaq (%rsi,%rax,2), %rax
pushq %rbp
movq %rsp, %rbp
movzwl (%rax), %esi
testw %si, %si
je 0xc5bde
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0xc5be0
rolw $0x8, %si
movw %si, (%rdx)
movl $0x2, %eax
jmp 0xc5be0
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
|
my_wc_mb_euc_kr:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_C5A9E
cmp esi, 7Fh
ja short loc_C5A9F
mov [rdx], sil
mov eax, 1
locret_C5A9E:
retn
loc_C5A9F:
lea eax, [rsi-0A1h]
cmp eax, 0C6h
ja short loc_C5ABA
mov eax, eax
lea rsi, tab_uni_ksc56010
jmp loc_C5BB2
loc_C5ABA:
lea eax, [rsi-2C7h]
cmp eax, 18Ah
ja short loc_C5AD5
mov eax, eax
lea rsi, tab_uni_ksc56011
jmp loc_C5BB2
loc_C5AD5:
lea eax, [rsi-2015h]
cmp eax, 2FDh
ja short loc_C5AF0
mov eax, eax
lea rsi, tab_uni_ksc56012
jmp loc_C5BB2
loc_C5AF0:
lea eax, [rsi-2460h]
cmp eax, 20Dh
ja short loc_C5B0B
mov eax, eax
lea rsi, tab_uni_ksc56013
jmp loc_C5BB2
loc_C5B0B:
lea eax, [rsi-3000h]
cmp eax, 27Fh
ja short loc_C5B26
mov eax, eax
lea rsi, tab_uni_ksc56014
jmp loc_C5BB2
loc_C5B26:
lea eax, [rsi-3380h]
cmp eax, 5Dh ; ']'
ja short loc_C5B3C
mov eax, eax
lea rsi, tab_uni_ksc56015
jmp short loc_C5BB2
loc_C5B3C:
lea eax, [rsi-4E00h]
cmp eax, 467Fh
ja short loc_C5B54
mov eax, eax
lea rsi, tab_uni_ksc56016
jmp short loc_C5BB2
loc_C5B54:
lea eax, [rsi-9577h]
cmp eax, 0A25h
ja short loc_C5B6C
mov eax, eax
lea rsi, tab_uni_ksc56017
jmp short loc_C5BB2
loc_C5B6C:
lea eax, [rsi-0AC00h]
cmp eax, 2BA3h
ja short loc_C5B84
mov eax, eax
lea rsi, tab_uni_ksc56018
jmp short loc_C5BB2
loc_C5B84:
lea eax, [rsi-0F900h]
cmp eax, 10Bh
ja short loc_C5B9C
mov eax, eax
lea rsi, tab_uni_ksc56019
jmp short loc_C5BB2
loc_C5B9C:
lea eax, [rsi-0FF01h]
cmp eax, 0E5h
ja short loc_C5BE2
mov eax, eax
lea rsi, tab_uni_ksc560110
loc_C5BB2:
lea rax, [rsi+rax*2]
push rbp
mov rbp, rsp
movzx esi, word ptr [rax]
test si, si
jz short loc_C5BDE
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_C5BE0
rol si, 8
mov [rdx], si
mov eax, 2
jmp short loc_C5BE0
loc_C5BDE:
xor eax, eax
loc_C5BE0:
pop rbp
retn
loc_C5BE2:
xor eax, eax
retn
|
long long my_wc_mb_euc_kr(long long a1, unsigned int a2, _WORD *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rax
_WORD *v6; // rsi
__int16 v7; // si
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
if ( a2 > 0x7F )
{
LODWORD(v5) = a2 - 161;
if ( a2 - 161 > 0xC6 )
{
LODWORD(v5) = a2 - 711;
if ( a2 - 711 > 0x18A )
{
LODWORD(v5) = a2 - 8213;
if ( a2 - 8213 > 0x2FD )
{
LODWORD(v5) = a2 - 9312;
if ( a2 - 9312 > 0x20D )
{
LODWORD(v5) = a2 - 12288;
if ( a2 - 12288 > 0x27F )
{
LODWORD(v5) = a2 - 13184;
if ( a2 - 13184 > 0x5D )
{
LODWORD(v5) = a2 - 19968;
if ( a2 - 19968 > 0x467F )
{
LODWORD(v5) = a2 - 38263;
if ( a2 - 38263 > 0xA25 )
{
LODWORD(v5) = a2 - 44032;
if ( a2 - 44032 > 0x2BA3 )
{
LODWORD(v5) = a2 - 63744;
if ( a2 - 63744 > 0x10B )
{
LODWORD(v5) = a2 - 65281;
if ( a2 - 65281 > 0xE5 )
return 0LL;
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc560110;
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56019;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56018;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56017;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56016;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56015;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56014;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56013;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56012;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56011;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56010;
}
v7 = v6[v5];
if ( v7 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
*a3 = __ROL2__(v7, 8);
return 2LL;
}
}
else
{
return 0LL;
}
}
else
{
*(_BYTE *)a3 = a2;
return 1LL;
}
}
return result;
}
|
my_wc_mb_euc_kr:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001c5a9e
CMP ESI,0x7f
JA 0x001c5a9f
MOV byte ptr [RDX],SIL
MOV EAX,0x1
LAB_001c5a9e:
RET
LAB_001c5a9f:
LEA EAX,[RSI + -0xa1]
CMP EAX,0xc6
JA 0x001c5aba
MOV EAX,EAX
LEA RSI,[0x29e330]
JMP 0x001c5bb2
LAB_001c5aba:
LEA EAX,[RSI + -0x2c7]
CMP EAX,0x18a
JA 0x001c5ad5
MOV EAX,EAX
LEA RSI,[0x29e4c0]
JMP 0x001c5bb2
LAB_001c5ad5:
LEA EAX,[RSI + -0x2015]
CMP EAX,0x2fd
JA 0x001c5af0
MOV EAX,EAX
LEA RSI,[0x29e7e0]
JMP 0x001c5bb2
LAB_001c5af0:
LEA EAX,[RSI + -0x2460]
CMP EAX,0x20d
JA 0x001c5b0b
MOV EAX,EAX
LEA RSI,[0x29ede0]
JMP 0x001c5bb2
LAB_001c5b0b:
LEA EAX,[RSI + -0x3000]
CMP EAX,0x27f
JA 0x001c5b26
MOV EAX,EAX
LEA RSI,[0x29f200]
JMP 0x001c5bb2
LAB_001c5b26:
LEA EAX,[RSI + -0x3380]
CMP EAX,0x5d
JA 0x001c5b3c
MOV EAX,EAX
LEA RSI,[0x29f700]
JMP 0x001c5bb2
LAB_001c5b3c:
LEA EAX,[RSI + -0x4e00]
CMP EAX,0x467f
JA 0x001c5b54
MOV EAX,EAX
LEA RSI,[0x29f7c0]
JMP 0x001c5bb2
LAB_001c5b54:
LEA EAX,[RSI + -0x9577]
CMP EAX,0xa25
JA 0x001c5b6c
MOV EAX,EAX
LEA RSI,[0x2a84c0]
JMP 0x001c5bb2
LAB_001c5b6c:
LEA EAX,[RSI + -0xac00]
CMP EAX,0x2ba3
JA 0x001c5b84
MOV EAX,EAX
LEA RSI,[0x2a9910]
JMP 0x001c5bb2
LAB_001c5b84:
LEA EAX,[RSI + -0xf900]
CMP EAX,0x10b
JA 0x001c5b9c
MOV EAX,EAX
LEA RSI,[0x2af060]
JMP 0x001c5bb2
LAB_001c5b9c:
LEA EAX,[RSI + -0xff01]
CMP EAX,0xe5
JA 0x001c5be2
MOV EAX,EAX
LEA RSI,[0x2af280]
LAB_001c5bb2:
LEA RAX,[RSI + RAX*0x2]
PUSH RBP
MOV RBP,RSP
MOVZX ESI,word ptr [RAX]
TEST SI,SI
JZ 0x001c5bde
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001c5be0
ROL SI,0x8
MOV word ptr [RDX],SI
MOV EAX,0x2
JMP 0x001c5be0
LAB_001c5bde:
XOR EAX,EAX
LAB_001c5be0:
POP RBP
RET
LAB_001c5be2:
XOR EAX,EAX
RET
|
int8 my_wc_mb_euc_kr(int8 param_1,uint param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
int8 uVar2;
ulong uVar3;
int1 *puVar4;
uVar2 = 0xffffff9b;
if (param_3 < param_4) {
if (0x7f < param_2) {
if (param_2 - 0xa1 < 199) {
uVar3 = (ulong)(param_2 - 0xa1);
puVar4 = tab_uni_ksc56010;
}
else if (param_2 - 0x2c7 < 0x18b) {
uVar3 = (ulong)(param_2 - 0x2c7);
puVar4 = tab_uni_ksc56011;
}
else if (param_2 - 0x2015 < 0x2fe) {
uVar3 = (ulong)(param_2 - 0x2015);
puVar4 = tab_uni_ksc56012;
}
else if (param_2 - 0x2460 < 0x20e) {
uVar3 = (ulong)(param_2 - 0x2460);
puVar4 = tab_uni_ksc56013;
}
else if (param_2 - 0x3000 < 0x280) {
uVar3 = (ulong)(param_2 - 0x3000);
puVar4 = tab_uni_ksc56014;
}
else if (param_2 - 0x3380 < 0x5e) {
uVar3 = (ulong)(param_2 - 0x3380);
puVar4 = tab_uni_ksc56015;
}
else if (param_2 - 0x4e00 < 0x4680) {
uVar3 = (ulong)(param_2 - 0x4e00);
puVar4 = tab_uni_ksc56016;
}
else if (param_2 - 0x9577 < 0xa26) {
uVar3 = (ulong)(param_2 - 0x9577);
puVar4 = tab_uni_ksc56017;
}
else if (param_2 - 0xac00 < 0x2ba4) {
uVar3 = (ulong)(param_2 - 0xac00);
puVar4 = tab_uni_ksc56018;
}
else if (param_2 - 0xf900 < 0x10c) {
uVar3 = (ulong)(param_2 - 0xf900);
puVar4 = tab_uni_ksc56019;
}
else {
uVar3 = (ulong)(param_2 - 0xff01);
if (0xe5 < param_2 - 0xff01) {
return 0;
}
puVar4 = tab_uni_ksc560110;
}
uVar1 = *(ushort *)(puVar4 + uVar3 * 2);
if (uVar1 == 0) {
uVar2 = 0;
}
else {
uVar2 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
*param_3 = uVar1 << 8 | uVar1 >> 8;
uVar2 = 2;
}
}
return uVar2;
}
*(char *)param_3 = (char)param_2;
uVar2 = 1;
}
return uVar2;
}
|
|
66,443 |
nglog::LogDestination::LogToSinks(nglog::LogSeverity, char const*, char const*, int, nglog::LogMessageTime const&, char const*, unsigned long)
|
ng-log[P]ng-log/src/logging.cc
|
inline void LogDestination::LogToSinks(LogSeverity severity,
const char* full_filename,
const char* base_filename, int line,
const LogMessageTime& time,
const char* message,
size_t message_len) {
std::shared_lock<SinkMutex> l{sink_mutex_};
if (sinks_) {
for (size_t i = sinks_->size(); i-- > 0;) {
(*sinks_)[i]->send(severity, full_filename, base_filename, line, time,
message, message_len);
}
}
}
|
O2
|
cpp
|
nglog::LogDestination::LogToSinks(nglog::LogSeverity, char const*, char const*, int, nglog::LogMessageTime const&, char const*, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, (%rsp)
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %r13d
leaq 0x20cb3(%rip), %rdi # 0x2ebb8
movq %rdi, 0x8(%rsp)
movb $0x1, 0x10(%rsp)
callq 0xf02c
movq 0x20c95(%rip), %rax # 0x2ebb0
testq %rax, %rax
je 0xdf63
movq 0x8(%rax), %rbx
subq (%rax), %rbx
sarq $0x3, %rbx
subq $0x1, %rbx
jb 0xdf63
movq 0x20c78(%rip), %rax # 0x2ebb0
movq (%rax), %rax
movq (%rax,%rbx,8), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl %r13d, %esi
movq %r12, %rdx
movq %r15, %rcx
movl %ebp, %r8d
movq %r14, %r9
pushq 0x50(%rsp)
pushq 0x8(%rsp)
callq *%rax
popq %rax
popq %rcx
jmp 0xdf2b
leaq 0x8(%rsp), %rdi
callq 0xf01c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf01c
movq %rbx, %rdi
callq 0x7a00
nop
|
_ZN5nglog14LogDestination10LogToSinksENS_11LogSeverityEPKcS3_iRKNS_14LogMessageTimeES3_m:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], r9
mov r14, r8
mov ebp, ecx
mov r15, rdx
mov r12, rsi
mov r13d, edi
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; this
mov [rsp+48h+var_40], rdi
mov [rsp+48h+var_38], 1
call _ZNSt22__shared_mutex_pthread11lock_sharedEv; std::__shared_mutex_pthread::lock_shared(void)
mov rax, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
test rax, rax
jz short loc_DF63
mov rbx, [rax+8]
sub rbx, [rax]
sar rbx, 3
loc_DF2B:
sub rbx, 1
jb short loc_DF63
mov rax, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
mov rax, [rax]
mov rdi, [rax+rbx*8]
mov rax, [rdi]
mov rax, [rax+10h]
mov esi, r13d
mov rdx, r12
mov rcx, r15
mov r8d, ebp
mov r9, r14
push [rsp+48h+arg_0]
push [rsp+50h+var_48]
call rax
pop rax
pop rcx
jmp short loc_DF2B
loc_DF63:
lea rdi, [rsp+48h+var_40]
call _ZNSt11shared_lockISt12shared_mutexED2Ev; std::shared_lock<std::shared_mutex>::~shared_lock()
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZNSt11shared_lockISt12shared_mutexED2Ev; std::shared_lock<std::shared_mutex>::~shared_lock()
mov rdi, rbx
call __Unwind_Resume
|
long long nglog::LogDestination::LogToSinks(
unsigned int a1,
long long a2,
long long a3,
unsigned int a4,
long long a5,
long long a6,
long long a7)
{
long long v10; // r12
long long i; // rbx
void *v15; // [rsp+8h] [rbp-40h] BYREF
char v16; // [rsp+10h] [rbp-38h]
v10 = a2;
v15 = &nglog::LogDestination::sink_mutex_;
v16 = 1;
std::__shared_mutex_pthread::lock_shared((std::__shared_mutex_pthread *)&nglog::LogDestination::sink_mutex_);
if ( nglog::LogDestination::sinks_ )
{
for ( i = (long long)(*(_QWORD *)(nglog::LogDestination::sinks_ + 8) - *(_QWORD *)nglog::LogDestination::sinks_) >> 3;
i-- != 0;
(*(void ( **)(_QWORD, _QWORD, long long, long long, _QWORD, long long, long long, long long))(**(_QWORD **)(*(_QWORD *)nglog::LogDestination::sinks_ + 8 * i) + 16LL))(
*(_QWORD *)(*(_QWORD *)nglog::LogDestination::sinks_ + 8 * i),
a1,
v10,
a3,
a4,
a5,
a6,
a7) )
{
a2 = a1;
}
}
return std::shared_lock<std::shared_mutex>::~shared_lock(&v15, a2);
}
|
LogToSinks:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],R9
MOV R14,R8
MOV EBP,ECX
MOV R15,RDX
MOV R12,RSI
MOV R13D,EDI
LEA RDI,[0x12ebb8]
MOV qword ptr [RSP + 0x8],RDI
MOV byte ptr [RSP + 0x10],0x1
CALL 0x0010f02c
MOV RAX,qword ptr [0x0012ebb0]
TEST RAX,RAX
JZ 0x0010df63
MOV RBX,qword ptr [RAX + 0x8]
SUB RBX,qword ptr [RAX]
SAR RBX,0x3
LAB_0010df2b:
SUB RBX,0x1
JC 0x0010df63
MOV RAX,qword ptr [0x0012ebb0]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + RBX*0x8]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x10]
LAB_0010df46:
MOV ESI,R13D
MOV RDX,R12
MOV RCX,R15
MOV R8D,EBP
MOV R9,R14
PUSH qword ptr [RSP + 0x50]
PUSH qword ptr [RSP + 0x8]
CALL RAX
POP RAX
POP RCX
LAB_0010df61:
JMP 0x0010df2b
LAB_0010df63:
LEA RDI,[RSP + 0x8]
CALL 0x0010f01c
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nglog::LogDestination::LogToSinks(nglog::LogSeverity, char const*, char const*, int,
nglog::LogMessageTime const&, char const*, unsigned long) */
void nglog::LogDestination::LogToSinks
(int4 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 param_5,int8 param_6,int8 param_7)
{
long *plVar1;
long lVar2;
bool bVar3;
int1 *local_40;
int1 local_38;
local_40 = sink_mutex_;
local_38 = 1;
std::__shared_mutex_pthread::lock_shared((__shared_mutex_pthread *)sink_mutex_);
if (sinks_ != (long *)0x0) {
lVar2 = sinks_[1] - *sinks_ >> 3;
while (bVar3 = lVar2 != 0, lVar2 = lVar2 + -1, bVar3) {
plVar1 = *(long **)(*sinks_ + lVar2 * 8);
/* try { // try from 0010df46 to 0010df60 has its CatchHandler @ 0010df7c */
(**(code **)(*plVar1 + 0x10))(plVar1,param_1,param_2,param_3,param_4,param_5,param_6,param_7);
}
}
std::shared_lock<std::shared_mutex>::~shared_lock((shared_lock<std::shared_mutex> *)&local_40);
return;
}
|
|
66,444 |
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-internal-inl.h
|
void OnTestEnd(const TestInfo& test_info) override {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) + "&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
}
|
O0
|
c
|
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&):
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, (%rsp)
movq 0xe8(%rsp), %rdi
callq 0x458e0
movq %rax, %rdi
callq 0x4c4d0
movq (%rsp), %rsi
movzbl %al, %edx
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5d2f0
movq 0x8(%rsp), %rdx
leaq 0x19e71(%rip), %rsi # 0x7643b
leaq 0x68(%rsp), %rdi
callq 0x45b10
jmp 0x5c5d6
leaq 0x19e74(%rip), %rdx # 0x76451
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x45200
jmp 0x5c5f1
movq 0xe8(%rsp), %rdi
callq 0x458e0
movq %rax, %rdi
callq 0x4c5a0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4c510
jmp 0x5c61c
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x45250
jmp 0x5c638
leaq 0x19e21(%rip), %rdx # 0x76460
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x45200
jmp 0x5c656
movq (%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x5d0f0
jmp 0x5c669
leaq 0xc8(%rsp), %rdi
callq 0xec60
leaq 0xa8(%rsp), %rdi
callq 0xec60
leaq 0x18(%rsp), %rdi
callq 0xec60
leaq 0x88(%rsp), %rdi
callq 0xec60
leaq 0x68(%rsp), %rdi
callq 0xec60
leaq 0x48(%rsp), %rdi
callq 0xec60
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x5c752
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x5c748
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x5c73b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x5c731
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x5c724
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0xec60
leaq 0xa8(%rsp), %rdi
callq 0xec60
leaq 0x18(%rsp), %rdi
callq 0xec60
leaq 0x88(%rsp), %rdi
callq 0xec60
leaq 0x68(%rsp), %rdi
callq 0xec60
leaq 0x48(%rsp), %rdi
callq 0xec60
movq 0x40(%rsp), %rdi
callq 0xb910
nopw %cs:(%rax,%rax)
|
_ZN7testing8internal17StreamingListener9OnTestEndERKNS_8TestInfoE:
sub rsp, 0F8h
mov [rsp+0F8h+var_8], rdi
mov [rsp+0F8h+var_10], rsi
mov rax, [rsp+0F8h+var_8]
mov [rsp+0F8h+var_F8], rax
mov rdi, [rsp+0F8h+var_10]; this
call _ZNK7testing8TestInfo6resultEv; testing::TestInfo::result(void)
mov rdi, rax; this
call _ZNK7testing10TestResult6PassedEv; testing::TestResult::Passed(void)
mov rsi, [rsp+0F8h+var_F8]
movzx edx, al
lea rdi, [rsp+0F8h+var_B0]
mov [rsp+0F8h+var_F0], rdi
call _ZN7testing8internal17StreamingListener10FormatBoolB5cxx11Eb; testing::internal::StreamingListener::FormatBool(bool)
mov rdx, [rsp+0F8h+var_F0]
lea rsi, aEventTestendPa; "event=TestEnd&passed="
lea rdi, [rsp+0F8h+var_90]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_5C5D6:
lea rdx, aElapsedTime; "&elapsed_time="
lea rdi, [rsp+0F8h+var_70]
lea rsi, [rsp+0F8h+var_90]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_5C5F1:
mov rdi, [rsp+0F8h+var_10]; this
call _ZNK7testing8TestInfo6resultEv; testing::TestInfo::result(void)
mov rdi, rax; this
call _ZNK7testing10TestResult12elapsed_timeEv; testing::TestResult::elapsed_time(void)
mov [rsp+0F8h+var_E8], rax
lea rdi, [rsp+0F8h+var_E0]
lea rsi, [rsp+0F8h+var_E8]
call _ZN7testing8internal18StreamableToStringIlEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::internal::StreamableToString<long>(long const&)
jmp short $+2
loc_5C61C:
lea rdi, [rsp+0F8h+var_50]
lea rsi, [rsp+0F8h+var_70]
lea rdx, [rsp+0F8h+var_E0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
jmp short $+2
loc_5C638:
lea rdx, aMs; "ms"
lea rdi, [rsp+0F8h+var_30]
lea rsi, [rsp+0F8h+var_50]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_5C656:
mov rdi, [rsp+0F8h+var_F8]
lea rsi, [rsp+0F8h+var_30]
call _ZN7testing8internal17StreamingListener6SendLnERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::StreamingListener::SendLn(std::string const&)
jmp short $+2
loc_5C669:
lea rdi, [rsp+0F8h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0F8h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0F8h+var_E0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0F8h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0F8h+var_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0F8h+var_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add rsp, 0F8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
jmp loc_5C752
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
jmp short loc_5C748
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
jmp short loc_5C73B
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
jmp short loc_5C731
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
jmp short loc_5C724
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
lea rdi, [rsp+arg_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_5C724:
lea rdi, [rsp+arg_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_5C731:
lea rdi, [rsp+arg_10]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_5C73B:
lea rdi, [rsp+arg_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_5C748:
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_5C752:
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+arg_38]
call __Unwind_Resume
|
void testing::internal::StreamingListener::OnTestEnd(
testing::internal::StreamingListener *this,
const testing::TestInfo *a2)
{
testing::TestResult *v2; // rax
unsigned __int8 v3; // al
int v4; // ecx
int v5; // r8d
int v6; // r9d
testing::TestResult *v7; // rax
long long v8; // [rsp+0h] [rbp-F8h]
long long v9; // [rsp+8h] [rbp-F0h]
long long v10; // [rsp+10h] [rbp-E8h] BYREF
_DWORD v11[6]; // [rsp+18h] [rbp-E0h] BYREF
long long v12; // [rsp+30h] [rbp-C8h]
int v13; // [rsp+38h] [rbp-C0h]
_BYTE v14[32]; // [rsp+48h] [rbp-B0h] BYREF
_BYTE v15[32]; // [rsp+68h] [rbp-90h] BYREF
_BYTE v16[32]; // [rsp+88h] [rbp-70h] BYREF
_BYTE v17[32]; // [rsp+A8h] [rbp-50h] BYREF
_BYTE v18[32]; // [rsp+C8h] [rbp-30h] BYREF
testing::TestInfo *v19; // [rsp+E8h] [rbp-10h]
testing::internal::StreamingListener *v20; // [rsp+F0h] [rbp-8h]
v20 = this;
v19 = a2;
v2 = (testing::TestResult *)testing::TestInfo::result(a2);
v3 = testing::TestResult::Passed(v2);
testing::internal::StreamingListener::FormatBool[abi:cxx11](
(unsigned int)v14,
(_DWORD)this,
v3,
v4,
v5,
v6,
(_DWORD)this,
(unsigned int)v14,
v10,
v11[0],
v11[2],
v11[4],
v12,
v13);
std::operator+<char>((long long)v15, (long long)"event=TestEnd&passed=", v9);
std::operator+<char>((long long)v16, (long long)v15, "&elapsed_time=");
v7 = (testing::TestResult *)testing::TestInfo::result(v19);
v10 = testing::TestResult::elapsed_time(v7);
testing::internal::StreamableToString<long>((long long)v11, (long long)&v10);
std::operator+<char>((long long)v17, (long long)v16, (long long)v11);
std::operator+<char>((long long)v18, (long long)v17, "ms");
testing::internal::StreamingListener::SendLn(v8, v18);
std::string::~string(v18);
std::string::~string(v17);
std::string::~string(v11);
std::string::~string(v16);
std::string::~string(v15);
std::string::~string(v14);
}
|
OnTestEnd:
SUB RSP,0xf8
MOV qword ptr [RSP + 0xf0],RDI
MOV qword ptr [RSP + 0xe8],RSI
MOV RAX,qword ptr [RSP + 0xf0]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x001458e0
MOV RDI,RAX
CALL 0x0014c4d0
MOV RSI,qword ptr [RSP]
MOVZX EDX,AL
LEA RDI,[RSP + 0x48]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0015d2f0
MOV RDX,qword ptr [RSP + 0x8]
LAB_0015c5c3:
LEA RSI,[0x17643b]
LEA RDI,[RSP + 0x68]
CALL 0x00145b10
JMP 0x0015c5d6
LAB_0015c5d6:
LEA RDX,[0x176451]
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x68]
CALL 0x00145200
JMP 0x0015c5f1
LAB_0015c5f1:
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x001458e0
MOV RDI,RAX
CALL 0x0014c5a0
MOV qword ptr [RSP + 0x10],RAX
LAB_0015c60b:
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x10]
CALL 0x0014c510
JMP 0x0015c61c
LAB_0015c61c:
LEA RDI,[RSP + 0xa8]
LEA RSI,[RSP + 0x88]
LEA RDX,[RSP + 0x18]
CALL 0x00145250
JMP 0x0015c638
LAB_0015c638:
LEA RDX,[0x176460]
LEA RDI,[RSP + 0xc8]
LEA RSI,[RSP + 0xa8]
CALL 0x00145200
JMP 0x0015c656
LAB_0015c656:
MOV RDI,qword ptr [RSP]
LEA RSI,[RSP + 0xc8]
CALL 0x0015d0f0
LAB_0015c667:
JMP 0x0015c669
LAB_0015c669:
LEA RDI,[RSP + 0xc8]
CALL 0x0010ec60
LEA RDI,[RSP + 0xa8]
CALL 0x0010ec60
LEA RDI,[RSP + 0x18]
CALL 0x0010ec60
LEA RDI,[RSP + 0x88]
CALL 0x0010ec60
LEA RDI,[RSP + 0x68]
CALL 0x0010ec60
LEA RDI,[RSP + 0x48]
CALL 0x0010ec60
ADD RSP,0xf8
RET
|
/* testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&) */
void __thiscall
testing::internal::StreamingListener::OnTestEnd(StreamingListener *this,TestInfo *param_1)
{
TestResult *pTVar1;
long local_e8;
internal local_e0 [48];
string local_b0 [32];
string local_90 [32];
string local_70 [32];
string local_50 [32];
string local_30 [32];
TestInfo *local_10;
StreamingListener *local_8;
local_10 = param_1;
local_8 = this;
pTVar1 = (TestResult *)TestInfo::result(param_1);
TestResult::Passed(pTVar1);
FormatBool_abi_cxx11_(SUB81(local_b0,0));
/* try { // try from 0015c5c3 to 0015c5d3 has its CatchHandler @ 0015c6b6 */
std::operator+((char *)local_90,(string *)"event=TestEnd&passed=");
/* try { // try from 0015c5d6 to 0015c5ee has its CatchHandler @ 0015c6c9 */
std::operator+(local_70,(char *)local_90);
pTVar1 = (TestResult *)TestInfo::result(local_10);
local_e8 = TestResult::elapsed_time(pTVar1);
/* try { // try from 0015c60b to 0015c619 has its CatchHandler @ 0015c6d9 */
StreamableToString<long>(local_e0,&local_e8);
/* try { // try from 0015c61c to 0015c635 has its CatchHandler @ 0015c6e9 */
std::operator+(local_50,local_70);
/* try { // try from 0015c638 to 0015c653 has its CatchHandler @ 0015c6f9 */
std::operator+(local_30,(char *)local_50);
/* try { // try from 0015c656 to 0015c666 has its CatchHandler @ 0015c709 */
SendLn(this,local_30);
std::__cxx11::string::~string(local_30);
std::__cxx11::string::~string(local_50);
std::__cxx11::string::~string((string *)local_e0);
std::__cxx11::string::~string(local_70);
std::__cxx11::string::~string(local_90);
std::__cxx11::string::~string(local_b0);
return;
}
|
|
66,445 |
get_rdlock
|
eloqsql/storage/maria/ma_pagecache.c
|
static my_bool get_rdlock(PAGECACHE *pagecache,
PAGECACHE_BLOCK_LINK *block)
{
PAGECACHE_FILE file= block->hash_link->file;
pgcache_page_no_t pageno= block->hash_link->pageno;
pthread_t locker= pthread_self();
DBUG_ENTER("get_rdlock");
DBUG_PRINT("info", ("the block %p "
"files %d(%d) pages %lu(%lu)",
block, file.file, block->hash_link->file.file,
(ulong) pageno, (ulong) block->hash_link->pageno));
PCBLOCK_INFO(block);
while (block->wlocks && !pthread_equal(block->write_locker, locker))
{
/* Lock failed we will wait */
if (pagecache_wait_lock(pagecache, block, file, pageno,
MY_PTHREAD_LOCK_READ))
DBUG_RETURN(1);
}
/* we are doing it by global cache mutex protection, so it is OK */
if (block->wlocks)
{
DBUG_ASSERT(pthread_equal(block->write_locker, locker));
block->rlocks_queue++;
DBUG_PRINT("info", ("RD lock put into queue, block %p", block));
}
else
{
block->rlocks++;
DBUG_PRINT("info", ("RD lock set, block %p", block));
}
DBUG_RETURN(0);
}
|
O0
|
c
|
get_rdlock:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x18, %rsi
leaq -0x60(%rbp), %rdi
movl $0x48, %edx
callq 0x2a0b0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x60(%rax), %rax
movq %rax, -0x68(%rbp)
callq 0x2a5c0
movq %rax, -0x70(%rbp)
jmp 0x429e8
jmp 0x429ea
jmp 0x429ec
jmp 0x429ee
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x68(%rcx)
movb %al, -0x71(%rbp)
je 0x42a19
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x70(%rbp), %rsi
callq 0x2a9e0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x42a22
jmp 0x42a72
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x68(%rbp), %rdx
xorl %eax, %eax
movq -0x20(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x40(%rax)
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups -0x40(%rbp), %xmm2
movups -0x30(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
xorl %ecx, %ecx
callq 0x42ac0
cmpb $0x0, %al
je 0x42a6d
jmp 0x42a67
movb $0x1, -0x1(%rbp)
jmp 0x42aa8
jmp 0x429ee
movq -0x18(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0x42a91
jmp 0x42a7e
jmp 0x42a80
movq -0x18(%rbp), %rax
movl 0x70(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x70(%rax)
jmp 0x42a8f
jmp 0x42aa2
movq -0x18(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
jmp 0x42aa0
jmp 0x42aa2
jmp 0x42aa4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
get_rdlock:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
mov rsi, [rax+20h]
add rsi, 18h
lea rdi, [rbp+var_60]
mov edx, 48h ; 'H'
call _memcpy
mov rax, [rbp+var_18]
mov rax, [rax+20h]
mov rax, [rax+60h]
mov [rbp+var_68], rax
call _pthread_self
mov [rbp+var_70], rax
jmp short $+2
loc_429E8:
jmp short $+2
loc_429EA:
jmp short $+2
loc_429EC:
jmp short $+2
loc_429EE:
mov rcx, [rbp+var_18]
xor eax, eax
cmp dword ptr [rcx+68h], 0
mov [rbp+var_71], al
jz short loc_42A19
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
mov rsi, [rbp+var_70]
call _pthread_equal
cmp eax, 0
setnz al
xor al, 0FFh
mov [rbp+var_71], al
loc_42A19:
mov al, [rbp+var_71]
test al, 1
jnz short loc_42A22
jmp short loc_42A72
loc_42A22:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_68]
xor eax, eax
mov rcx, [rbp+var_20]
mov rax, rsp
mov [rax+40h], rcx
movups xmm0, [rbp+var_60]
movups xmm1, [rbp+var_50]
movups xmm2, [rbp+var_40]
movups xmm3, [rbp+var_30]
movups xmmword ptr [rax+30h], xmm3
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
xor ecx, ecx
call pagecache_wait_lock
cmp al, 0
jz short loc_42A6D
jmp short $+2
loc_42A67:
mov [rbp+var_1], 1
jmp short loc_42AA8
loc_42A6D:
jmp loc_429EE
loc_42A72:
mov rax, [rbp+var_18]
cmp dword ptr [rax+68h], 0
jz short loc_42A91
jmp short $+2
loc_42A7E:
jmp short $+2
loc_42A80:
mov rax, [rbp+var_18]
mov ecx, [rax+70h]
add ecx, 1
mov [rax+70h], ecx
jmp short $+2
loc_42A8F:
jmp short loc_42AA2
loc_42A91:
mov rax, [rbp+var_18]
mov ecx, [rax+6Ch]
add ecx, 1
mov [rax+6Ch], ecx
jmp short $+2
loc_42AA0:
jmp short $+2
loc_42AA2:
jmp short $+2
loc_42AA4:
mov [rbp+var_1], 0
loc_42AA8:
mov al, [rbp+var_1]
add rsp, 0C0h
pop rbp
retn
|
char get_rdlock(long long a1, long long a2)
{
int v2; // r8d
int v3; // r9d
char v5; // [rsp+4Fh] [rbp-71h]
long long v6; // [rsp+50h] [rbp-70h]
long long v7; // [rsp+58h] [rbp-68h]
_OWORD v8[4]; // [rsp+60h] [rbp-60h] BYREF
long long v9; // [rsp+A0h] [rbp-20h]
long long v10; // [rsp+A8h] [rbp-18h]
long long v11; // [rsp+B0h] [rbp-10h]
v11 = a1;
v10 = a2;
memcpy(v8, *(_QWORD *)(a2 + 32) + 24LL, 72LL);
v7 = *(_QWORD *)(*(_QWORD *)(v10 + 32) + 96LL);
v6 = pthread_self();
while ( 1 )
{
v5 = 0;
if ( *(_DWORD *)(v10 + 104) )
v5 = ~((unsigned int)pthread_equal(*(_QWORD *)(v10 + 56), v6) != 0);
if ( (v5 & 1) == 0 )
break;
if ( (unsigned __int8)pagecache_wait_lock(v11, v10, v7, 0, v2, v3, v8[0], v8[1], v8[2], v8[3], v9) )
return 1;
}
if ( *(_DWORD *)(v10 + 104) )
++*(_DWORD *)(v10 + 112);
else
++*(_DWORD *)(v10 + 108);
return 0;
}
|
get_rdlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x20]
ADD RSI,0x18
LEA RDI,[RBP + -0x60]
MOV EDX,0x48
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RBP + -0x68],RAX
CALL 0x0012a5c0
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001429e8
LAB_001429e8:
JMP 0x001429ea
LAB_001429ea:
JMP 0x001429ec
LAB_001429ec:
JMP 0x001429ee
LAB_001429ee:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP dword ptr [RCX + 0x68],0x0
MOV byte ptr [RBP + -0x71],AL
JZ 0x00142a19
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
MOV RSI,qword ptr [RBP + -0x70]
CALL 0x0012a9e0
CMP EAX,0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x71],AL
LAB_00142a19:
MOV AL,byte ptr [RBP + -0x71]
TEST AL,0x1
JNZ 0x00142a22
JMP 0x00142a72
LAB_00142a22:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x68]
XOR EAX,EAX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,RSP
MOV qword ptr [RAX + 0x40],RCX
MOVUPS XMM0,xmmword ptr [RBP + -0x60]
MOVUPS XMM1,xmmword ptr [RBP + -0x50]
MOVUPS XMM2,xmmword ptr [RBP + -0x40]
MOVUPS XMM3,xmmword ptr [RBP + -0x30]
MOVUPS xmmword ptr [RAX + 0x30],XMM3
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
XOR ECX,ECX
CALL 0x00142ac0
CMP AL,0x0
JZ 0x00142a6d
JMP 0x00142a67
LAB_00142a67:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00142aa8
LAB_00142a6d:
JMP 0x001429ee
LAB_00142a72:
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x68],0x0
JZ 0x00142a91
JMP 0x00142a7e
LAB_00142a7e:
JMP 0x00142a80
LAB_00142a80:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x70]
ADD ECX,0x1
MOV dword ptr [RAX + 0x70],ECX
JMP 0x00142a8f
LAB_00142a8f:
JMP 0x00142aa2
LAB_00142a91:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x6c]
ADD ECX,0x1
MOV dword ptr [RAX + 0x6c],ECX
JMP 0x00142aa0
LAB_00142aa0:
JMP 0x00142aa2
LAB_00142aa2:
JMP 0x00142aa4
LAB_00142aa4:
MOV byte ptr [RBP + -0x1],0x0
LAB_00142aa8:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0xc0
POP RBP
RET
|
int1
get_rdlock(int8 param_1,long param_2,int8 param_3,int8 param_4,int8 param_5,
int8 param_6)
{
int8 uVar1;
char cVar2;
int iVar3;
pthread_t __thread2;
bool bVar4;
int4 local_68 [2];
int4 uStack_60;
int4 local_58;
int4 uStack_50;
int4 local_48;
int4 uStack_40;
int4 local_38;
int4 uStack_30;
int8 local_28;
long local_20;
int8 local_18;
local_20 = param_2;
local_18 = param_1;
memcpy(local_68,(void *)(*(long *)(param_2 + 0x20) + 0x18),0x48);
uVar1 = *(int8 *)(*(long *)(local_20 + 0x20) + 0x60);
__thread2 = pthread_self();
while( true ) {
bVar4 = false;
if (*(int *)(local_20 + 0x68) != 0) {
iVar3 = pthread_equal(*(pthread_t *)(local_20 + 0x38),__thread2);
bVar4 = iVar3 == 0;
}
if (!bVar4) break;
cVar2 = pagecache_wait_lock(local_18,local_20,uVar1,0,param_5,param_6,local_68[0],uStack_60,
local_58,uStack_50,local_48,uStack_40,local_38,uStack_30,local_28);
if (cVar2 != '\0') {
return 1;
}
}
if (*(int *)(local_20 + 0x68) == 0) {
*(int *)(local_20 + 0x6c) = *(int *)(local_20 + 0x6c) + 1;
}
else {
*(int *)(local_20 + 0x70) = *(int *)(local_20 + 0x70) + 1;
}
return 0;
}
|
|
66,446 |
bf_pow_generic
|
bluesky950520[P]quickjs/libbf.c
|
static int bf_pow_generic(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
{
bf_context_t *s = r->ctx;
const bf_t *y = opaque;
bf_t T_s, *T = &T_s;
limb_t prec1;
bf_init(s, T);
/* XXX: proof for the added precision */
prec1 = prec + 32;
bf_log(T, x, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
bf_mul(T, T, y, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
if (bf_is_nan(T))
bf_set_nan(r);
else
bf_exp_internal(r, T, prec1, NULL); /* no overflow/underlow test needed */
bf_delete(T);
return BF_ST_INEXACT;
}
|
O2
|
c
|
bf_pow_generic:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
andl $0x0, 0x8(%r12)
movq %rdx, %r14
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%r13), %rax
movq %rax, 0x10(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
addq $0x20, %r14
movq %r12, %rdi
movq %r14, %rdx
movl $0x7e6, %ecx # imm = 0x7E6
callq 0x78343
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl $0x7e6, %r8d # imm = 0x7E6
callq 0x74959
cmpq %r13, 0x10(%r12)
jne 0x791b8
movq %rbx, %rdi
callq 0x7317d
jmp 0x791c8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7810e
leaq 0x8(%rsp), %rdi
callq 0x7500e
pushq $0x10
popq %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
bf_pow_generic:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 30h
mov r15, rcx
mov rbx, rdi
mov rax, [rdi]
lea r12, [rsp+58h+var_50]
mov [r12], rax
and dword ptr [r12+8], 0
mov r14, rdx
mov r13, 7FFFFFFFFFFFFFFFh
lea rax, [r13+1]
mov [r12+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [r12+18h], xmm0
add r14, 20h ; ' '
mov rdi, r12
mov rdx, r14
mov ecx, 7E6h
call bf_log
mov rdi, r12
mov rsi, r12
mov rdx, r15
mov rcx, r14
mov r8d, 7E6h
call bf_mul
cmp [r12+10h], r13
jnz short loc_791B8
mov rdi, rbx
call bf_set_nan
jmp short loc_791C8
loc_791B8:
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
mov rdx, r14
call bf_exp_internal
loc_791C8:
lea rdi, [rsp+58h+var_50]
call bf_delete_0
push 10h
pop rax
add rsp, 30h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long bf_pow_generic(long long *a1, long long a2, long long a3, long long *a4)
{
long long v5; // r14
long long v7; // [rsp+8h] [rbp-50h] BYREF
int v8; // [rsp+10h] [rbp-48h]
unsigned long long v9; // [rsp+18h] [rbp-40h]
__int128 v10; // [rsp+20h] [rbp-38h]
v7 = *a1;
v8 = 0;
v9 = 0x8000000000000000LL;
v10 = 0LL;
v5 = a3 + 32;
bf_log(&v7, a2, a3 + 32, 0x7E6u);
bf_mul(&v7, &v7, a4, v5, 0x7E6u);
if ( v9 == 0x7FFFFFFFFFFFFFFFLL )
bf_set_nan((long long)a1);
else
bf_exp_internal(a1, (long long)&v7, v5);
bf_delete_0(&v7);
return 16LL;
}
|
bf_pow_generic:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV R15,RCX
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
LEA R12,[RSP + 0x8]
MOV qword ptr [R12],RAX
AND dword ptr [R12 + 0x8],0x0
MOV R14,RDX
MOV R13,0x7fffffffffffffff
LEA RAX,[R13 + 0x1]
MOV qword ptr [R12 + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12 + 0x18],XMM0
ADD R14,0x20
MOV RDI,R12
MOV RDX,R14
MOV ECX,0x7e6
CALL 0x00178343
MOV RDI,R12
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
MOV R8D,0x7e6
CALL 0x00174959
CMP qword ptr [R12 + 0x10],R13
JNZ 0x001791b8
MOV RDI,RBX
CALL 0x0017317d
JMP 0x001791c8
LAB_001791b8:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
MOV RDX,R14
CALL 0x0017810e
LAB_001791c8:
LEA RDI,[RSP + 0x8]
CALL 0x0017500e
PUSH 0x10
POP RAX
ADD RSP,0x30
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int8 bf_pow_generic(int8 *param_1,int8 param_2,long param_3,int8 param_4)
{
int8 local_50;
int4 local_48;
long local_40;
int8 local_38;
int8 uStack_30;
local_50 = *param_1;
local_48 = 0;
local_40 = -0x8000000000000000;
local_38 = 0;
uStack_30 = 0;
param_3 = param_3 + 0x20;
bf_log(&local_50,param_2,param_3,0x7e6);
bf_mul(&local_50,&local_50,param_4,param_3,0x7e6);
if (local_40 == 0x7fffffffffffffff) {
bf_set_nan(param_1);
}
else {
bf_exp_internal(param_1,&local_50,param_3);
}
bf_delete(&local_50);
return 0x10;
}
|
|
66,447 |
minja::Value::operator>(minja::Value const&) const
|
monkey531[P]llama/common/minja.hpp
|
bool operator>(const Value & other) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_number() && other.is_number()) return get<double>() > other.get<double>();
if (is_string() && other.is_string()) return get<std::string>() > other.get<std::string>();
throw std::runtime_error("Cannot compare values: " + dump() + " > " + other.dump());
}
|
O2
|
cpp
|
minja::Value::operator>(minja::Value const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x66cb2
testb %al, %al
jne 0x74177
movb 0x40(%r15), %al
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0x74113
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x2, %al
ja 0x741a7
movq %r15, %rdi
callq 0x665e4
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x665e4
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %bl
jmp 0x74167
cmpb $0x3, %al
jne 0x741a7
cmpb $0x3, 0x40(%r14)
jne 0x741a7
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x670fc
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x670fc
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x74437
movl %eax, %ebx
movq %r15, %rdi
callq 0x254d8
movq %r14, %rdi
callq 0x254d8
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x244f0
movq %rax, %rbx
leaq 0x42f6a(%rip), %rsi # 0xb70f3
movq %rax, %rdi
callq 0x24370
movq 0x8de50(%rip), %rsi # 0x101fe8
movq 0x8dda9(%rip), %rdx # 0x101f48
movq %rbx, %rdi
callq 0x251c0
pushq $0x10
popq %rdi
callq 0x244f0
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x666c8
leaq 0x43b1b(%rip), %rsi # 0xb7ce6
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x5be22
leaq 0x43b1e(%rip), %rdx # 0xb7d02
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x3c22c
leaq 0x48(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x666c8
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x2b0a3
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x250c0
xorl %ebp, %ebp
movq 0x8ddb3(%rip), %rsi # 0x101fe8
movq 0x8dd0c(%rip), %rdx # 0x101f48
movq %rbx, %rdi
callq 0x251c0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x254d8
jmp 0x74259
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x254d8
jmp 0x7426b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x254d8
jmp 0x7427d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x88(%rsp), %rdi
callq 0x254d8
jmp 0x74292
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rdi
callq 0x254d8
testb %bpl, %bpl
jne 0x742b7
jmp 0x742bf
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x254d8
jmp 0x742bf
jmp 0x742b4
movq %rax, %r14
movq %rbx, %rdi
callq 0x24780
movq %r14, %rdi
callq 0x25250
nop
|
_ZNK5minja5ValuegtERKS0_:
push rbp
push r15
push r14
push rbx
sub rsp, 0A8h
mov r14, rsi
mov r15, rdi
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jnz loc_74177
mov al, [r15+40h]
lea ecx, [rax-5]
cmp cl, 2
ja short loc_74113
mov al, [r14+40h]
add al, 0FBh
cmp al, 2
ja loc_741A7
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+0C8h+var_C8], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd xmm1, [rsp+0C8h+var_C8]
ucomisd xmm1, xmm0
setnbe bl
jmp short loc_74167
loc_74113:
cmp al, 3
jnz loc_741A7
cmp byte ptr [r14+40h], 3
jnz loc_741A7
lea rdi, [rsp+0C8h+var_C0]
mov rsi, r15
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea rdi, [rsp+0C8h+var_A0]
mov rsi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea r14, [rsp+0C8h+var_C0]
lea r15, [rsp+0C8h+var_A0]
mov rdi, r14
mov rsi, r15
call _ZStgtIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EESA_; std::operator><char>(std::string const&,std::string const&)
mov ebx, eax
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_74167:
mov eax, ebx
add rsp, 0A8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_74177:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_741A7:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0C8h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r15
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aCannotCompareV; "Cannot compare values: "
lea rdi, [rsp+0C8h+var_40]
lea rdx, [rsp+0C8h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rdx, asc_B7D02; " > "
lea rdi, [rsp+0C8h+var_A0]
lea rsi, [rsp+0C8h+var_40]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+0C8h+var_80]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rdi, [rsp+0C8h+var_C0]
lea rsi, [rsp+0C8h+var_A0]
lea rdx, [rsp+0C8h+var_80]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
mov bpl, 1
lea rsi, [rsp+0C8h+var_C0]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+0C8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_74259
mov r14, rax
mov bpl, 1
loc_74259:
lea rdi, [rsp+0C8h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7426B
mov r14, rax
mov bpl, 1
loc_7426B:
lea rdi, [rsp+0C8h+var_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7427D
mov r14, rax
mov bpl, 1
loc_7427D:
lea rdi, [rsp+0C8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_74292
mov r14, rax
mov bpl, 1
loc_74292:
lea rdi, [rsp+0C8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_742B7
jmp short loc_742BF
mov r14, rax
lea rdi, [rsp+0C8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_742BF
jmp short $+2
loc_742B4:
mov r14, rax
loc_742B7:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_742BF:
mov rdi, r14
call __Unwind_Resume
|
long long minja::Value::operator>(minja::Value *a1, minja::Value *a2)
{
unsigned int v2; // ebx
char v3; // al
std::runtime_error *exception; // rbx
void *v6; // rbx
_BYTE v7[32]; // [rsp+8h] [rbp-C0h] BYREF
_QWORD v8[4]; // [rsp+28h] [rbp-A0h] BYREF
_QWORD v9[4]; // [rsp+48h] [rbp-80h] BYREF
_BYTE v10[32]; // [rsp+68h] [rbp-60h] BYREF
_BYTE v11[64]; // [rsp+88h] [rbp-40h] BYREF
if ( minja::Value::is_null(a1) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = *((_BYTE *)a1 + 64);
if ( (unsigned __int8)(v3 - 5) > 2u )
{
if ( v3 == 3 && *((_BYTE *)a2 + 64) == 3 )
{
minja::Value::get<std::string>((long long)v7, a1);
minja::Value::get<std::string>((long long)v8, a2);
v2 = std::operator><char>(v7, v8);
std::string::~string(v8);
std::string::~string(v7);
return v2;
}
LABEL_10:
v6 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Cannot compare values: ", (long long)v10);
std::operator+<char>((long long)v8, (long long)v11, (long long)" > ");
minja::Value::dump[abi:cxx11]((long long)v9, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v7, v8, v9);
std::runtime_error::runtime_error(v6, v7);
__cxa_throw(
v6,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (unsigned __int8)(*((_BYTE *)a2 + 64) - 5) > 2u )
goto LABEL_10;
minja::Value::get<double>(a1);
minja::Value::get<double>(a2);
LOBYTE(v2) = 0;
return v2;
}
|
operator>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV R14,RSI
MOV R15,RDI
CALL 0x00166cb2
TEST AL,AL
JNZ 0x00174177
MOV AL,byte ptr [R15 + 0x40]
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x00174113
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x2
JA 0x001741a7
MOV RDI,R15
CALL 0x001665e4
MOVSD qword ptr [RSP],XMM0
MOV RDI,R14
CALL 0x001665e4
MOVSD XMM1,qword ptr [RSP]
UCOMISD XMM1,XMM0
SETA BL
JMP 0x00174167
LAB_00174113:
CMP AL,0x3
JNZ 0x001741a7
CMP byte ptr [R14 + 0x40],0x3
JNZ 0x001741a7
LEA RDI,[RSP + 0x8]
MOV RSI,R15
CALL 0x001670fc
LAB_00174133:
LEA RDI,[RSP + 0x28]
MOV RSI,R14
CALL 0x001670fc
LAB_00174140:
LEA R14,[RSP + 0x8]
LEA R15,[RSP + 0x28]
MOV RDI,R14
MOV RSI,R15
CALL 0x00174437
MOV EBX,EAX
MOV RDI,R15
CALL 0x001254d8
MOV RDI,R14
CALL 0x001254d8
LAB_00174167:
MOV EAX,EBX
ADD RSP,0xa8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00174177:
PUSH 0x10
POP RDI
CALL 0x001244f0
MOV RBX,RAX
LAB_00174182:
LEA RSI,[0x1b70f3]
MOV RDI,RAX
CALL 0x00124370
LAB_00174191:
MOV RSI,qword ptr [0x00201fe8]
MOV RDX,qword ptr [0x00201f48]
MOV RDI,RBX
CALL 0x001251c0
LAB_001741a7:
PUSH 0x10
POP RDI
CALL 0x001244f0
MOV RBX,RAX
LAB_001741b2:
LEA RDI,[RSP + 0x68]
PUSH -0x1
POP RDX
MOV RSI,R15
XOR ECX,ECX
CALL 0x001666c8
LAB_001741c4:
LEA RSI,[0x1b7ce6]
LEA RDI,[RSP + 0x88]
LEA RDX,[RSP + 0x68]
CALL 0x0015be22
LAB_001741dd:
LEA RDX,[0x1b7d02]
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x88]
CALL 0x0013c22c
LAB_001741f6:
LEA RDI,[RSP + 0x48]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x001666c8
LAB_00174208:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x28]
LEA RDX,[RSP + 0x48]
CALL 0x0012b0a3
MOV BPL,0x1
LAB_0017421f:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x001250c0
XOR EBP,EBP
MOV RSI,qword ptr [0x00201fe8]
MOV RDX,qword ptr [0x00201f48]
MOV RDI,RBX
CALL 0x001251c0
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall minja::Value::operator>(Value *this,Value *param_1)
{
char cVar1;
bool bVar2;
int7 extraout_var;
runtime_error *prVar3;
int8 unaff_RBX;
ulong uVar4;
double dVar5;
double dVar6;
string local_c0 [32];
string local_a0 [32];
int1 local_80 [32];
int1 local_60 [32];
char local_40 [32];
cVar1 = is_null(this);
if (cVar1 != '\0') {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00174182 to 00174190 has its CatchHandler @ 001742b4 */
std::runtime_error::runtime_error(prVar3,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00201fe8,PTR__runtime_error_00201f48);
}
if ((byte)((char)this[0x40] - 5U) < 3) {
if (2 < (byte)((char)param_1[0x40] - 5U)) {
LAB_001741a7:
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001741b2 to 001741c3 has its CatchHandler @ 001742b2 */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 001741c4 to 001741dc has its CatchHandler @ 0017428c */
std::operator+(local_40,(string *)"Cannot compare values: ");
/* try { // try from 001741dd to 001741f5 has its CatchHandler @ 00174277 */
std::operator+(local_a0,local_40);
/* try { // try from 001741f6 to 00174207 has its CatchHandler @ 00174265 */
dump_abi_cxx11_((int)local_80,SUB81(param_1,0));
/* try { // try from 00174208 to 0017421b has its CatchHandler @ 00174253 */
std::operator+(local_c0,local_a0);
/* try { // try from 0017421f to 00174243 has its CatchHandler @ 00174244 */
std::runtime_error::runtime_error(prVar3,local_c0);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00201fe8,PTR__runtime_error_00201f48);
}
dVar5 = get<double>(this);
dVar6 = get<double>(param_1);
uVar4 = CONCAT71((int7)((ulong)unaff_RBX >> 8),dVar6 < dVar5);
}
else {
if ((this[0x40] != (Value)0x3) || (param_1[0x40] != (Value)0x3)) goto LAB_001741a7;
get<std::__cxx11::string>();
/* try { // try from 00174133 to 0017413f has its CatchHandler @ 001742a3 */
get<std::__cxx11::string>();
bVar2 = std::operator>(local_c0,local_a0);
uVar4 = CONCAT71(extraout_var,bVar2) & 0xffffffff;
std::__cxx11::string::~string(local_a0);
std::__cxx11::string::~string(local_c0);
}
return uVar4 & 0xffffffff;
}
|
|
66,448 |
my_read_charset_file
|
eloqsql/mysys/charset.c
|
static my_bool
my_read_charset_file(MY_CHARSET_LOADER *loader,
const char *filename,
myf myflags)
{
uchar *buf;
int fd;
size_t len, tmp_len;
MY_STAT stat_info;
if (!my_stat(filename, &stat_info, MYF(myflags)) ||
((len= (uint)stat_info.st_size) > MY_MAX_ALLOWED_BUF) ||
!(buf= (uchar*) my_malloc(key_memory_charset_loader,len,myflags)))
return TRUE;
if ((fd= mysql_file_open(key_file_charset, filename, O_RDONLY, myflags)) < 0)
goto error;
tmp_len= mysql_file_read(fd, buf, len, myflags);
mysql_file_close(fd, myflags);
if (tmp_len != len)
goto error;
if (my_parse_charset_xml(loader, (char *) buf, len))
{
my_printf_error(EE_UNKNOWN_CHARSET, "Error while parsing '%s': %s\n",
MYF(0), filename, loader->error);
goto error;
}
my_free(buf);
return FALSE;
error:
my_free(buf);
return TRUE;
}
|
O0
|
c
|
my_read_charset_file:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0xd0(%rbp), %rsi
callq 0x7d040
cmpq $0x0, %rax
je 0x71286
movq -0xa0(%rbp), %rax
movl %eax, %eax
movq %rax, -0x38(%rbp)
cmpq $0x100000, %rax # imm = 0x100000
ja 0x71286
leaq 0x384f97(%rip), %rax # 0x3f6204
movl (%rax), %edi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7d1e0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x7128f
movb $0x1, -0x1(%rbp)
jmp 0x7135b
leaq 0x38460a(%rip), %rax # 0x3f58a0
movl (%rax), %edi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r9
leaq 0x5cc87(%rip), %rsi # 0xcdf2e
movl $0x223, %edx # imm = 0x223
xorl %r8d, %r8d
callq 0x71370
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jge 0x712c1
jmp 0x7134e
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x5cc57(%rip), %rdi # 0xcdf2e
movl $0x225, %esi # imm = 0x225
callq 0x71460
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq 0x5cc3b(%rip), %rdi # 0xcdf2e
movl $0x226, %esi # imm = 0x226
callq 0x715d0
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x71309
jmp 0x7134e
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xbb9f0
cmpb $0x0, %al
je 0x7133f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x16, %edi
leaq 0x5cc35(%rip), %rsi # 0xcdf67
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x77b40
jmp 0x7134e
movq -0x28(%rbp), %rdi
callq 0x7d560
movb $0x0, -0x1(%rbp)
jmp 0x7135b
movq -0x28(%rbp), %rdi
callq 0x7d560
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
my_read_charset_file:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_20]
lea rsi, [rbp+var_D0]
call my_stat
cmp rax, 0
jz short loc_71286
mov rax, [rbp+var_A0]
mov eax, eax
mov [rbp+var_38], rax
cmp rax, offset unk_100000
ja short loc_71286
lea rax, key_memory_charset_loader
mov edi, [rax]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_20]
call my_malloc
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_7128F
loc_71286:
mov [rbp+var_1], 1
jmp loc_7135B
loc_7128F:
lea rax, key_file_charset
mov edi, [rax]
mov rcx, [rbp+var_18]
mov r9, [rbp+var_20]
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 223h
xor r8d, r8d
call inline_mysql_file_open
mov [rbp+var_2C], eax
cmp eax, 0
jge short loc_712C1
jmp loc_7134E
loc_712C1:
mov edx, [rbp+var_2C]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_38]
mov r9, [rbp+var_20]
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 225h
call inline_mysql_file_read
mov [rbp+var_40], rax
mov edx, [rbp+var_2C]
mov rcx, [rbp+var_20]
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 226h
call inline_mysql_file_close
mov rax, [rbp+var_40]
cmp rax, [rbp+var_38]
jz short loc_71309
jmp short loc_7134E
loc_71309:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call my_parse_charset_xml
cmp al, 0
jz short loc_7133F
mov rcx, [rbp+var_18]
mov r8, [rbp+var_10]
mov edi, 16h
lea rsi, aErrorWhilePars; "Error while parsing '%s': %s\n"
xor eax, eax
mov edx, eax
mov al, 0
call my_printf_error
jmp short loc_7134E
loc_7133F:
mov rdi, [rbp+var_28]
call my_free
mov [rbp+var_1], 0
jmp short loc_7135B
loc_7134E:
mov rdi, [rbp+var_28]
call my_free
mov [rbp+var_1], 1
loc_7135B:
mov al, [rbp+var_1]
add rsp, 0D0h
pop rbp
retn
|
char my_read_charset_file(long long a1, long long a2, long long a3)
{
int v3; // r9d
_BYTE v5[48]; // [rsp+0h] [rbp-D0h] BYREF
long long v6; // [rsp+30h] [rbp-A0h]
long long v7; // [rsp+90h] [rbp-40h]
long long v8; // [rsp+98h] [rbp-38h]
int v9; // [rsp+A4h] [rbp-2Ch]
long long v10; // [rsp+A8h] [rbp-28h]
long long v11; // [rsp+B0h] [rbp-20h]
long long v12; // [rsp+B8h] [rbp-18h]
long long v13; // [rsp+C0h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
if ( my_stat(a2, v5, a3) )
{
v8 = (unsigned int)v6;
if ( (unsigned int)v6 <= (unsigned long long)&unk_100000 )
{
v10 = my_malloc(key_memory_charset_loader, v8, v11);
if ( v10 )
{
v9 = inline_mysql_file_open(
key_file_charset,
"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",
547LL,
v12,
0LL,
v11);
if ( v9 >= 0 )
{
v7 = inline_mysql_file_read(
"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",
549LL,
(unsigned int)v9,
v10,
v8,
v11);
inline_mysql_file_close(
"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",
550LL,
(unsigned int)v9,
v11);
if ( v7 == v8 )
{
if ( !(unsigned __int8)my_parse_charset_xml(v13, v10, v8) )
{
my_free(v10);
return 0;
}
my_printf_error(22, (unsigned int)"Error while parsing '%s': %s\n", 0, v12, v13, v3);
}
}
my_free(v10);
return 1;
}
}
}
return 1;
}
|
my_read_charset_file:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0xd0]
CALL 0x0017d040
CMP RAX,0x0
JZ 0x00171286
MOV RAX,qword ptr [RBP + -0xa0]
MOV EAX,EAX
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x100000
JA 0x00171286
LEA RAX,[0x4f6204]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0017d1e0
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x0017128f
LAB_00171286:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017135b
LAB_0017128f:
LEA RAX,[0x4f58a0]
MOV EDI,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV R9,qword ptr [RBP + -0x20]
LEA RSI,[0x1cdf2e]
MOV EDX,0x223
XOR R8D,R8D
CALL 0x00171370
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JGE 0x001712c1
JMP 0x0017134e
LAB_001712c1:
MOV EDX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x38]
MOV R9,qword ptr [RBP + -0x20]
LEA RDI,[0x1cdf2e]
MOV ESI,0x225
CALL 0x00171460
MOV qword ptr [RBP + -0x40],RAX
MOV EDX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x20]
LEA RDI,[0x1cdf2e]
MOV ESI,0x226
CALL 0x001715d0
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x00171309
JMP 0x0017134e
LAB_00171309:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x001bb9f0
CMP AL,0x0
JZ 0x0017133f
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x10]
MOV EDI,0x16
LEA RSI,[0x1cdf67]
XOR EAX,EAX
MOV EDX,EAX
MOV AL,0x0
CALL 0x00177b40
JMP 0x0017134e
LAB_0017133f:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0017d560
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0017135b
LAB_0017134e:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0017d560
MOV byte ptr [RBP + -0x1],0x1
LAB_0017135b:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0xd0
POP RBP
RET
|
int1 my_read_charset_file(int8 param_1,int8 param_2,int8 param_3)
{
char cVar1;
long lVar2;
int1 local_d8 [48];
ulong local_a8;
ulong local_48;
ulong local_40;
int local_34;
long local_30;
int8 local_28;
int8 local_20;
int8 local_18;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
lVar2 = my_stat(param_2,local_d8,param_3);
if (((lVar2 != 0) && (local_40 = local_a8 & 0xffffffff, local_40 < 0x100001)) &&
(local_30 = my_malloc(key_memory_charset_loader,local_40,local_28), local_30 != 0)) {
local_34 = inline_mysql_file_open
(key_file_charset,
"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",0x223,local_20,
0,local_28);
if (-1 < local_34) {
local_48 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",0x225,
local_34,local_30,local_40,local_28);
inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",0x226,local_34,local_28)
;
if (local_48 == local_40) {
cVar1 = my_parse_charset_xml(local_18,local_30,local_40);
if (cVar1 == '\0') {
my_free(local_30);
return 0;
}
my_printf_error(0x16,"Error while parsing \'%s\': %s\n",0,local_20,local_18);
}
}
my_free(local_30);
}
return 1;
}
|
|
66,449 |
insert_dynamic
|
eloqsql/mysys/array.c
|
my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void * element)
{
void *buffer;
if (array->elements == array->max_element)
{ /* Call only when necessary */
if (!(buffer=alloc_dynamic(array)))
return TRUE;
}
else
{
buffer=array->buffer+(array->elements * array->size_of_element);
array->elements++;
}
memcpy(buffer,element,(size_t) array->size_of_element);
return FALSE;
}
|
O3
|
c
|
insert_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ecx
cmpl 0xc(%rdi), %ecx
jne 0x919ed
movq %r14, %rdi
callq 0x91a14
testq %rax, %rax
je 0x91a10
movq %rax, %rdi
movl 0x14(%r14), %eax
jmp 0x919ff
movl 0x14(%r14), %eax
movl %eax, %edi
imull %ecx, %edi
addq (%r14), %rdi
incl %ecx
movl %ecx, 0x8(%r14)
movl %eax, %edx
movq %rbx, %rsi
callq 0x29080
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x91a0b
|
insert_dynamic:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov ecx, [rdi+8]
cmp ecx, [rdi+0Ch]
jnz short loc_919ED
mov rdi, r14
call alloc_dynamic
test rax, rax
jz short loc_91A10
mov rdi, rax
mov eax, [r14+14h]
jmp short loc_919FF
loc_919ED:
mov eax, [r14+14h]
mov edi, eax
imul edi, ecx
add rdi, [r14]
inc ecx
mov [r14+8], ecx
loc_919FF:
mov edx, eax
mov rsi, rbx
call _memcpy
xor eax, eax
loc_91A0B:
pop rbx
pop r14
pop rbp
retn
loc_91A10:
mov al, 1
jmp short loc_91A0B
|
long long insert_dynamic(long long a1, long long a2)
{
int v3; // ecx
long long v4; // rax
long long v5; // rdi
unsigned int v6; // eax
v3 = *(_DWORD *)(a1 + 8);
if ( v3 != *(_DWORD *)(a1 + 12) )
{
v6 = *(_DWORD *)(a1 + 20);
v5 = *(_QWORD *)a1 + v3 * v6;
*(_DWORD *)(a1 + 8) = v3 + 1;
goto LABEL_5;
}
v4 = alloc_dynamic(a1);
if ( v4 )
{
v5 = v4;
v6 = *(_DWORD *)(a1 + 20);
LABEL_5:
memcpy(v5, a2, v6);
return 0LL;
}
return 1LL;
}
|
insert_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ECX,dword ptr [RDI + 0x8]
CMP ECX,dword ptr [RDI + 0xc]
JNZ 0x001919ed
MOV RDI,R14
CALL 0x00191a14
TEST RAX,RAX
JZ 0x00191a10
MOV RDI,RAX
MOV EAX,dword ptr [R14 + 0x14]
JMP 0x001919ff
LAB_001919ed:
MOV EAX,dword ptr [R14 + 0x14]
MOV EDI,EAX
IMUL EDI,ECX
ADD RDI,qword ptr [R14]
INC ECX
MOV dword ptr [R14 + 0x8],ECX
LAB_001919ff:
MOV EDX,EAX
MOV RSI,RBX
CALL 0x00129080
XOR EAX,EAX
LAB_00191a0b:
POP RBX
POP R14
POP RBP
RET
LAB_00191a10:
MOV AL,0x1
JMP 0x00191a0b
|
int8 insert_dynamic(long *param_1,void *param_2)
{
int iVar1;
uint uVar2;
void *__dest;
iVar1 = (int)param_1[1];
if (iVar1 == *(int *)((long)param_1 + 0xc)) {
__dest = (void *)alloc_dynamic(param_1);
if (__dest == (void *)0x0) {
return 1;
}
uVar2 = *(uint *)((long)param_1 + 0x14);
}
else {
uVar2 = *(uint *)((long)param_1 + 0x14);
__dest = (void *)((ulong)(uVar2 * iVar1) + *param_1);
*(int *)(param_1 + 1) = iVar1 + 1;
}
memcpy(__dest,param_2,(ulong)uVar2);
return 0;
}
|
|
66,450 |
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::erase(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>*, std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>>, __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>*, std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>>)
|
monkey531[P]llama/common/json.hpp
|
iterator erase(iterator first, iterator last)
{
if (first == last)
{
return first;
}
const auto elements_affected = std::distance(first, last);
const auto offset = std::distance(Container::begin(), first);
// This is the start situation. We need to delete elements_affected
// elements (3 in this example: e, f, g), and need to return an
// iterator past the last deleted element (h in this example).
// Note that offset is the distance from the start of the vector
// to first. We will need this later.
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// first last
// Since we cannot move const Keys, we re-construct them in place.
// We start at first and re-construct (viz. copy) the elements from
// the back of the vector. Example for first iteration:
// ,--------.
// v | destroy e and re-construct with h
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// it it + elements_affected
for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
{
it->~value_type(); // destroy but keep allocation
new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
}
// [ a, b, c, d, h, i, j, h, i, j ]
// ^ ^
// first last
// remove the unneeded elements at the end of the vector
Container::resize(this->size() - static_cast<size_type>(elements_affected));
// [ a, b, c, d, h, i, j ]
// ^ ^
// first last
// first is now pointing past the last deleted element, but we cannot
// use this iterator, because it may have been invalidated by the
// resize call. Instead, we can return begin() + offset.
return Container::begin() + offset;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::erase(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>*, std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>>, __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>*, std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0x77afb
movq %rdx, %r12
movq %rdi, %r14
movq %rdx, %rbp
subq %rbx, %rbp
sarq $0x5, %rbp
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rbp
movq (%rdi), %rax
movq %rax, (%rsp)
movq %rdx, %r15
negq %r15
movq %rbx, %r13
cmpq 0x8(%r14), %r12
je 0x77ace
movq %r13, %rdi
callq 0x70c18
movq %r13, %rdi
movq %r12, %rsi
callq 0x77b0e
addq $0x60, %r13
addq $0x60, %r12
addq $-0x60, %r15
jmp 0x77aa7
subq (%rsp), %rbx
addq (%r14), %r15
negq %r15
sarq $0x5, %r15
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r15
subq %rbp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x77b9a
addq (%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE5eraseEN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEESR_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
cmp rsi, rdx
jz loc_77AFB
mov r12, rdx
mov r14, rdi
mov rbp, rdx
sub rbp, rbx
sar rbp, 5
mov rax, 0AAAAAAAAAAAAAAABh
imul rbp, rax
mov rax, [rdi]
mov [rsp+38h+var_38], rax
mov r15, rdx
neg r15
mov r13, rbx
loc_77AA7:
cmp r12, [r14+8]
jz short loc_77ACE
mov rdi, r13
call _ZNSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueEED2Ev; std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>::~pair()
mov rdi, r13
mov rsi, r12
call _ZNSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueEEC2EOSI_; std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>::pair(std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>&&)
add r13, 60h ; '`'
add r12, 60h ; '`'
add r15, 0FFFFFFFFFFFFFFA0h
jmp short loc_77AA7
loc_77ACE:
sub rbx, [rsp+38h+var_38]
add r15, [r14]
neg r15
sar r15, 5
mov rax, 0AAAAAAAAAAAAAAABh
imul r15, rax
sub r15, rbp
mov rdi, r14
mov rsi, r15
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE6resizeEm; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::resize(ulong)
add rbx, [r14]
loc_77AFB:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::erase(
long long *a1,
long long a2,
long long a3)
{
long long v3; // rbx
long long v4; // r12
unsigned long long v5; // rbp
long long v6; // r15
long long v7; // r13
long long v9; // [rsp+0h] [rbp-38h]
v3 = a2;
if ( a2 != a3 )
{
v4 = a3;
v5 = 0xAAAAAAAAAAAAAAABLL * ((a3 - a2) >> 5);
v9 = *a1;
v6 = -a3;
v7 = a2;
while ( v4 != a1[1] )
{
std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>::~pair(v7);
std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>::pair(
v7,
v4);
v7 += 96LL;
v4 += 96LL;
v6 -= 96LL;
}
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::resize(
a1,
0xAAAAAAAAAAAAAAABLL * (-(*a1 + v6) >> 5) - v5);
return *a1 + a2 - v9;
}
return v3;
}
|
erase:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
CMP RSI,RDX
JZ 0x00177afb
MOV R12,RDX
MOV R14,RDI
MOV RBP,RDX
SUB RBP,RBX
SAR RBP,0x5
MOV RAX,-0x5555555555555555
IMUL RBP,RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP],RAX
MOV R15,RDX
NEG R15
MOV R13,RBX
LAB_00177aa7:
CMP R12,qword ptr [R14 + 0x8]
JZ 0x00177ace
MOV RDI,R13
CALL 0x00170c18
MOV RDI,R13
MOV RSI,R12
CALL 0x00177b0e
ADD R13,0x60
ADD R12,0x60
ADD R15,-0x60
JMP 0x00177aa7
LAB_00177ace:
SUB RBX,qword ptr [RSP]
ADD R15,qword ptr [R14]
NEG R15
SAR R15,0x5
MOV RAX,-0x5555555555555555
IMUL R15,RAX
SUB R15,RBP
MOV RDI,R14
MOV RSI,R15
CALL 0x00177b9a
ADD RBX,qword ptr [R14]
LAB_00177afb:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, minja::Value,
std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> >
>::erase(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>*,
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> > > >,
__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>*,
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value>,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> > > >) */
pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>
* __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::erase(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*this,pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>
*param_2,
pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>
*param_3)
{
long lVar1;
long lVar2;
pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>
*this_00;
long lVar3;
if (param_2 != param_3) {
lVar2 = (long)param_3 - (long)param_2;
lVar1 = *(long *)this;
lVar3 = -(long)param_3;
this_00 = param_2;
for (; param_3 !=
*(pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>
**)(this + 8); param_3 = param_3 + 0x60) {
std::
pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>
::~pair(this_00);
std::
pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>
::pair(this_00,param_3);
this_00 = this_00 + 0x60;
lVar3 = lVar3 + -0x60;
}
std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::resize((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this,(-(lVar3 + *(long *)this) >> 5) * -0x5555555555555555 +
(lVar2 >> 5) * 0x5555555555555555);
param_2 = param_2 + (*(long *)this - lVar1);
}
return param_2;
}
|
|
66,451 |
minja::Parser::parseLogicalOr()
|
llama.cpp/common/minja/minja.hpp
|
std::shared_ptr<Expression> parseLogicalOr() {
auto left = parseLogicalAnd();
if (!left) throw std::runtime_error("Expected left side of 'logical or' expression");
static std::regex or_tok(R"(or\b)");
auto location = get_location();
while (!consumeToken(or_tok).empty()) {
auto right = parseLogicalAnd();
if (!right) throw std::runtime_error("Expected right side of 'or' expression");
left = std::make_shared<BinaryOpExpr>(location, std::move(left), std::move(right), BinaryOpExpr::Op::Or);
}
return left;
}
|
O3
|
cpp
|
minja::Parser::parseLogicalOr():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xdfa42
cmpq $0x0, (%rbx)
je 0xdf732
leaq 0x86e86(%rip), %rax # 0x166440
movb (%rax), %al
testb %al, %al
je 0xdf764
movq (%r15), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0xdf5ef
movq 0x859b7(%rip), %rcx # 0x164f98
cmpb $0x0, (%rcx)
je 0xdf5eb
incl 0x8(%rax)
jmp 0xdf5ef
lock
incl 0x8(%rax)
leaq 0x20(%rsp), %rcx
movq 0x20(%r15), %rax
subq 0x10(%r15), %rax
movq %rax, 0x8(%rcx)
leaq 0x8(%rsp), %r13
leaq 0x848f4(%rip), %rbp # 0x163f00
addq $0x10, %rbp
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
leaq 0x86e01(%rip), %rdx # 0x166420
movl $0x1, %ecx
callq 0xde356
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %r14
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xdf64a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21170
testq %r14, %r14
je 0xdf6e2
movq %r13, %rdi
movq %r15, %rsi
callq 0xdfa42
cmpq $0x0, 0x8(%rsp)
je 0xdf6fe
movl $0x58, %edi
callq 0x21200
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
movq %rbp, (%r14)
movq %r14, %r12
addq $0x10, %r12
movq %r12, %rdi
leaq 0x18(%rsp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
movl $0xf, %r8d
callq 0xeba6e
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movups (%rbx), %xmm0
movq %r12, (%rbx)
movq %r14, 0x8(%rbx)
movaps %xmm0, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6fdfa
leaq 0x58(%rsp), %rdi
callq 0x6fdfa
leaq 0x10(%rsp), %rdi
callq 0x6fdfa
jmp 0xdf610
leaq 0x20(%rsp), %rdi
callq 0x6fdfa
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x21630
movq %rax, %r15
leaq 0x43683(%rip), %rsi # 0x122d95
movq %rax, %rdi
callq 0x21400
movq 0x8589f(%rip), %rsi # 0x164fc0
movq 0x85850(%rip), %rdx # 0x164f78
movq %r15, %rdi
callq 0x21a50
jmp 0xdf764
movl $0x10, %edi
callq 0x21630
movq %rax, %r15
leaq 0x4361c(%rip), %rsi # 0x122d62
movq %rax, %rdi
callq 0x21400
movq 0x8586b(%rip), %rsi # 0x164fc0
movq 0x8581c(%rip), %rdx # 0x164f78
movq %r15, %rdi
callq 0x21a50
leaq 0x86cd5(%rip), %rdi # 0x166440
callq 0x21580
testl %eax, %eax
je 0xdf5c4
leaq 0x86ca1(%rip), %rdi # 0x166420
leaq 0x4360a(%rip), %rsi # 0x122d90
movl $0x10, %edx
callq 0x65714
leaq -0x79fd7(%rip), %rdi # 0x657c0
leaq 0x86c82(%rip), %rsi # 0x166420
leaq 0x862a3(%rip), %rdx # 0x165a48
callq 0x21ed0
leaq 0x86c8f(%rip), %rdi # 0x166440
callq 0x21960
jmp 0xdf5c4
movq %rax, %r14
leaq 0x86c7b(%rip), %rdi # 0x166440
callq 0x216b0
jmp 0xdf80b
movq %rax, %r14
jmp 0xdf80b
movq %rax, %r14
movq %r15, %rdi
callq 0x21ef0
jmp 0xdf80b
jmp 0xdf7ef
movq %rax, %r14
movq %r15, %rdi
callq 0x21ef0
jmp 0xdf7f2
jmp 0xdf7fe
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6fdfa
jmp 0xdf801
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x6fdfa
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x6fdfa
movq %r14, %rdi
callq 0x21af0
nop
|
_ZN5minja6Parser14parseLogicalOrEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r15, rsi
mov rbx, rdi
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
cmp qword ptr [rbx], 0
jz loc_DF732
lea rax, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; `guard variable for'minja::Parser::parseLogicalOr(void)::or_tok
mov al, [rax]
test al, al
jz loc_DF764
loc_DF5C4:
mov rax, [r15]
mov [rsp+98h+var_80], rax; __int64
mov rax, [r15+8]
mov [rsp+98h+var_78], rax
test rax, rax
jz short loc_DF5EF
mov rcx, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rcx], 0
jz short loc_DF5EB
inc dword ptr [rax+8]
jmp short loc_DF5EF
loc_DF5EB:
lock inc dword ptr [rax+8]
loc_DF5EF:
lea rcx, [rsp+98h+var_78]
mov rax, [r15+20h]
sub rax, [r15+10h]
mov [rcx+8], rax
lea r13, [rsp+98h+var_90]
lea rbp, _ZTVSt23_Sp_counted_ptr_inplaceIN5minja12BinaryOpExprESaIvELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<minja::BinaryOpExpr,std::allocator<void>,(__gnu_cxx::_Lock_policy)2>
add rbp, 10h
loc_DF610:
lea rdi, [rsp+98h+var_68]; int
mov rsi, r15; int
lea rdx, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; int
mov ecx, 1; int
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
mov rdi, [rsp+98h+var_68]; void *
mov r14, [rsp+98h+var_68+8]
lea rax, [rsp+98h+var_58]
cmp rdi, rax
jz short loc_DF64A
mov rsi, [rsp+98h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_DF64A:
test r14, r14
jz loc_DF6E2
mov rdi, r13; this
mov rsi, r15
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
cmp [rsp+98h+var_90], 0
jz loc_DF6FE
mov edi, 58h ; 'X'; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rax, 100000001h
mov [r14+8], rax
mov [r14], rbp
mov r12, r14
add r12, 10h
mov rdi, r12
lea rsi, [rsp+98h+var_80]
mov rdx, rbx
mov rcx, r13
mov r8d, 0Fh
call _ZN5minja12BinaryOpExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEES7_NS0_2OpE; minja::BinaryOpExpr::BinaryOpExpr(minja::Location const&,std::shared_ptr<minja::Expression> &&,std::shared_ptr<minja::Expression> &,minja::BinaryOpExpr::Op)
xorps xmm0, xmm0
movaps [rsp+98h+var_48], xmm0
movups xmm0, xmmword ptr [rbx]
mov [rbx], r12
mov [rbx+8], r14
movaps xmmword ptr [rsp+98h+var_68], xmm0
lea rdi, [rsp+98h+var_68+8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+98h+var_48+8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+98h+var_88]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp loc_DF610
loc_DF6E2:
lea rdi, [rsp+98h+var_78]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_DF6FE:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedRightS; "Expected right side of 'or' expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_DF764
loc_DF732:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedLeftSi; "Expected left side of 'logical or' expr"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_DF764:
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_DF5C4
lea rdi, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; minja::Parser::parseLogicalOr(void)::or_tok
lea rsi, aOrB; "or\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_DF5C4
mov r14, rax
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_DF80B
mov r14, rax
jmp short loc_DF80B
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_DF80B
jmp short loc_DF7EF
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_DF7F2
jmp short loc_DF7FE
loc_DF7EF:
mov r14, rax
loc_DF7F2:
lea rdi, [rsp+arg_8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_DF801
loc_DF7FE:
mov r14, rax
loc_DF801:
lea rdi, [rsp+arg_18]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_DF80B:
add rbx, 8
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseLogicalOr(minja::Parser *this, long long *a2)
{
volatile signed __int32 *v2; // rax
void *v3; // r14
_QWORD *v4; // r14
__int128 v5; // xmm0
std::runtime_error *v7; // r15
std::runtime_error *exception; // r15
long long v9; // [rsp+8h] [rbp-90h] BYREF
volatile signed __int32 *v10; // [rsp+10h] [rbp-88h] BYREF
long long v11; // [rsp+18h] [rbp-80h] BYREF
volatile signed __int32 *v12[2]; // [rsp+20h] [rbp-78h] BYREF
void *v13[2]; // [rsp+30h] [rbp-68h] BYREF
long long v14; // [rsp+40h] [rbp-58h] BYREF
__int128 v15; // [rsp+50h] [rbp-48h] BYREF
minja::Parser::parseLogicalAnd(this);
if ( !*(_QWORD *)this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'logical or' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
(long long)"or\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]);
}
v11 = *a2;
v2 = (volatile signed __int32 *)a2[1];
v12[0] = v2;
if ( v2 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v2 + 2);
else
_InterlockedIncrement(v2 + 2);
}
v12[1] = (volatile signed __int32 *)(a2[4] - a2[2]);
while ( 1 )
{
minja::Parser::consumeToken(v13, (long long)a2, (long long)&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11], 1u);
v3 = v13[1];
if ( v13[0] != &v14 )
operator delete(v13[0], v14 + 1);
if ( !v3 )
break;
minja::Parser::parseLogicalAnd((minja::Parser *)&v9);
if ( !v9 )
{
v7 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v7, "Expected right side of 'or' expression");
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4 = (_QWORD *)operator new(0x58uLL);
v4[1] = 0x100000001LL;
*v4 = &`vtable for'std::_Sp_counted_ptr_inplace<minja::BinaryOpExpr,std::allocator<void>,(__gnu_cxx::_Lock_policy)2>
+ 2;
minja::BinaryOpExpr::BinaryOpExpr(v4 + 2, &v11, this, &v9, 15LL);
v15 = 0LL;
v5 = *(_OWORD *)this;
*(_QWORD *)this = v4 + 2;
*((_QWORD *)this + 1) = v4;
*(_OWORD *)v13 = v5;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v13[1]);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v15 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v10);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v12);
return this;
}
|
parseLogicalOr:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R15,RSI
MOV RBX,RDI
CALL 0x001dfa42
CMP qword ptr [RBX],0x0
JZ 0x001df732
LEA RAX,[0x266440]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x001df764
LAB_001df5c4:
MOV RAX,qword ptr [R15]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [R15 + 0x8]
MOV qword ptr [RSP + 0x20],RAX
TEST RAX,RAX
JZ 0x001df5ef
MOV RCX,qword ptr [0x00264f98]
CMP byte ptr [RCX],0x0
JZ 0x001df5eb
INC dword ptr [RAX + 0x8]
JMP 0x001df5ef
LAB_001df5eb:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001df5ef:
LEA RCX,[RSP + 0x20]
MOV RAX,qword ptr [R15 + 0x20]
SUB RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RCX + 0x8],RAX
LEA R13,[RSP + 0x8]
LEA RBP,[0x263f00]
ADD RBP,0x10
LAB_001df610:
LEA RDI,[RSP + 0x30]
MOV RSI,R15
LEA RDX,[0x266420]
MOV ECX,0x1
CALL 0x001de356
MOV RDI,qword ptr [RSP + 0x30]
MOV R14,qword ptr [RSP + 0x38]
LEA RAX,[RSP + 0x40]
CMP RDI,RAX
JZ 0x001df64a
MOV RSI,qword ptr [RSP + 0x40]
INC RSI
CALL 0x00121170
LAB_001df64a:
TEST R14,R14
JZ 0x001df6e2
LAB_001df653:
MOV RDI,R13
MOV RSI,R15
CALL 0x001dfa42
CMP qword ptr [RSP + 0x8],0x0
JZ 0x001df6fe
LAB_001df66a:
MOV EDI,0x58
CALL 0x00121200
LAB_001df674:
MOV R14,RAX
MOV RAX,0x100000001
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [R14],RBP
MOV R12,R14
ADD R12,0x10
MOV RDI,R12
LEA RSI,[RSP + 0x18]
MOV RDX,RBX
MOV RCX,R13
MOV R8D,0xf
CALL 0x001eba6e
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVUPS XMM0,xmmword ptr [RBX]
MOV qword ptr [RBX],R12
MOV qword ptr [RBX + 0x8],R14
MOVAPS xmmword ptr [RSP + 0x30],XMM0
LEA RDI,[RSP + 0x38]
CALL 0x0016fdfa
LEA RDI,[RSP + 0x58]
CALL 0x0016fdfa
LEA RDI,[RSP + 0x10]
CALL 0x0016fdfa
JMP 0x001df610
LAB_001df6e2:
LEA RDI,[RSP + 0x20]
CALL 0x0016fdfa
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001df6fe:
MOV EDI,0x10
CALL 0x00121630
MOV R15,RAX
LAB_001df70b:
LEA RSI,[0x222d95]
MOV RDI,RAX
CALL 0x00121400
LAB_001df71a:
MOV RSI,qword ptr [0x00264fc0]
MOV RDX,qword ptr [0x00264f78]
MOV RDI,R15
CALL 0x00121a50
LAB_001df732:
MOV EDI,0x10
CALL 0x00121630
MOV R15,RAX
LAB_001df73f:
LEA RSI,[0x222d62]
MOV RDI,RAX
CALL 0x00121400
LAB_001df74e:
MOV RSI,qword ptr [0x00264fc0]
MOV RDX,qword ptr [0x00264f78]
MOV RDI,R15
CALL 0x00121a50
LAB_001df764:
LEA RDI,[0x266440]
CALL 0x00121580
TEST EAX,EAX
JZ 0x001df5c4
LAB_001df778:
LEA RDI,[0x266420]
LEA RSI,[0x222d90]
MOV EDX,0x10
CALL 0x00165714
LAB_001df790:
LEA RDI,[0x1657c0]
LEA RSI,[0x266420]
LEA RDX,[0x265a48]
CALL 0x00121ed0
LEA RDI,[0x266440]
CALL 0x00121960
JMP 0x001df5c4
|
/* minja::Parser::parseLogicalOr() */
void minja::Parser::parseLogicalOr(void)
{
long lVar1;
int iVar2;
int8 *puVar3;
runtime_error *prVar4;
int8 *in_RSI;
long *in_RDI;
long local_90;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_88 [8];
int8 local_80;
long local_78;
long local_70;
long *local_68;
long lStack_60;
long local_58 [2];
int8 local_48;
int8 auStack_40 [2];
parseLogicalAnd();
if (*in_RDI == 0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001df73f to 001df74d has its CatchHandler @ 001df7d1 */
std::runtime_error::runtime_error(prVar4,"Expected left side of \'logical or\' expression");
/* try { // try from 001df74e to 001df763 has its CatchHandler @ 001df7cc */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00264fc0,PTR__runtime_error_00264f78);
}
if (parseLogicalOr()::or_tok_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&parseLogicalOr()::or_tok_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 001df778 to 001df78f has its CatchHandler @ 001df7bb */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseLogicalOr()::or_tok_abi_cxx11_,&DAT_00222d90,0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseLogicalOr()::or_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseLogicalOr()::or_tok_abi_cxx11_);
}
}
local_80 = *in_RSI;
local_78 = in_RSI[1];
if (local_78 != 0) {
if (*PTR___libc_single_threaded_00264f98 == '\0') {
LOCK();
*(int *)(local_78 + 8) = *(int *)(local_78 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_78 + 8) = *(int *)(local_78 + 8) + 1;
}
}
local_70 = in_RSI[4] - in_RSI[2];
while( true ) {
/* try { // try from 001df610 to 001df628 has its CatchHandler @ 001df7fe */
consumeToken(&local_68);
lVar1 = lStack_60;
if (local_68 != local_58) {
operator_delete(local_68,local_58[0] + 1);
}
if (lVar1 == 0) break;
/* try { // try from 001df653 to 001df65d has its CatchHandler @ 001df7ed */
parseLogicalAnd();
if (local_90 == 0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001df70b to 001df719 has its CatchHandler @ 001df7e0 */
std::runtime_error::runtime_error(prVar4,"Expected right side of \'or\' expression");
/* try { // try from 001df71a to 001df72f has its CatchHandler @ 001df7de */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00264fc0,PTR__runtime_error_00264f78);
}
/* try { // try from 001df66a to 001df673 has its CatchHandler @ 001df7ef */
puVar3 = (int8 *)operator_new(0x58);
puVar3[1] = 0x100000001;
*puVar3 = &PTR___Sp_counted_base_00263f10;
BinaryOpExpr::BinaryOpExpr((BinaryOpExpr *)(puVar3 + 2),&local_80);
local_48 = 0;
auStack_40[0] = 0;
local_68 = (long *)*in_RDI;
lStack_60 = in_RDI[1];
*in_RDI = (long)(puVar3 + 2);
in_RDI[1] = (long)puVar3;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&lStack_60);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)auStack_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_88);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_78);
return;
}
|
|
66,452 |
my_wc_mb_utf8mb4_no_range
|
eloqsql/strings/ctype-utf8.c
|
static int
my_wc_mb_utf8mb4_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *r)
{
int count;
if (wc < 0x80)
count= 1;
else if (wc < 0x800)
count= 2;
else if (wc < 0x10000)
count= 3;
else if (wc < 0x200000)
count= 4;
else
return MY_CS_ILUNI;
switch (count)
{
case 4: r[3]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0x10000;
/* fall through */
case 3: r[2]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0x800;
/* fall through */
case 2: r[1]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0xc0;
/* fall through */
case 1: r[0]= (uchar) wc;
}
return count;
}
|
O0
|
c
|
my_wc_mb_utf8mb4_no_range:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x80, -0x18(%rbp)
jae 0xc7db3
movl $0x1, -0x24(%rbp)
jmp 0xc7dfe
cmpq $0x800, -0x18(%rbp) # imm = 0x800
jae 0xc7dc6
movl $0x2, -0x24(%rbp)
jmp 0xc7dfc
cmpq $0x10000, -0x18(%rbp) # imm = 0x10000
jae 0xc7dd9
movl $0x3, -0x24(%rbp)
jmp 0xc7dfa
cmpq $0x200000, -0x18(%rbp) # imm = 0x200000
jae 0xc7dec
movl $0x4, -0x24(%rbp)
jmp 0xc7df8
movl $0x0, -0x4(%rbp)
jmp 0xc7ecb
jmp 0xc7dfa
jmp 0xc7dfc
jmp 0xc7dfe
movl -0x24(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0xc7ec5
movq -0x30(%rbp), %rax
leaq 0x14bb53(%rip), %rcx # 0x213970
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0x10000, %rax # imm = 0x10000
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0x800, %rax # imm = 0x800
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0xc0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
|
my_wc_mb_utf8mb4_no_range:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
cmp [rbp+var_18], 80h
jnb short loc_C7DB3
mov [rbp+var_24], 1
jmp short loc_C7DFE
loc_C7DB3:
cmp [rbp+var_18], 800h
jnb short loc_C7DC6
mov [rbp+var_24], 2
jmp short loc_C7DFC
loc_C7DC6:
cmp [rbp+var_18], 10000h
jnb short loc_C7DD9
mov [rbp+var_24], 3
jmp short loc_C7DFA
loc_C7DD9:
cmp [rbp+var_18], offset off_200000
jnb short loc_C7DEC
mov [rbp+var_24], 4
jmp short loc_C7DF8
loc_C7DEC:
mov [rbp+var_4], 0
jmp loc_C7ECB
loc_C7DF8:
jmp short $+2
loc_C7DFA:
jmp short $+2
loc_C7DFC:
jmp short $+2
loc_C7DFE:
mov eax, [rbp+var_24]
dec eax; switch 4 cases
mov ecx, eax
mov [rbp+var_30], rcx
sub eax, 3
ja def_C7E24; jumptable 00000000000C7E24 default case
mov rax, [rbp+var_30]
lea rcx, jpt_C7E24
movsxd rax, ds:(jpt_C7E24 - 213970h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_C7E26:
mov rax, [rbp+var_18]; jumptable 00000000000C7E24 case 4
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+3], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 10000h
mov [rbp+var_18], rax
loc_C7E57:
mov rax, [rbp+var_18]; jumptable 00000000000C7E24 case 3
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+2], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 800h
mov [rbp+var_18], rax
loc_C7E88:
mov rax, [rbp+var_18]; jumptable 00000000000C7E24 case 2
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 0C0h
mov [rbp+var_18], rax
loc_C7EB9:
mov rax, [rbp+var_18]; jumptable 00000000000C7E24 case 1
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
def_C7E24:
mov eax, [rbp+var_24]; jumptable 00000000000C7E24 default case
mov [rbp+var_4], eax
loc_C7ECB:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_wc_mb_utf8mb4_no_range(long long a1, unsigned long long a2, _BYTE *a3)
{
unsigned int v4; // [rsp+Ch] [rbp-24h]
unsigned long long v5; // [rsp+18h] [rbp-18h]
v5 = a2;
if ( a2 >= 0x80 )
{
if ( a2 >= 0x800 )
{
if ( a2 >= 0x10000 )
{
if ( a2 >= (unsigned long long)&off_200000 )
return 0;
v4 = 4;
}
else
{
v4 = 3;
}
}
else
{
v4 = 2;
}
}
else
{
v4 = 1;
}
switch ( v4 )
{
case 1u:
goto LABEL_14;
case 2u:
goto LABEL_13;
case 3u:
goto LABEL_12;
case 4u:
a3[3] = a2 & 0x3F | 0x80;
v5 = (a2 >> 6) | 0x10000;
LABEL_12:
a3[2] = v5 & 0x3F | 0x80;
v5 = (v5 >> 6) | 0x800;
LABEL_13:
a3[1] = v5 & 0x3F | 0x80;
v5 = (v5 >> 6) | 0xC0;
LABEL_14:
*a3 = v5;
break;
default:
break;
}
return v4;
}
|
my_wc_mb_utf8mb4_no_range:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
CMP qword ptr [RBP + -0x18],0x80
JNC 0x001c7db3
MOV dword ptr [RBP + -0x24],0x1
JMP 0x001c7dfe
LAB_001c7db3:
CMP qword ptr [RBP + -0x18],0x800
JNC 0x001c7dc6
MOV dword ptr [RBP + -0x24],0x2
JMP 0x001c7dfc
LAB_001c7dc6:
CMP qword ptr [RBP + -0x18],0x10000
JNC 0x001c7dd9
MOV dword ptr [RBP + -0x24],0x3
JMP 0x001c7dfa
LAB_001c7dd9:
CMP qword ptr [RBP + -0x18],0x200000
JNC 0x001c7dec
MOV dword ptr [RBP + -0x24],0x4
JMP 0x001c7df8
LAB_001c7dec:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001c7ecb
LAB_001c7df8:
JMP 0x001c7dfa
LAB_001c7dfa:
JMP 0x001c7dfc
LAB_001c7dfc:
JMP 0x001c7dfe
LAB_001c7dfe:
MOV EAX,dword ptr [RBP + -0x24]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x30],RCX
SUB EAX,0x3
JA 0x001c7ec5
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x313970]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_4:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0x10000
MOV qword ptr [RBP + -0x18],RAX
caseD_3:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0x800
MOV qword ptr [RBP + -0x18],RAX
caseD_2:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0xc0
MOV qword ptr [RBP + -0x18],RAX
caseD_1:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
default:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_001c7ecb:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_utf8mb4_no_range(int8 param_1,ulong param_2,int1 *param_3)
{
int4 local_2c;
ulong local_20;
if (param_2 < 0x80) {
local_2c = 1;
}
else if (param_2 < 0x800) {
local_2c = 2;
}
else if (param_2 < 0x10000) {
local_2c = 3;
}
else {
if (0x1fffff < param_2) {
return 0;
}
local_2c = 4;
}
local_20 = param_2;
switch(local_2c) {
case 4:
param_3[3] = (byte)param_2 & 0x3f | 0x80;
local_20 = param_2 >> 6 | 0x10000;
case 3:
param_3[2] = (byte)local_20 & 0x3f | 0x80;
local_20 = local_20 >> 6 | 0x800;
case 2:
param_3[1] = (byte)local_20 & 0x3f | 0x80;
local_20 = local_20 >> 6 | 0xc0;
case 1:
*param_3 = (char)local_20;
return local_2c;
default:
return local_2c;
}
}
|
|
66,453 |
eth_free_codes
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_account.c
|
INTERNAL void eth_free_codes(call_code_t* call_codes) {
while (call_codes) {
call_code_t* next = call_codes->next;
if (call_codes->free) safe_free(call_codes->code.data);
safe_free(call_codes);
call_codes = next;
}
}
|
O0
|
c
|
eth_free_codes:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x33f99
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x33f86
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x9dbf0
movq -0x8(%rbp), %rdi
callq 0x9dbf0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x33f5c
addq $0x10, %rsp
popq %rbp
retq
nop
|
eth_free_codes:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
loc_33F5C:
cmp [rbp+var_8], 0
jz short loc_33F99
mov rax, [rbp+var_8]
mov rax, [rax+38h]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
test byte ptr [rax+30h], 1
jz short loc_33F86
mov rax, [rbp+var_8]
mov rdi, [rax+28h]
call safe_free
loc_33F86:
mov rdi, [rbp+var_8]
call safe_free
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp short loc_33F5C
loc_33F99:
add rsp, 10h
pop rbp
retn
|
long long eth_free_codes(long long a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-10h]
while ( a1 )
{
v2 = *(_QWORD *)(a1 + 56);
if ( (*(_BYTE *)(a1 + 48) & 1) != 0 )
safe_free(*(_QWORD *)(a1 + 40));
safe_free(a1);
result = v2;
a1 = v2;
}
return result;
}
|
eth_free_codes:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
LAB_00133f5c:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00133f99
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x30],0x1
JZ 0x00133f86
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x28]
CALL 0x0019dbf0
LAB_00133f86:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0019dbf0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00133f5c
LAB_00133f99:
ADD RSP,0x10
POP RBP
RET
|
void eth_free_codes(long param_1)
{
long lVar1;
int8 local_10;
local_10 = param_1;
while (local_10 != 0) {
lVar1 = *(long *)(local_10 + 0x38);
if ((*(byte *)(local_10 + 0x30) & 1) != 0) {
safe_free(*(int8 *)(local_10 + 0x28));
}
safe_free(local_10);
local_10 = lVar1;
}
return;
}
|
|
66,454 |
my_rw_unlock
|
eloqsql/mysys/thr_rwlock.c
|
int my_rw_unlock(my_rw_lock_t *rwp)
{
DBUG_PRINT("rw_unlock",
("state: %d waiters: %d", rwp->state, rwp->waiters));
pthread_mutex_lock(&rwp->lock);
DBUG_ASSERT(rwp->state != 0);
if (rwp->state == -1) /* writer releasing */
{
my_rw_lock_assert_write_owner(rwp);
rwp->state= 0; /* mark as available */
#ifdef SAFE_MUTEX
rwp->write_thread= 0;
#endif
if ( rwp->waiters ) /* writers queued */
pthread_cond_signal( &rwp->writers );
else
pthread_cond_broadcast( &rwp->readers );
}
else
{
if ( --rwp->state == 0 && /* no more readers */
rwp->waiters)
pthread_cond_signal( &rwp->writers );
}
pthread_mutex_unlock( &rwp->lock );
return(0);
}
|
O3
|
c
|
my_rw_unlock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x36260
movl 0x88(%rbx), %eax
cmpl $-0x1, %eax
je 0x61e70
decl %eax
movl %eax, 0x88(%rbx)
jne 0x61e97
cmpl $0x0, 0x8c(%rbx)
jne 0x61e83
jmp 0x61e97
movl $0x0, 0x88(%rbx)
cmpl $0x0, 0x8c(%rbx)
je 0x61e8e
leaq 0x58(%rbx), %rdi
callq 0x36700
jmp 0x61e97
leaq 0x28(%rbx), %rdi
callq 0x368e0
movq %rbx, %rdi
callq 0x36220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
my_rw_unlock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _pthread_mutex_lock
mov eax, [rbx+88h]
cmp eax, 0FFFFFFFFh
jz short loc_61E70
dec eax
mov [rbx+88h], eax
jnz short loc_61E97
cmp dword ptr [rbx+8Ch], 0
jnz short loc_61E83
jmp short loc_61E97
loc_61E70:
mov dword ptr [rbx+88h], 0
cmp dword ptr [rbx+8Ch], 0
jz short loc_61E8E
loc_61E83:
lea rdi, [rbx+58h]
call _pthread_cond_signal
jmp short loc_61E97
loc_61E8E:
lea rdi, [rbx+28h]
call _pthread_cond_broadcast
loc_61E97:
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
|
long long my_rw_unlock(long long a1)
{
int v1; // eax
int v2; // eax
pthread_mutex_lock(a1);
v1 = *(_DWORD *)(a1 + 136);
if ( v1 == -1 )
{
*(_DWORD *)(a1 + 136) = 0;
if ( !*(_DWORD *)(a1 + 140) )
{
pthread_cond_broadcast(a1 + 40);
goto LABEL_8;
}
goto LABEL_6;
}
v2 = v1 - 1;
*(_DWORD *)(a1 + 136) = v2;
if ( !v2 && *(_DWORD *)(a1 + 140) )
LABEL_6:
pthread_cond_signal(a1 + 88);
LABEL_8:
pthread_mutex_unlock(a1);
return 0LL;
}
|
my_rw_unlock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00136260
MOV EAX,dword ptr [RBX + 0x88]
CMP EAX,-0x1
JZ 0x00161e70
DEC EAX
MOV dword ptr [RBX + 0x88],EAX
JNZ 0x00161e97
CMP dword ptr [RBX + 0x8c],0x0
JNZ 0x00161e83
JMP 0x00161e97
LAB_00161e70:
MOV dword ptr [RBX + 0x88],0x0
CMP dword ptr [RBX + 0x8c],0x0
JZ 0x00161e8e
LAB_00161e83:
LEA RDI,[RBX + 0x58]
CALL 0x00136700
JMP 0x00161e97
LAB_00161e8e:
LEA RDI,[RBX + 0x28]
CALL 0x001368e0
LAB_00161e97:
MOV RDI,RBX
CALL 0x00136220
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 my_rw_unlock(pthread_mutex_t *param_1)
{
int iVar1;
pthread_mutex_lock(param_1);
if (*(int *)((long)param_1 + 0x88) == -1) {
*(int4 *)((long)param_1 + 0x88) = 0;
if (*(int *)((long)param_1 + 0x8c) == 0) {
pthread_cond_broadcast((pthread_cond_t *)(param_1 + 1));
goto LAB_00161e97;
}
}
else {
iVar1 = *(int *)((long)param_1 + 0x88) + -1;
*(int *)((long)param_1 + 0x88) = iVar1;
if ((iVar1 != 0) || (*(int *)((long)param_1 + 0x8c) == 0)) goto LAB_00161e97;
}
pthread_cond_signal((pthread_cond_t *)((long)param_1 + 0x58));
LAB_00161e97:
pthread_mutex_unlock(param_1);
return 0;
}
|
|
66,455 |
Gcalc_scan_iterator::get_event_x() const
|
eloqsql/sql/gcalc_slicescan.cc
|
double Gcalc_scan_iterator::get_event_x() const
{
if (state.pi->type == Gcalc_heap::nt_intersection)
{
Gcalc_coord1 dxa, dya;
Gcalc_coord2 t_a, t_b;
Gcalc_coord3 a_tb, b_ta, x_exp;
calc_t(t_a, t_b, dxa, dya,
state.pi->node.intersection.p1, state.pi->node.intersection.p2, state.pi->node.intersection.p3, state.pi->node.intersection.p4);
gcalc_mul_coord(a_tb, GCALC_COORD_BASE3,
t_b, GCALC_COORD_BASE2, state.pi->node.intersection.p1->node.shape.ix, GCALC_COORD_BASE);
gcalc_mul_coord(b_ta, GCALC_COORD_BASE3,
t_a, GCALC_COORD_BASE2, dxa, GCALC_COORD_BASE);
gcalc_add_coord(x_exp, GCALC_COORD_BASE3, a_tb, b_ta);
return (get_pure_double(x_exp, GCALC_COORD_BASE3) /
get_pure_double(t_b, GCALC_COORD_BASE2)) / m_heap->coord_extent;
}
else
return state.pi->node.shape.x;
}
|
O0
|
cpp
|
Gcalc_scan_iterator::get_event_x() const:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x68(%rax), %rax
cmpl $0x1, 0x8(%rax)
jne 0xe4e0f8
movq -0xa8(%rbp), %rax
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movq 0x68(%rax), %r8
movq 0x10(%r8), %r8
movq 0x68(%rax), %r9
movq 0x18(%r9), %r9
movq 0x68(%rax), %r10
movq 0x20(%r10), %r10
movq 0x68(%rax), %rax
movq 0x28(%rax), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xe4dc80
movq -0xa8(%rbp), %rax
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq 0x68(%rax), %rax
movq 0x10(%rax), %r8
addq $0x10, %r8
addq $0x28, %r8
movl $0x6, %esi
movl $0x4, %ecx
movl $0x2, %r9d
callq 0xe4ab50
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x18(%rbp), %r8
movl $0x6, %esi
movl $0x4, %ecx
movl $0x2, %r9d
callq 0xe4ab50
leaq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rdx
leaq -0x80(%rbp), %rcx
movl $0x6, %esi
callq 0xe4ad00
leaq -0xa0(%rbp), %rdi
movl $0x6, %esi
callq 0xe4df40
movsd %xmm0, -0xb0(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x4, %esi
callq 0xe4df40
movq -0xa8(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0xb0(%rbp), %xmm0
divsd %xmm1, %xmm0
movq 0x40(%rax), %rax
divsd 0x38(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xe4e10d
movq -0xa8(%rbp), %rax
movq 0x68(%rax), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZNK19Gcalc_scan_iterator11get_event_xEv:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov [rbp+var_A8], rax
mov rax, [rax+68h]
cmp dword ptr [rax+8], 1
jnz loc_E4E0F8
mov rax, [rbp+var_A8]
lea rdi, [rbp+var_30]; unsigned int *
lea rsi, [rbp+var_40]; unsigned int *
lea rdx, [rbp+var_18]; unsigned int *
lea rcx, [rbp+var_20]; unsigned int *
mov r8, [rax+68h]
mov r8, [r8+10h]; Gcalc_heap::Info *
mov r9, [rax+68h]
mov r9, [r9+18h]; Gcalc_heap::Info *
mov r10, [rax+68h]
mov r10, [r10+20h]
mov rax, [rax+68h]
mov rax, [rax+28h]
mov [rsp+0C0h+var_C0], r10; Gcalc_heap::Info *
mov [rsp+0C0h+var_B8], rax; Gcalc_heap::Info *
call _Z6calc_tPjS_S_S_PKN10Gcalc_heap4InfoES3_S3_S3_; calc_t(uint *,uint *,uint *,uint *,Gcalc_heap::Info const*,Gcalc_heap::Info const*,Gcalc_heap::Info const*,Gcalc_heap::Info const*)
mov rax, [rbp+var_A8]
lea rdi, [rbp+var_60]; unsigned int *
lea rdx, [rbp+var_40]; unsigned int *
mov rax, [rax+68h]
mov r8, [rax+10h]
add r8, 10h
add r8, 28h ; '('; unsigned int *
mov esi, 6; int
mov ecx, 4; int
mov r9d, 2; int
call _Z15gcalc_mul_coordPjiPKjiS1_i; gcalc_mul_coord(uint *,int,uint const*,int,uint const*,int)
lea rdi, [rbp+var_80]; unsigned int *
lea rdx, [rbp+var_30]; unsigned int *
lea r8, [rbp+var_18]; unsigned int *
mov esi, 6; int
mov ecx, 4; int
mov r9d, 2; int
call _Z15gcalc_mul_coordPjiPKjiS1_i; gcalc_mul_coord(uint *,int,uint const*,int,uint const*,int)
lea rdi, [rbp+var_A0]; unsigned int *
lea rdx, [rbp+var_60]; unsigned int *
lea rcx, [rbp+var_80]; unsigned int *
mov esi, 6; int
call _Z15gcalc_add_coordPjiPKjS1_; gcalc_add_coord(uint *,int,uint const*,uint const*)
lea rdi, [rbp+var_A0]; this
mov esi, offset byte_6; unsigned int *
call _ZN19Gcalc_scan_iterator15get_pure_doubleEPKji; Gcalc_scan_iterator::get_pure_double(uint const*,int)
movsd [rbp+var_B0], xmm0
lea rdi, [rbp+var_40]; this
mov esi, offset byte_4; unsigned int *
call _ZN19Gcalc_scan_iterator15get_pure_doubleEPKji; Gcalc_scan_iterator::get_pure_double(uint const*,int)
mov rax, [rbp+var_A8]
movaps xmm1, xmm0
movsd xmm0, [rbp+var_B0]
divsd xmm0, xmm1
mov rax, [rax+40h]
divsd xmm0, qword ptr [rax+38h]
movsd [rbp+var_8], xmm0
jmp short loc_E4E10D
loc_E4E0F8:
mov rax, [rbp+var_A8]
mov rax, [rax+68h]
movsd xmm0, qword ptr [rax+28h]
movsd [rbp+var_8], xmm0
loc_E4E10D:
movsd xmm0, [rbp+var_8]
add rsp, 0C0h
pop rbp
retn
|
double Gcalc_scan_iterator::get_event_x(Gcalc_scan_iterator *this)
{
double pure_double; // [rsp+10h] [rbp-B0h]
unsigned int v3[8]; // [rsp+20h] [rbp-A0h] BYREF
unsigned int v4[8]; // [rsp+40h] [rbp-80h] BYREF
unsigned int v5[8]; // [rsp+60h] [rbp-60h] BYREF
unsigned int v6[4]; // [rsp+80h] [rbp-40h] BYREF
unsigned int v7[4]; // [rsp+90h] [rbp-30h] BYREF
unsigned int v8; // [rsp+A0h] [rbp-20h] BYREF
unsigned int v9; // [rsp+A8h] [rbp-18h] BYREF
Gcalc_scan_iterator *v10; // [rsp+B0h] [rbp-10h]
v10 = this;
if ( *(_DWORD *)(*((_QWORD *)this + 13) + 8LL) != 1 )
return *(double *)(*((_QWORD *)this + 13) + 40LL);
calc_t(
v7,
v6,
&v9,
&v8,
*(const Gcalc_heap::Info **)(*((_QWORD *)this + 13) + 16LL),
*(const Gcalc_heap::Info **)(*((_QWORD *)this + 13) + 24LL),
*(const Gcalc_heap::Info **)(*((_QWORD *)this + 13) + 32LL),
*(const Gcalc_heap::Info **)(*((_QWORD *)this + 13) + 40LL));
gcalc_mul_coord(v5, 6, v6, 4, (const unsigned int *)(*(_QWORD *)(*((_QWORD *)this + 13) + 16LL) + 56LL), 2);
gcalc_mul_coord(v4, 6, v7, 4, &v9, 2);
gcalc_add_coord(v3, 6, v5, v4);
pure_double = Gcalc_scan_iterator::get_pure_double((Gcalc_scan_iterator *)v3, (const unsigned int *)&byte_6);
return pure_double
/ Gcalc_scan_iterator::get_pure_double((Gcalc_scan_iterator *)v6, (const unsigned int *)&byte_4)
/ *(double *)(*((_QWORD *)this + 8) + 56LL);
}
|
real_op:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00e4dfe6
LAB_00e4dfe6:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00e4df80
CMP EAX,0x0
JNZ 0x00e4e006
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x64],0x1
XORPS XMM0,XMM0
MOVSD qword ptr [RBP + -0x8],XMM0
JMP 0x00e4e03f
LAB_00e4e006:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x70]
MOV RDI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xe8]
MOV RAX,qword ptr [RBP + -0x20]
MOVSD qword ptr [RBP + -0x18],XMM0
MOV RCX,qword ptr [RAX + 0x70]
MOV RCX,qword ptr [RCX + 0x10]
MOV CL,byte ptr [RCX + 0x64]
AND CL,0x1
MOV byte ptr [RAX + 0x64],CL
MOVSD XMM0,qword ptr [RBP + -0x18]
MOVSD qword ptr [RBP + -0x8],XMM0
LAB_00e4e03f:
MOVSD XMM0,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
/* Item_func_nullif::real_op() */
int8 __thiscall Item_func_nullif::real_op(Item_func_nullif *this)
{
int iVar1;
int8 local_10;
iVar1 = compare(this);
if (iVar1 == 0) {
this[100] = (Item_func_nullif)0x1;
local_10 = 0;
}
else {
local_10 = (**(code **)(**(long **)(*(long *)(this + 0x70) + 0x10) + 0xe8))();
this[100] = (Item_func_nullif)(*(byte *)(*(long *)(*(long *)(this + 0x70) + 0x10) + 100) & 1);
}
return local_10;
}
|
|
66,456 |
js_array_buffer_constructor3
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_buffer_constructor3(JSContext *ctx,
JSValue new_target,
uint64_t len, uint64_t *max_len,
JSClassID class_id,
uint8_t *buf,
JSFreeArrayBufferDataFunc *free_func,
void *opaque, BOOL alloc_flag)
{
JSRuntime *rt = ctx->rt;
JSValue obj;
JSArrayBuffer *abuf = NULL;
uint64_t sab_alloc_len;
if (!alloc_flag && buf && max_len && free_func != js_array_buffer_free) {
// not observable from JS land, only through C API misuse;
// JS code cannot create externally managed buffers directly
return JS_ThrowInternalError(ctx,
"resizable ArrayBuffers not supported "
"for externally managed buffers");
}
obj = js_create_from_ctor(ctx, new_target, class_id);
if (JS_IsException(obj))
return obj;
/* XXX: we are currently limited to 2 GB */
if (len > INT32_MAX) {
JS_ThrowRangeError(ctx, "invalid array buffer length");
goto fail;
}
if (max_len && *max_len > INT32_MAX) {
JS_ThrowRangeError(ctx, "invalid max array buffer length");
goto fail;
}
abuf = js_malloc(ctx, sizeof(*abuf));
if (!abuf)
goto fail;
abuf->byte_length = len;
abuf->max_byte_length = max_len ? *max_len : -1;
if (alloc_flag) {
if (class_id == JS_CLASS_SHARED_ARRAY_BUFFER &&
rt->sab_funcs.sab_alloc) {
// TOOD(bnoordhuis) resizing backing memory for SABs atomically
// is hard so we cheat and allocate |maxByteLength| bytes upfront
sab_alloc_len = max_len ? *max_len : len;
abuf->data = rt->sab_funcs.sab_alloc(rt->sab_funcs.sab_opaque,
max_int(sab_alloc_len, 1));
if (!abuf->data)
goto fail;
memset(abuf->data, 0, sab_alloc_len);
} else {
/* the allocation must be done after the object creation */
abuf->data = js_mallocz(ctx, max_int(len, 1));
if (!abuf->data)
goto fail;
}
} else {
if (class_id == JS_CLASS_SHARED_ARRAY_BUFFER &&
rt->sab_funcs.sab_dup) {
rt->sab_funcs.sab_dup(rt->sab_funcs.sab_opaque, buf);
}
abuf->data = buf;
}
init_list_head(&abuf->array_list);
abuf->detached = FALSE;
abuf->shared = (class_id == JS_CLASS_SHARED_ARRAY_BUFFER);
abuf->opaque = opaque;
abuf->free_func = free_func;
if (alloc_flag && buf)
memcpy(abuf->data, buf, len);
JS_SetOpaqueInternal(obj, abuf);
return obj;
fail:
JS_FreeValue(ctx, obj);
js_free(ctx, abuf);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_array_buffer_constructor3:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %r12
movq %rdi, %r13
movq 0x18(%rdi), %r15
testq %r8, %r8
je 0x38060
cmpq $0x0, 0x50(%rsp)
je 0x38060
leaq 0x271(%rip), %rax # 0x382a5
cmpq %rax, 0x58(%rsp)
je 0x38060
cmpl $0x0, 0x68(%rsp)
jne 0x38060
leaq 0x68c28(%rip), %rsi # 0xa0c71
xorl %ebx, %ebx
movq %r13, %rdi
xorl %eax, %eax
callq 0x21a7f
movl $0x6, %r14d
jmp 0x380e6
movq %rcx, 0x10(%rsp)
movq %r13, %rdi
movl %ebp, %ecx
callq 0x36142
movq %rax, %rbx
movq %rdx, %r14
cmpl $0x6, %r14d
jne 0x3808d
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbx, %rcx
andq %rax, %rcx
jmp 0x380e8
cmpq $0x7fffffff, 0x10(%rsp) # imm = 0x7FFFFFFF
jbe 0x380a1
leaq 0x68c16(%rip), %rsi # 0xa0cb5
jmp 0x380b7
testq %r12, %r12
je 0x380ff
cmpq $0x7fffffff, (%r12) # imm = 0x7FFFFFFF
jbe 0x380ff
leaq 0x68c1a(%rip), %rsi # 0xa0cd1
xorl %r15d, %r15d
movq %r13, %rdi
xorl %eax, %eax
callq 0x1fec9
movq 0x18(%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ccb2
movq %r13, %rdi
movq %r15, %rsi
callq 0x1bf85
movl $0x6, %r14d
xorl %ebx, %ebx
xorl %ecx, %ecx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %esi
movq %r13, %rdi
callq 0xed5d
testq %rax, %rax
je 0x38128
movq 0x10(%rsp), %rcx
movq %rax, 0x8(%rsp)
movl %ecx, (%rax)
testq %r12, %r12
je 0x3812d
movl (%r12), %eax
jmp 0x38132
xorl %r15d, %r15d
jmp 0x380c4
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq 0x50(%rsp), %rsi
movl 0x68(%rsp), %edi
movq 0x8(%rsp), %rdx
movl %eax, 0x4(%rdx)
testl %edi, %edi
je 0x381aa
cmpl $0x14, %ebp
jne 0x3822a
movq 0x160(%r15), %rax
testq %rax, %rax
je 0x3822a
testq %r12, %r12
je 0x38169
movq (%r12), %rcx
movq 0x178(%r15), %rdi
cmpl $0x2, %ecx
movl $0x1, %esi
movq %rcx, %r12
cmovgel %ecx, %esi
callq *%rax
movq 0x8(%rsp), %r15
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x380c4
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xe340
movq 0x50(%rsp), %rsi
movl 0x68(%rsp), %edi
jmp 0x381d6
cmpl $0x14, %ebp
jne 0x381cd
movq 0x170(%r15), %rax
testq %rax, %rax
je 0x381cd
movq 0x178(%r15), %rdi
callq *%rax
movl 0x68(%rsp), %edi
movq 0x50(%rsp), %rsi
movq 0x8(%rsp), %r15
movq %rsi, 0x10(%r15)
testl %edi, %edi
sete %al
testq %rsi, %rsi
sete %cl
movq %r15, %rdx
addq $0x18, %rdx
movq %rdx, 0x18(%r15)
movq %rdx, 0x20(%r15)
movb $0x0, 0x8(%r15)
cmpl $0x14, %ebp
sete 0x9(%r15)
movq 0x60(%rsp), %rdx
movq %rdx, 0x28(%r15)
movq 0x58(%rsp), %rdx
movq %rdx, 0x30(%r15)
orb %al, %cl
jne 0x38221
movq 0x10(%r15), %rdi
movq 0x10(%rsp), %rdx
callq 0xe5a0
movq %r15, 0x30(%rbx)
jmp 0x3807b
cmpl $0x2, %ecx
movl $0x1, %esi
cmovgel %ecx, %esi
movq %r13, %rdi
callq 0xed7d
movl 0x68(%rsp), %edi
movq 0x50(%rsp), %rsi
movq 0x8(%rsp), %r15
movq %rax, 0x10(%r15)
testq %rax, %rax
jne 0x381d6
jmp 0x380c4
|
js_array_buffer_constructor3:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, r9d
mov r12, r8
mov r13, rdi
mov r15, [rdi+18h]
test r8, r8
jz short loc_38060
cmp [rsp+48h+arg_0], 0
jz short loc_38060
lea rax, js_array_buffer_free
cmp [rsp+48h+arg_8], rax
jz short loc_38060
cmp [rsp+48h+arg_18], 0
jnz short loc_38060
lea rsi, aResizableArray; "resizable ArrayBuffers not supported fo"...
xor ebx, ebx
mov rdi, r13
xor eax, eax
call JS_ThrowInternalError
mov r14d, 6
jmp loc_380E6
loc_38060:
mov [rsp+48h+var_38], rcx
mov rdi, r13
mov ecx, ebp
call js_create_from_ctor
mov rbx, rax
mov r14, rdx
cmp r14d, 6
jnz short loc_3808D
loc_3807B:
mov rax, 0FFFFFFFF00000000h
mov rcx, rbx
and rcx, rax
jmp short loc_380E8
loc_3808D:
cmp [rsp+48h+var_38], 7FFFFFFFh
jbe short loc_380A1
lea rsi, aInvalidArrayBu; "invalid array buffer length"
jmp short loc_380B7
loc_380A1:
test r12, r12
jz short loc_380FF
cmp qword ptr [r12], 7FFFFFFFh
jbe short loc_380FF
lea rsi, aInvalidMaxArra; "invalid max array buffer length"
loc_380B7:
xor r15d, r15d
mov rdi, r13
xor eax, eax
call JS_ThrowRangeError
loc_380C4:
mov rdi, [r13+18h]
mov rsi, rbx
mov rdx, r14
call JS_FreeValueRT
mov rdi, r13
mov rsi, r15
call js_free
mov r14d, 6
xor ebx, ebx
loc_380E6:
xor ecx, ecx
loc_380E8:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_380FF:
mov esi, 38h ; '8'
mov rdi, r13
call js_malloc
test rax, rax
jz short loc_38128
mov rcx, [rsp+48h+var_38]
mov [rsp+48h+var_40], rax
mov [rax], ecx
test r12, r12
jz short loc_3812D
mov eax, [r12]
jmp short loc_38132
loc_38128:
xor r15d, r15d
jmp short loc_380C4
loc_3812D:
mov eax, 0FFFFFFFFh
loc_38132:
mov rsi, [rsp+48h+arg_0]
mov edi, [rsp+48h+arg_18]
mov rdx, [rsp+48h+var_40]
mov [rdx+4], eax
test edi, edi
jz short loc_381AA
cmp ebp, 14h
jnz loc_3822A
mov rax, [r15+160h]
test rax, rax
jz loc_3822A
test r12, r12
jz short loc_38169
mov rcx, [r12]
loc_38169:
mov rdi, [r15+178h]
cmp ecx, 2
mov esi, 1
mov r12, rcx
cmovge esi, ecx
call rax
mov r15, [rsp+48h+var_40]
mov [r15+10h], rax
test rax, rax
jz loc_380C4
mov rdi, rax
xor esi, esi
mov rdx, r12
call _memset
mov rsi, [rsp+48h+arg_0]
mov edi, [rsp+48h+arg_18]
jmp short loc_381D6
loc_381AA:
cmp ebp, 14h
jnz short loc_381CD
mov rax, [r15+170h]
test rax, rax
jz short loc_381CD
mov rdi, [r15+178h]
call rax
mov edi, [rsp+48h+arg_18]
mov rsi, [rsp+48h+arg_0]
loc_381CD:
mov r15, [rsp+48h+var_40]
mov [r15+10h], rsi
loc_381D6:
test edi, edi
setz al
test rsi, rsi
setz cl
mov rdx, r15
add rdx, 18h
mov [r15+18h], rdx
mov [r15+20h], rdx
mov byte ptr [r15+8], 0
cmp ebp, 14h
setz byte ptr [r15+9]
mov rdx, [rsp+48h+arg_10]
mov [r15+28h], rdx
mov rdx, [rsp+48h+arg_8]
mov [r15+30h], rdx
or cl, al
jnz short loc_38221
mov rdi, [r15+10h]
mov rdx, [rsp+48h+var_38]
call _memcpy
loc_38221:
mov [rbx+30h], r15
jmp loc_3807B
loc_3822A:
cmp ecx, 2
mov esi, 1
cmovge esi, ecx
mov rdi, r13
call js_mallocz
mov edi, [rsp+48h+arg_18]
mov rsi, [rsp+48h+arg_0]
mov r15, [rsp+48h+var_40]
mov [r15+10h], rax
test rax, rax
jnz short loc_381D6
jmp loc_380C4
|
unsigned long long js_array_buffer_constructor3(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
int *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
long long a15,
long long ( *a16)(),
long long a17,
int a18)
{
int v18; // ebp
_QWORD *v21; // r15
unsigned long long v22; // rbx
long long v23; // rdx
long long v24; // rcx
long long v25; // r8
long long v26; // r9
__m128 v27; // xmm4
__m128 v28; // xmm5
long long v29; // r14
unsigned long long v30; // rcx
const char *v31; // rsi
long long v32; // r15
_DWORD *v34; // rax
unsigned long long v35; // rcx
int v36; // eax
long long v37; // rsi
int v38; // edi
long long ( *v39)(_QWORD, long long); // rax
long long v40; // rsi
unsigned long long v41; // r12
long long v42; // rax
void ( *v43)(_QWORD, long long); // rax
unsigned long long v44; // rsi
long long v45; // rax
char v46; // [rsp+0h] [rbp-48h]
_DWORD *v47; // [rsp+8h] [rbp-40h]
v18 = a6;
v21 = *(_QWORD **)(a1 + 24);
if ( a5 && a15 && a16 != js_array_buffer_free && !a18 )
{
LODWORD(v22) = 0;
JS_ThrowInternalError(
a1,
(long long)"resizable ArrayBuffers not supported for externally managed buffers",
a3,
a4,
(long long)a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v46);
LABEL_15:
v30 = 0LL;
return v30 | (unsigned int)v22;
}
v22 = js_create_from_ctor(a1, a2, a3, a6);
v29 = v23;
if ( (_DWORD)v23 != 6 )
{
if ( a4 <= 0x7FFFFFFF )
{
if ( !a5 || *(_QWORD *)a5 <= 0x7FFFFFFFuLL )
{
v34 = (_DWORD *)js_malloc(a1, 56LL);
if ( v34 )
{
v35 = a4;
v47 = v34;
*v34 = a4;
if ( a5 )
v36 = *a5;
else
v36 = -1;
v37 = a15;
v38 = a18;
v47[1] = v36;
if ( a18 )
{
if ( v18 == 20 && (v39 = (long long ( *)(_QWORD, long long))v21[44]) != 0LL )
{
if ( a5 )
v35 = *(_QWORD *)a5;
v40 = 1LL;
v41 = v35;
if ( (int)v35 >= 2 )
v40 = (unsigned int)v35;
v42 = v39(v21[47], v40);
v32 = (long long)v47;
*((_QWORD *)v47 + 2) = v42;
if ( !v42 )
goto LABEL_14;
memset(v42, 0LL, v41);
v37 = a15;
v38 = a18;
}
else
{
v44 = 1LL;
if ( (int)a4 >= 2 )
v44 = (unsigned int)a4;
v45 = js_mallocz(a1, v44);
v38 = a18;
v37 = a15;
v32 = (long long)v47;
*((_QWORD *)v47 + 2) = v45;
if ( !v45 )
goto LABEL_14;
}
}
else
{
if ( v18 == 20 )
{
v43 = (void ( *)(_QWORD, long long))v21[46];
if ( v43 )
{
v43(v21[47], a15);
v38 = 0;
v37 = a15;
}
}
v32 = (long long)v47;
*((_QWORD *)v47 + 2) = v37;
}
*(_QWORD *)(v32 + 24) = v32 + 24;
*(_QWORD *)(v32 + 32) = v32 + 24;
*(_BYTE *)(v32 + 8) = 0;
*(_BYTE *)(v32 + 9) = v18 == 20;
*(_QWORD *)(v32 + 40) = a17;
*(_QWORD *)(v32 + 48) = a16;
if ( v38 != 0 && v37 != 0 )
memcpy(*(_QWORD *)(v32 + 16), v37, a4);
*(_QWORD *)(v22 + 48) = v32;
goto LABEL_7;
}
v32 = 0LL;
LABEL_14:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v22, v29);
js_free(a1, v32);
LODWORD(v22) = 0;
goto LABEL_15;
}
v31 = "invalid max array buffer length";
}
else
{
v31 = "invalid array buffer length";
}
v32 = 0LL;
JS_ThrowRangeError(a1, (long long)v31, v23, v24, v25, v26, a7, a8, a9, a10, v27, v28, a13, a14, v46);
goto LABEL_14;
}
LABEL_7:
v30 = v22 & 0xFFFFFFFF00000000LL;
return v30 | (unsigned int)v22;
}
|
js_array_buffer_constructor3:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,R9D
MOV R12,R8
MOV R13,RDI
MOV R15,qword ptr [RDI + 0x18]
TEST R8,R8
JZ 0x00138060
CMP qword ptr [RSP + 0x50],0x0
JZ 0x00138060
LEA RAX,[0x1382a5]
CMP qword ptr [RSP + 0x58],RAX
JZ 0x00138060
CMP dword ptr [RSP + 0x68],0x0
JNZ 0x00138060
LEA RSI,[0x1a0c71]
XOR EBX,EBX
MOV RDI,R13
XOR EAX,EAX
CALL 0x00121a7f
MOV R14D,0x6
JMP 0x001380e6
LAB_00138060:
MOV qword ptr [RSP + 0x10],RCX
MOV RDI,R13
MOV ECX,EBP
CALL 0x00136142
MOV RBX,RAX
MOV R14,RDX
CMP R14D,0x6
JNZ 0x0013808d
LAB_0013807b:
MOV RAX,-0x100000000
MOV RCX,RBX
AND RCX,RAX
JMP 0x001380e8
LAB_0013808d:
CMP qword ptr [RSP + 0x10],0x7fffffff
JBE 0x001380a1
LEA RSI,[0x1a0cb5]
JMP 0x001380b7
LAB_001380a1:
TEST R12,R12
JZ 0x001380ff
CMP qword ptr [R12],0x7fffffff
JBE 0x001380ff
LEA RSI,[0x1a0cd1]
LAB_001380b7:
XOR R15D,R15D
MOV RDI,R13
XOR EAX,EAX
CALL 0x0011fec9
LAB_001380c4:
MOV RDI,qword ptr [R13 + 0x18]
MOV RSI,RBX
MOV RDX,R14
CALL 0x0011ccb2
MOV RDI,R13
MOV RSI,R15
CALL 0x0011bf85
MOV R14D,0x6
XOR EBX,EBX
LAB_001380e6:
XOR ECX,ECX
LAB_001380e8:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001380ff:
MOV ESI,0x38
MOV RDI,R13
CALL 0x0010ed5d
TEST RAX,RAX
JZ 0x00138128
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RAX],ECX
TEST R12,R12
JZ 0x0013812d
MOV EAX,dword ptr [R12]
JMP 0x00138132
LAB_00138128:
XOR R15D,R15D
JMP 0x001380c4
LAB_0013812d:
MOV EAX,0xffffffff
LAB_00138132:
MOV RSI,qword ptr [RSP + 0x50]
MOV EDI,dword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x8]
MOV dword ptr [RDX + 0x4],EAX
TEST EDI,EDI
JZ 0x001381aa
CMP EBP,0x14
JNZ 0x0013822a
MOV RAX,qword ptr [R15 + 0x160]
TEST RAX,RAX
JZ 0x0013822a
TEST R12,R12
JZ 0x00138169
MOV RCX,qword ptr [R12]
LAB_00138169:
MOV RDI,qword ptr [R15 + 0x178]
CMP ECX,0x2
MOV ESI,0x1
MOV R12,RCX
CMOVGE ESI,ECX
CALL RAX
MOV R15,qword ptr [RSP + 0x8]
MOV qword ptr [R15 + 0x10],RAX
TEST RAX,RAX
JZ 0x001380c4
MOV RDI,RAX
XOR ESI,ESI
MOV RDX,R12
CALL 0x0010e340
MOV RSI,qword ptr [RSP + 0x50]
MOV EDI,dword ptr [RSP + 0x68]
JMP 0x001381d6
LAB_001381aa:
CMP EBP,0x14
JNZ 0x001381cd
MOV RAX,qword ptr [R15 + 0x170]
TEST RAX,RAX
JZ 0x001381cd
MOV RDI,qword ptr [R15 + 0x178]
CALL RAX
MOV EDI,dword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x50]
LAB_001381cd:
MOV R15,qword ptr [RSP + 0x8]
MOV qword ptr [R15 + 0x10],RSI
LAB_001381d6:
TEST EDI,EDI
SETZ AL
TEST RSI,RSI
SETZ CL
MOV RDX,R15
ADD RDX,0x18
MOV qword ptr [R15 + 0x18],RDX
MOV qword ptr [R15 + 0x20],RDX
MOV byte ptr [R15 + 0x8],0x0
CMP EBP,0x14
SETZ byte ptr [R15 + 0x9]
MOV RDX,qword ptr [RSP + 0x60]
MOV qword ptr [R15 + 0x28],RDX
MOV RDX,qword ptr [RSP + 0x58]
MOV qword ptr [R15 + 0x30],RDX
OR CL,AL
JNZ 0x00138221
MOV RDI,qword ptr [R15 + 0x10]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0010e5a0
LAB_00138221:
MOV qword ptr [RBX + 0x30],R15
JMP 0x0013807b
LAB_0013822a:
CMP ECX,0x2
MOV ESI,0x1
CMOVGE ESI,ECX
MOV RDI,R13
CALL 0x0010ed7d
MOV EDI,dword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x50]
MOV R15,qword ptr [RSP + 0x8]
MOV qword ptr [R15 + 0x10],RAX
TEST RAX,RAX
JNZ 0x001381d6
JMP 0x001380c4
|
int1 [16]
js_array_buffer_constructor3
(long param_1,int8 param_2,int8 param_3,ulong param_4,ulong *param_5,
int param_6,void *param_7,code *param_8,int8 param_9,int param_10)
{
int iVar1;
int *piVar2;
void *__s;
long lVar3;
ulong uVar4;
char *pcVar5;
ulong uVar6;
int1 auVar7 [16];
int1 auVar8 [16];
lVar3 = *(long *)(param_1 + 0x18);
if ((((param_5 == (ulong *)0x0) || (param_7 == (void *)0x0)) || (param_8 == js_array_buffer_free))
|| (param_10 != 0)) {
auVar7 = js_create_from_ctor(param_1,param_2,param_3,param_6);
uVar4 = auVar7._0_8_;
if (auVar7._8_4_ == 6) {
LAB_0013807b:
uVar4 = uVar4 & 0xffffffff00000000;
goto LAB_001380e8;
}
if (param_4 < 0x80000000) {
if ((param_5 != (ulong *)0x0) && (0x7fffffff < *param_5)) {
pcVar5 = "invalid max array buffer length";
goto LAB_001380b7;
}
piVar2 = (int *)js_malloc(param_1,0x38);
if (piVar2 == (int *)0x0) {
piVar2 = (int *)0x0;
goto LAB_001380c4;
}
*piVar2 = (int)param_4;
if (param_5 == (ulong *)0x0) {
iVar1 = -1;
}
else {
iVar1 = (int)*param_5;
}
piVar2[1] = iVar1;
if (param_10 == 0) {
if ((param_6 == 0x14) && (*(code **)(lVar3 + 0x170) != (code *)0x0)) {
(**(code **)(lVar3 + 0x170))(*(int8 *)(lVar3 + 0x178));
}
*(void **)(piVar2 + 4) = param_7;
LAB_001381d6:
*(int **)(piVar2 + 6) = piVar2 + 6;
*(int **)(piVar2 + 8) = piVar2 + 6;
*(int1 *)(piVar2 + 2) = 0;
*(bool *)((long)piVar2 + 9) = param_6 == 0x14;
*(int8 *)(piVar2 + 10) = param_9;
*(code **)(piVar2 + 0xc) = param_8;
if (param_7 != (void *)0x0 && param_10 != 0) {
memcpy(*(void **)(piVar2 + 4),param_7,param_4);
}
*(int **)(uVar4 + 0x30) = piVar2;
goto LAB_0013807b;
}
if ((param_6 == 0x14) && (*(code **)(lVar3 + 0x160) != (code *)0x0)) {
uVar6 = param_4;
if (param_5 != (ulong *)0x0) {
uVar6 = *param_5;
}
__s = (void *)(**(code **)(lVar3 + 0x160))(*(int8 *)(lVar3 + 0x178));
*(void **)(piVar2 + 4) = __s;
if (__s != (void *)0x0) {
memset(__s,0,uVar6);
goto LAB_001381d6;
}
}
else {
uVar6 = 1;
if (1 < (int)param_4) {
uVar6 = param_4 & 0xffffffff;
}
lVar3 = js_mallocz(param_1,uVar6);
*(long *)(piVar2 + 4) = lVar3;
if (lVar3 != 0) goto LAB_001381d6;
}
}
else {
pcVar5 = "invalid array buffer length";
LAB_001380b7:
piVar2 = (int *)0x0;
JS_ThrowRangeError(param_1,pcVar5);
}
LAB_001380c4:
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar4,auVar7._8_8_);
js_free(param_1,piVar2);
}
else {
JS_ThrowInternalError
(param_1,"resizable ArrayBuffers not supported for externally managed buffers");
}
auVar7 = ZEXT816(6) << 0x40;
uVar4 = 0;
LAB_001380e8:
auVar8._0_8_ = auVar7._0_8_ & 0xffffffff | uVar4;
auVar8._8_8_ = auVar7._8_8_;
return auVar8;
}
|
|
66,457 |
js_array_buffer_constructor3
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_buffer_constructor3(JSContext *ctx,
JSValue new_target,
uint64_t len, uint64_t *max_len,
JSClassID class_id,
uint8_t *buf,
JSFreeArrayBufferDataFunc *free_func,
void *opaque, BOOL alloc_flag)
{
JSRuntime *rt = ctx->rt;
JSValue obj;
JSArrayBuffer *abuf = NULL;
uint64_t sab_alloc_len;
if (!alloc_flag && buf && max_len && free_func != js_array_buffer_free) {
// not observable from JS land, only through C API misuse;
// JS code cannot create externally managed buffers directly
return JS_ThrowInternalError(ctx,
"resizable ArrayBuffers not supported "
"for externally managed buffers");
}
obj = js_create_from_ctor(ctx, new_target, class_id);
if (JS_IsException(obj))
return obj;
/* XXX: we are currently limited to 2 GB */
if (len > INT32_MAX) {
JS_ThrowRangeError(ctx, "invalid array buffer length");
goto fail;
}
if (max_len && *max_len > INT32_MAX) {
JS_ThrowRangeError(ctx, "invalid max array buffer length");
goto fail;
}
abuf = js_malloc(ctx, sizeof(*abuf));
if (!abuf)
goto fail;
abuf->byte_length = len;
abuf->max_byte_length = max_len ? *max_len : -1;
if (alloc_flag) {
if (class_id == JS_CLASS_SHARED_ARRAY_BUFFER &&
rt->sab_funcs.sab_alloc) {
// TOOD(bnoordhuis) resizing backing memory for SABs atomically
// is hard so we cheat and allocate |maxByteLength| bytes upfront
sab_alloc_len = max_len ? *max_len : len;
abuf->data = rt->sab_funcs.sab_alloc(rt->sab_funcs.sab_opaque,
max_int(sab_alloc_len, 1));
if (!abuf->data)
goto fail;
memset(abuf->data, 0, sab_alloc_len);
} else {
/* the allocation must be done after the object creation */
abuf->data = js_mallocz(ctx, max_int(len, 1));
if (!abuf->data)
goto fail;
}
} else {
if (class_id == JS_CLASS_SHARED_ARRAY_BUFFER &&
rt->sab_funcs.sab_dup) {
rt->sab_funcs.sab_dup(rt->sab_funcs.sab_opaque, buf);
}
abuf->data = buf;
}
init_list_head(&abuf->array_list);
abuf->detached = FALSE;
abuf->shared = (class_id == JS_CLASS_SHARED_ARRAY_BUFFER);
abuf->opaque = opaque;
abuf->free_func = free_func;
if (alloc_flag && buf)
memcpy(abuf->data, buf, len);
JS_SetOpaqueInternal(obj, abuf);
return obj;
fail:
JS_FreeValue(ctx, obj);
js_free(ctx, abuf);
return JS_EXCEPTION;
}
|
O2
|
c
|
js_array_buffer_constructor3:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %r12
movq %rdi, %r13
movq 0x18(%rdi), %r15
testq %r8, %r8
je 0x3128e
cmpq $0x0, 0x50(%rsp)
je 0x3128e
leaq 0x265(%rip), %rax # 0x314c9
cmpq %rax, 0x58(%rsp)
je 0x3128e
cmpl $0x0, 0x68(%rsp)
jne 0x3128e
leaq 0x56942(%rip), %rsi # 0x87bbb
xorl %ebx, %ebx
movq %r13, %rdi
xorl %eax, %eax
callq 0x1bbf5
pushq $0x6
popq %r14
jmp 0x31311
movq %rcx, 0x10(%rsp)
movq %r13, %rdi
movl %ebp, %ecx
callq 0x2f8de
movq %rax, %rbx
movq %rdx, %r14
cmpl $0x6, %r14d
jne 0x312bb
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbx, %rcx
andq %rax, %rcx
jmp 0x31313
cmpq $0x7fffffff, 0x10(%rsp) # imm = 0x7FFFFFFF
jbe 0x312cf
leaq 0x56932(%rip), %rsi # 0x87bff
jmp 0x312e5
testq %r12, %r12
je 0x3132a
cmpq $0x7fffffff, (%r12) # imm = 0x7FFFFFFF
jbe 0x3132a
leaq 0x56936(%rip), %rsi # 0x87c1b
xorl %r15d, %r15d
movq %r13, %rdi
xorl %eax, %eax
callq 0x1a137
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x174a2
movq %r13, %rdi
movq %r15, %rsi
callq 0x166f2
pushq $0x6
popq %r14
xorl %ebx, %ebx
xorl %ecx, %ecx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rsi
movq %r13, %rdi
callq 0x16698
testq %rax, %rax
je 0x31351
movq 0x10(%rsp), %rdx
movq %rax, 0x8(%rsp)
movl %edx, (%rax)
testq %r12, %r12
je 0x31356
movl (%r12), %eax
jmp 0x31359
xorl %r15d, %r15d
jmp 0x312f2
pushq $-0x1
popq %rax
movq 0x50(%rsp), %rsi
movl 0x68(%rsp), %edi
movq 0x8(%rsp), %rcx
movl %eax, 0x4(%rcx)
testl %edi, %edi
je 0x313fc
cmpl $0x14, %ebp
jne 0x313d0
movq 0x160(%r15), %rax
testq %rax, %rax
je 0x313d0
movl %edx, %ecx
testq %r12, %r12
je 0x31391
movq (%r12), %rcx
movq %rcx, %rdx
movq %rdx, %r12
movq 0x178(%r15), %rdi
cmpl $0x2, %ecx
pushq $0x1
popq %rsi
cmovgel %ecx, %esi
callq *%rax
movq 0x8(%rsp), %r15
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x312f2
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xe350
movq 0x50(%rsp), %rsi
movl 0x68(%rsp), %edi
jmp 0x31428
cmpl $0x1, %edx
movl %edx, %esi
adcl $0x0, %esi
movq %r13, %rdi
callq 0x166c5
movl 0x68(%rsp), %edi
movq 0x50(%rsp), %rsi
movq 0x8(%rsp), %r15
movq %rax, 0x10(%r15)
testq %rax, %rax
jne 0x31428
jmp 0x312f2
cmpl $0x14, %ebp
jne 0x3141f
movq 0x170(%r15), %rax
testq %rax, %rax
je 0x3141f
movq 0x178(%r15), %rdi
callq *%rax
movl 0x68(%rsp), %edi
movq 0x50(%rsp), %rsi
movq 0x8(%rsp), %r15
movq %rsi, 0x10(%r15)
testl %edi, %edi
sete %al
testq %rsi, %rsi
sete %cl
movq %r15, %rdx
addq $0x18, %rdx
movq %rdx, 0x18(%r15)
movq %rdx, 0x20(%r15)
movb $0x0, 0x8(%r15)
cmpl $0x14, %ebp
sete 0x9(%r15)
movq 0x60(%rsp), %rdx
movq %rdx, 0x28(%r15)
movq 0x58(%rsp), %rdx
movq %rdx, 0x30(%r15)
orb %al, %cl
jne 0x31473
movq 0x10(%r15), %rdi
movq 0x10(%rsp), %rdx
callq 0xe5b0
movq %r15, 0x30(%rbx)
jmp 0x312a9
|
js_array_buffer_constructor3:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, r9d
mov r12, r8
mov r13, rdi
mov r15, [rdi+18h]
test r8, r8
jz short loc_3128E
cmp [rsp+48h+arg_0], 0
jz short loc_3128E
lea rax, js_array_buffer_free
cmp [rsp+48h+arg_8], rax
jz short loc_3128E
cmp [rsp+48h+arg_18], 0
jnz short loc_3128E
lea rsi, aResizableArray; "resizable ArrayBuffers not supported fo"...
xor ebx, ebx
mov rdi, r13
xor eax, eax
call JS_ThrowInternalError
push 6
pop r14
jmp loc_31311
loc_3128E:
mov [rsp+48h+var_38], rcx
mov rdi, r13
mov ecx, ebp
call js_create_from_ctor
mov rbx, rax
mov r14, rdx
cmp r14d, 6
jnz short loc_312BB
loc_312A9:
mov rax, 0FFFFFFFF00000000h
mov rcx, rbx
and rcx, rax
jmp short loc_31313
loc_312BB:
cmp [rsp+48h+var_38], 7FFFFFFFh
jbe short loc_312CF
lea rsi, aInvalidArrayBu_0; "invalid array buffer length"
jmp short loc_312E5
loc_312CF:
test r12, r12
jz short loc_3132A
cmp qword ptr [r12], 7FFFFFFFh
jbe short loc_3132A
lea rsi, aInvalidMaxArra; "invalid max array buffer length"
loc_312E5:
xor r15d, r15d
mov rdi, r13
xor eax, eax
call JS_ThrowRangeError
loc_312F2:
mov rdi, r13
mov rsi, rbx
mov rdx, r14
call JS_FreeValue
mov rdi, r13
mov rsi, r15
call js_free
push 6
pop r14
xor ebx, ebx
loc_31311:
xor ecx, ecx
loc_31313:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3132A:
push 38h ; '8'
pop rsi
mov rdi, r13
call js_malloc
test rax, rax
jz short loc_31351
mov rdx, [rsp+48h+var_38]
mov [rsp+48h+var_40], rax
mov [rax], edx
test r12, r12
jz short loc_31356
mov eax, [r12]
jmp short loc_31359
loc_31351:
xor r15d, r15d
jmp short loc_312F2
loc_31356:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_31359:
mov rsi, [rsp+48h+arg_0]
mov edi, [rsp+48h+arg_18]
mov rcx, [rsp+48h+var_40]
mov [rcx+4], eax
test edi, edi
jz loc_313FC
cmp ebp, 14h
jnz short loc_313D0
mov rax, [r15+160h]
test rax, rax
jz short loc_313D0
mov ecx, edx
test r12, r12
jz short loc_31391
mov rcx, [r12]
mov rdx, rcx
loc_31391:
mov r12, rdx
mov rdi, [r15+178h]
cmp ecx, 2
push 1
pop rsi
cmovge esi, ecx
call rax
mov r15, [rsp+48h+var_40]
mov [r15+10h], rax
test rax, rax
jz loc_312F2
mov rdi, rax
xor esi, esi
mov rdx, r12
call _memset
mov rsi, [rsp+48h+arg_0]
mov edi, [rsp+48h+arg_18]
jmp short loc_31428
loc_313D0:
cmp edx, 1
mov esi, edx
adc esi, 0
mov rdi, r13
call js_mallocz
mov edi, [rsp+48h+arg_18]
mov rsi, [rsp+48h+arg_0]
mov r15, [rsp+48h+var_40]
mov [r15+10h], rax
test rax, rax
jnz short loc_31428
jmp loc_312F2
loc_313FC:
cmp ebp, 14h
jnz short loc_3141F
mov rax, [r15+170h]
test rax, rax
jz short loc_3141F
mov rdi, [r15+178h]
call rax
mov edi, [rsp+48h+arg_18]
mov rsi, [rsp+48h+arg_0]
loc_3141F:
mov r15, [rsp+48h+var_40]
mov [r15+10h], rsi
loc_31428:
test edi, edi
setz al
test rsi, rsi
setz cl
mov rdx, r15
add rdx, 18h
mov [r15+18h], rdx
mov [r15+20h], rdx
mov byte ptr [r15+8], 0
cmp ebp, 14h
setz byte ptr [r15+9]
mov rdx, [rsp+48h+arg_10]
mov [r15+28h], rdx
mov rdx, [rsp+48h+arg_8]
mov [r15+30h], rdx
or cl, al
jnz short loc_31473
mov rdi, [r15+10h]
mov rdx, [rsp+48h+var_38]
call _memcpy
loc_31473:
mov [rbx+30h], r15
jmp loc_312A9
|
unsigned long long js_array_buffer_constructor3(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
int *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
long long a15,
long long ( *a16)(),
long long a17,
int a18)
{
int v18; // ebp
_QWORD *v21; // r15
unsigned long long v22; // rbx
long long v23; // rdx
long long v24; // rcx
long long v25; // r8
long long v26; // r9
__m128 v27; // xmm4
__m128 v28; // xmm5
long long v29; // r14
unsigned long long v30; // rcx
const char *v31; // rsi
long long v32; // r15
_DWORD *v34; // rax
unsigned long long v35; // rdx
int v36; // eax
long long v37; // rsi
int v38; // edi
long long ( *v39)(_QWORD, long long); // rax
unsigned long long v40; // rcx
unsigned long long v41; // r12
long long v42; // rsi
long long v43; // rax
long long v44; // rax
void ( *v45)(_QWORD, long long); // rax
char v46; // [rsp+0h] [rbp-48h]
_DWORD *v47; // [rsp+8h] [rbp-40h]
v18 = a6;
v21 = *(_QWORD **)(a1 + 24);
if ( a5 && a15 && a16 != js_array_buffer_free && !a18 )
{
LODWORD(v22) = 0;
JS_ThrowInternalError(
a1,
(long long)"resizable ArrayBuffers not supported for externally managed buffers",
a3,
a4,
(long long)a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v46);
LABEL_15:
v30 = 0LL;
return v30 | (unsigned int)v22;
}
v22 = js_create_from_ctor(a1, a2, a3, a6);
v29 = v23;
if ( (_DWORD)v23 != 6 )
{
if ( a4 <= 0x7FFFFFFF )
{
if ( !a5 || *(_QWORD *)a5 <= 0x7FFFFFFFuLL )
{
v34 = (_DWORD *)js_malloc(a1, 56LL);
if ( v34 )
{
v35 = a4;
v47 = v34;
*v34 = a4;
if ( a5 )
v36 = *a5;
else
v36 = -1;
v37 = a15;
v38 = a18;
v47[1] = v36;
if ( a18 )
{
if ( v18 == 20 && (v39 = (long long ( *)(_QWORD, long long))v21[44]) != 0LL )
{
LODWORD(v40) = a4;
if ( a5 )
{
v40 = *(_QWORD *)a5;
v35 = *(_QWORD *)a5;
}
v41 = v35;
v42 = 1LL;
if ( (int)v40 >= 2 )
v42 = (unsigned int)v40;
v43 = v39(v21[47], v42);
v32 = (long long)v47;
*((_QWORD *)v47 + 2) = v43;
if ( !v43 )
goto LABEL_14;
memset(v43, 0LL, v41);
v37 = a15;
v38 = a18;
}
else
{
v44 = js_mallocz(a1, ((_DWORD)a4 == 0) + (unsigned int)a4);
v38 = a18;
v37 = a15;
v32 = (long long)v47;
*((_QWORD *)v47 + 2) = v44;
if ( !v44 )
goto LABEL_14;
}
}
else
{
if ( v18 == 20 )
{
v45 = (void ( *)(_QWORD, long long))v21[46];
if ( v45 )
{
v45(v21[47], a15);
v38 = 0;
v37 = a15;
}
}
v32 = (long long)v47;
*((_QWORD *)v47 + 2) = v37;
}
*(_QWORD *)(v32 + 24) = v32 + 24;
*(_QWORD *)(v32 + 32) = v32 + 24;
*(_BYTE *)(v32 + 8) = 0;
*(_BYTE *)(v32 + 9) = v18 == 20;
*(_QWORD *)(v32 + 40) = a17;
*(_QWORD *)(v32 + 48) = a16;
if ( v38 != 0 && v37 != 0 )
memcpy(*(_QWORD *)(v32 + 16), v37, a4);
*(_QWORD *)(v22 + 48) = v32;
goto LABEL_7;
}
v32 = 0LL;
LABEL_14:
JS_FreeValue(a1, v22, v29);
js_free(a1, v32);
LODWORD(v22) = 0;
goto LABEL_15;
}
v31 = "invalid max array buffer length";
}
else
{
v31 = "invalid array buffer length";
}
v32 = 0LL;
JS_ThrowRangeError(a1, (long long)v31, v23, v24, v25, v26, a7, a8, a9, a10, v27, v28, a13, a14, v46);
goto LABEL_14;
}
LABEL_7:
v30 = v22 & 0xFFFFFFFF00000000LL;
return v30 | (unsigned int)v22;
}
|
js_array_buffer_constructor3:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,R9D
MOV R12,R8
MOV R13,RDI
MOV R15,qword ptr [RDI + 0x18]
TEST R8,R8
JZ 0x0013128e
CMP qword ptr [RSP + 0x50],0x0
JZ 0x0013128e
LEA RAX,[0x1314c9]
CMP qword ptr [RSP + 0x58],RAX
JZ 0x0013128e
CMP dword ptr [RSP + 0x68],0x0
JNZ 0x0013128e
LEA RSI,[0x187bbb]
XOR EBX,EBX
MOV RDI,R13
XOR EAX,EAX
CALL 0x0011bbf5
PUSH 0x6
POP R14
JMP 0x00131311
LAB_0013128e:
MOV qword ptr [RSP + 0x10],RCX
MOV RDI,R13
MOV ECX,EBP
CALL 0x0012f8de
MOV RBX,RAX
MOV R14,RDX
CMP R14D,0x6
JNZ 0x001312bb
LAB_001312a9:
MOV RAX,-0x100000000
MOV RCX,RBX
AND RCX,RAX
JMP 0x00131313
LAB_001312bb:
CMP qword ptr [RSP + 0x10],0x7fffffff
JBE 0x001312cf
LEA RSI,[0x187bff]
JMP 0x001312e5
LAB_001312cf:
TEST R12,R12
JZ 0x0013132a
CMP qword ptr [R12],0x7fffffff
JBE 0x0013132a
LEA RSI,[0x187c1b]
LAB_001312e5:
XOR R15D,R15D
MOV RDI,R13
XOR EAX,EAX
CALL 0x0011a137
LAB_001312f2:
MOV RDI,R13
MOV RSI,RBX
MOV RDX,R14
CALL 0x001174a2
MOV RDI,R13
MOV RSI,R15
CALL 0x001166f2
PUSH 0x6
POP R14
XOR EBX,EBX
LAB_00131311:
XOR ECX,ECX
LAB_00131313:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013132a:
PUSH 0x38
POP RSI
MOV RDI,R13
CALL 0x00116698
TEST RAX,RAX
JZ 0x00131351
MOV RDX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RAX],EDX
TEST R12,R12
JZ 0x00131356
MOV EAX,dword ptr [R12]
JMP 0x00131359
LAB_00131351:
XOR R15D,R15D
JMP 0x001312f2
LAB_00131356:
PUSH -0x1
POP RAX
LAB_00131359:
MOV RSI,qword ptr [RSP + 0x50]
MOV EDI,dword ptr [RSP + 0x68]
MOV RCX,qword ptr [RSP + 0x8]
MOV dword ptr [RCX + 0x4],EAX
TEST EDI,EDI
JZ 0x001313fc
CMP EBP,0x14
JNZ 0x001313d0
MOV RAX,qword ptr [R15 + 0x160]
TEST RAX,RAX
JZ 0x001313d0
MOV ECX,EDX
TEST R12,R12
JZ 0x00131391
MOV RCX,qword ptr [R12]
MOV RDX,RCX
LAB_00131391:
MOV R12,RDX
MOV RDI,qword ptr [R15 + 0x178]
CMP ECX,0x2
PUSH 0x1
POP RSI
CMOVGE ESI,ECX
CALL RAX
MOV R15,qword ptr [RSP + 0x8]
MOV qword ptr [R15 + 0x10],RAX
TEST RAX,RAX
JZ 0x001312f2
MOV RDI,RAX
XOR ESI,ESI
MOV RDX,R12
CALL 0x0010e350
MOV RSI,qword ptr [RSP + 0x50]
MOV EDI,dword ptr [RSP + 0x68]
JMP 0x00131428
LAB_001313d0:
CMP EDX,0x1
MOV ESI,EDX
ADC ESI,0x0
MOV RDI,R13
CALL 0x001166c5
MOV EDI,dword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x50]
MOV R15,qword ptr [RSP + 0x8]
MOV qword ptr [R15 + 0x10],RAX
TEST RAX,RAX
JNZ 0x00131428
JMP 0x001312f2
LAB_001313fc:
CMP EBP,0x14
JNZ 0x0013141f
MOV RAX,qword ptr [R15 + 0x170]
TEST RAX,RAX
JZ 0x0013141f
MOV RDI,qword ptr [R15 + 0x178]
CALL RAX
MOV EDI,dword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x50]
LAB_0013141f:
MOV R15,qword ptr [RSP + 0x8]
MOV qword ptr [R15 + 0x10],RSI
LAB_00131428:
TEST EDI,EDI
SETZ AL
TEST RSI,RSI
SETZ CL
MOV RDX,R15
ADD RDX,0x18
MOV qword ptr [R15 + 0x18],RDX
MOV qword ptr [R15 + 0x20],RDX
MOV byte ptr [R15 + 0x8],0x0
CMP EBP,0x14
SETZ byte ptr [R15 + 0x9]
MOV RDX,qword ptr [RSP + 0x60]
MOV qword ptr [R15 + 0x28],RDX
MOV RDX,qword ptr [RSP + 0x58]
MOV qword ptr [R15 + 0x30],RDX
OR CL,AL
JNZ 0x00131473
MOV RDI,qword ptr [R15 + 0x10]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0010e5b0
LAB_00131473:
MOV qword ptr [RBX + 0x30],R15
JMP 0x001312a9
|
int1 [16]
js_array_buffer_constructor3
(long param_1,int8 param_2,int8 param_3,ulong param_4,ulong *param_5,
int param_6,void *param_7,code *param_8,int8 param_9,int param_10)
{
int iVar1;
int *piVar2;
void *__s;
long lVar3;
ulong uVar4;
int iVar5;
ulong __n;
char *pcVar6;
int1 auVar7 [16];
int1 auVar8 [16];
lVar3 = *(long *)(param_1 + 0x18);
if ((((param_5 == (ulong *)0x0) || (param_7 == (void *)0x0)) || (param_8 == js_array_buffer_free))
|| (param_10 != 0)) {
auVar7 = js_create_from_ctor(param_1,param_2,param_3,param_6);
uVar4 = auVar7._0_8_;
if (auVar7._8_4_ == 6) {
LAB_001312a9:
uVar4 = uVar4 & 0xffffffff00000000;
goto LAB_00131313;
}
if (param_4 < 0x80000000) {
if ((param_5 != (ulong *)0x0) && (0x7fffffff < *param_5)) {
pcVar6 = "invalid max array buffer length";
goto LAB_001312e5;
}
piVar2 = (int *)js_malloc(param_1,0x38);
if (piVar2 == (int *)0x0) {
piVar2 = (int *)0x0;
goto LAB_001312f2;
}
iVar5 = (int)param_4;
*piVar2 = iVar5;
if (param_5 == (ulong *)0x0) {
iVar1 = -1;
}
else {
iVar1 = (int)*param_5;
}
piVar2[1] = iVar1;
if (param_10 == 0) {
if ((param_6 == 0x14) && (*(code **)(lVar3 + 0x170) != (code *)0x0)) {
(**(code **)(lVar3 + 0x170))(*(int8 *)(lVar3 + 0x178));
}
*(void **)(piVar2 + 4) = param_7;
LAB_00131428:
*(int **)(piVar2 + 6) = piVar2 + 6;
*(int **)(piVar2 + 8) = piVar2 + 6;
*(int1 *)(piVar2 + 2) = 0;
*(bool *)((long)piVar2 + 9) = param_6 == 0x14;
*(int8 *)(piVar2 + 10) = param_9;
*(code **)(piVar2 + 0xc) = param_8;
if (param_7 != (void *)0x0 && param_10 != 0) {
memcpy(*(void **)(piVar2 + 4),param_7,param_4);
}
*(int **)(uVar4 + 0x30) = piVar2;
goto LAB_001312a9;
}
if ((param_6 == 0x14) && (*(code **)(lVar3 + 0x160) != (code *)0x0)) {
__n = param_4;
if (param_5 != (ulong *)0x0) {
__n = *param_5;
}
__s = (void *)(**(code **)(lVar3 + 0x160))(*(int8 *)(lVar3 + 0x178));
*(void **)(piVar2 + 4) = __s;
if (__s != (void *)0x0) {
memset(__s,0,__n);
goto LAB_00131428;
}
}
else {
lVar3 = js_mallocz(param_1,iVar5 + (uint)(iVar5 == 0));
*(long *)(piVar2 + 4) = lVar3;
if (lVar3 != 0) goto LAB_00131428;
}
}
else {
pcVar6 = "invalid array buffer length";
LAB_001312e5:
piVar2 = (int *)0x0;
JS_ThrowRangeError(param_1,pcVar6);
}
LAB_001312f2:
JS_FreeValue(param_1,uVar4,auVar7._8_8_);
js_free(param_1,piVar2);
}
else {
JS_ThrowInternalError
(param_1,"resizable ArrayBuffers not supported for externally managed buffers");
}
auVar7 = ZEXT816(6) << 0x40;
uVar4 = 0;
LAB_00131313:
auVar8._0_8_ = auVar7._0_8_ & 0xffffffff | uVar4;
auVar8._8_8_ = auVar7._8_8_;
return auVar8;
}
|
|
66,458 |
js_array_buffer_constructor3
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_buffer_constructor3(JSContext *ctx,
JSValue new_target,
uint64_t len, uint64_t *max_len,
JSClassID class_id,
uint8_t *buf,
JSFreeArrayBufferDataFunc *free_func,
void *opaque, BOOL alloc_flag)
{
JSRuntime *rt = ctx->rt;
JSValue obj;
JSArrayBuffer *abuf = NULL;
uint64_t sab_alloc_len;
if (!alloc_flag && buf && max_len && free_func != js_array_buffer_free) {
// not observable from JS land, only through C API misuse;
// JS code cannot create externally managed buffers directly
return JS_ThrowInternalError(ctx,
"resizable ArrayBuffers not supported "
"for externally managed buffers");
}
obj = js_create_from_ctor(ctx, new_target, class_id);
if (JS_IsException(obj))
return obj;
/* XXX: we are currently limited to 2 GB */
if (len > INT32_MAX) {
JS_ThrowRangeError(ctx, "invalid array buffer length");
goto fail;
}
if (max_len && *max_len > INT32_MAX) {
JS_ThrowRangeError(ctx, "invalid max array buffer length");
goto fail;
}
abuf = js_malloc(ctx, sizeof(*abuf));
if (!abuf)
goto fail;
abuf->byte_length = len;
abuf->max_byte_length = max_len ? *max_len : -1;
if (alloc_flag) {
if (class_id == JS_CLASS_SHARED_ARRAY_BUFFER &&
rt->sab_funcs.sab_alloc) {
// TOOD(bnoordhuis) resizing backing memory for SABs atomically
// is hard so we cheat and allocate |maxByteLength| bytes upfront
sab_alloc_len = max_len ? *max_len : len;
abuf->data = rt->sab_funcs.sab_alloc(rt->sab_funcs.sab_opaque,
max_int(sab_alloc_len, 1));
if (!abuf->data)
goto fail;
memset(abuf->data, 0, sab_alloc_len);
} else {
/* the allocation must be done after the object creation */
abuf->data = js_mallocz(ctx, max_int(len, 1));
if (!abuf->data)
goto fail;
}
} else {
if (class_id == JS_CLASS_SHARED_ARRAY_BUFFER &&
rt->sab_funcs.sab_dup) {
rt->sab_funcs.sab_dup(rt->sab_funcs.sab_opaque, buf);
}
abuf->data = buf;
}
init_list_head(&abuf->array_list);
abuf->detached = FALSE;
abuf->shared = (class_id == JS_CLASS_SHARED_ARRAY_BUFFER);
abuf->opaque = opaque;
abuf->free_func = free_func;
if (alloc_flag && buf)
memcpy(abuf->data, buf, len);
JS_SetOpaqueInternal(obj, abuf);
return obj;
fail:
JS_FreeValue(ctx, obj);
js_free(ctx, abuf);
return JS_EXCEPTION;
}
|
O3
|
c
|
js_array_buffer_constructor3:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %r13
movq %rdi, %r15
movq 0x18(%rdi), %r12
testq %r8, %r8
je 0x3930e
cmpq $0x0, 0x50(%rsp)
je 0x3930e
leaq 0x2b4(%rip), %rax # 0x39596
cmpq %rax, 0x58(%rsp)
je 0x3930e
cmpl $0x0, 0x68(%rsp)
jne 0x3930e
leaq 0x6a934(%rip), %rsi # 0xa3c2b
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2227b
movl $0x6, %r14d
jmp 0x393aa
movq %rcx, 0x8(%rsp)
movq %r15, %rdi
movl %ebp, %ecx
callq 0x373f3
movq %rax, %rbx
movq %rdx, %r14
cmpl $0x6, %r14d
jne 0x3933b
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbx, %rcx
andq %rax, %rcx
jmp 0x393ac
cmpq $0x7fffffff, 0x8(%rsp) # imm = 0x7FFFFFFF
jbe 0x3934f
leaq 0x6a922(%rip), %rsi # 0xa3c6f
jmp 0x39369
testq %r13, %r13
je 0x393c3
cmpq $0x7fffffff, (%r13) # imm = 0x7FFFFFFF
jbe 0x393e7
leaq 0x6a922(%rip), %rsi # 0xa3c8b
xorl %r12d, %r12d
movq %r15, %rdi
xorl %eax, %eax
callq 0x205f0
cmpl $-0x9, %r14d
jb 0x39397
movq 0x18(%r15), %rdi
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %eax
jg 0x39397
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20d90
movq %r15, %rdi
movq %r12, %rsi
callq 0x1c845
movl $0x6, %r14d
xorl %ebx, %ebx
xorl %ecx, %ecx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %esi
movq %r15, %rdi
callq 0xed89
testq %rax, %rax
je 0x3948a
movq 0x8(%rsp), %rdx
movl %edx, (%rax)
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
jmp 0x39408
movl $0x38, %esi
movq %r15, %rdi
callq 0xed89
testq %rax, %rax
je 0x3948a
movq 0x8(%rsp), %rdx
movl %edx, (%rax)
movl (%r13), %ecx
movl %edx, %esi
movq %rax, 0x10(%rsp)
movl %ecx, 0x4(%rax)
movl 0x68(%rsp), %ecx
testl %ecx, %ecx
movq 0x50(%rsp), %r8
je 0x39492
cmpl $0x14, %ebp
jne 0x39520
movq 0x160(%r12), %rax
testq %rax, %rax
je 0x39520
testq %r13, %r13
je 0x39442
movq (%r13), %rdx
movq 0x178(%r12), %rdi
cmpl $0x2, %edx
movl $0x1, %esi
movq %rdx, %r13
cmovgel %edx, %esi
callq *%rax
movq 0x10(%rsp), %r12
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x39376
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0xe340
movq 0x8(%rsp), %rdx
movq 0x50(%rsp), %r8
movl 0x68(%rsp), %ecx
jmp 0x394c9
xorl %r12d, %r12d
jmp 0x39376
cmpl $0x14, %ebp
jne 0x394bf
movq 0x170(%r12), %rax
testq %rax, %rax
je 0x394bf
movq 0x178(%r12), %rdi
movq %r8, %rsi
callq *%rax
movl 0x68(%rsp), %ecx
movq 0x50(%rsp), %r8
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %r12
movq %r8, 0x10(%r12)
testl %ecx, %ecx
sete %al
testq %r8, %r8
sete %cl
leaq 0x18(%r12), %rsi
movq %rsi, 0x18(%r12)
movq %rsi, 0x20(%r12)
movb $0x0, 0x8(%r12)
cmpl $0x14, %ebp
sete 0x9(%r12)
movq 0x60(%rsp), %rsi
movq %rsi, 0x28(%r12)
movq 0x58(%rsp), %rsi
movq %rsi, 0x30(%r12)
orb %al, %cl
jne 0x39517
movq 0x10(%r12), %rdi
movq %r8, %rsi
callq 0xe5a0
movq %r12, 0x30(%rbx)
jmp 0x39329
cmpl $0x1, %esi
adcl $0x0, %esi
movq %r15, %rdi
callq 0xedb6
movl 0x68(%rsp), %ecx
movq 0x50(%rsp), %r8
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %r12
movq %rax, 0x10(%r12)
testq %rax, %rax
jne 0x394c9
jmp 0x39376
|
js_array_buffer_constructor3:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, r9d
mov r13, r8
mov r15, rdi
mov r12, [rdi+18h]
test r8, r8
jz short loc_3930E
cmp [rsp+48h+arg_0], 0
jz short loc_3930E
lea rax, js_array_buffer_free
cmp [rsp+48h+arg_8], rax
jz short loc_3930E
cmp [rsp+48h+arg_18], 0
jnz short loc_3930E
lea rsi, aResizableArray; "resizable ArrayBuffers not supported fo"...
xor ebx, ebx
mov rdi, r15
xor eax, eax
call JS_ThrowInternalError
mov r14d, 6
jmp loc_393AA
loc_3930E:
mov [rsp+48h+var_40], rcx
mov rdi, r15
mov ecx, ebp
call js_create_from_ctor
mov rbx, rax
mov r14, rdx
cmp r14d, 6
jnz short loc_3933B
loc_39329:
mov rax, 0FFFFFFFF00000000h
mov rcx, rbx
and rcx, rax
jmp short loc_393AC
loc_3933B:
cmp [rsp+48h+var_40], 7FFFFFFFh
jbe short loc_3934F
lea rsi, aInvalidArrayBu; "invalid array buffer length"
jmp short loc_39369
loc_3934F:
test r13, r13
jz short loc_393C3
cmp qword ptr [r13+0], 7FFFFFFFh
jbe loc_393E7
lea rsi, aInvalidMaxArra; "invalid max array buffer length"
loc_39369:
xor r12d, r12d
mov rdi, r15
xor eax, eax
call JS_ThrowRangeError
loc_39376:
cmp r14d, 0FFFFFFF7h
jb short loc_39397
mov rdi, [r15+18h]
mov eax, [rbx]
lea ecx, [rax-1]
mov [rbx], ecx
cmp eax, 1
jg short loc_39397
mov rsi, rbx
mov rdx, r14
call js_free_value_rt
loc_39397:
mov rdi, r15
mov rsi, r12
call js_free
mov r14d, 6
xor ebx, ebx
loc_393AA:
xor ecx, ecx
loc_393AC:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_393C3:
mov esi, 38h ; '8'
mov rdi, r15
call js_malloc
test rax, rax
jz loc_3948A
mov rdx, [rsp+48h+var_40]
mov [rax], edx
mov ecx, 0FFFFFFFFh
jmp short loc_39408
loc_393E7:
mov esi, 38h ; '8'
mov rdi, r15
call js_malloc
test rax, rax
jz loc_3948A
mov rdx, [rsp+48h+var_40]
mov [rax], edx
mov ecx, [r13+0]
loc_39408:
mov esi, edx
mov [rsp+48h+var_38], rax
mov [rax+4], ecx
mov ecx, [rsp+48h+arg_18]
test ecx, ecx
mov r8, [rsp+48h+arg_0]
jz short loc_39492
cmp ebp, 14h
jnz loc_39520
mov rax, [r12+160h]
test rax, rax
jz loc_39520
test r13, r13
jz short loc_39442
mov rdx, [r13+0]
loc_39442:
mov rdi, [r12+178h]
cmp edx, 2
mov esi, 1
mov r13, rdx
cmovge esi, edx
call rax
mov r12, [rsp+48h+var_38]
mov [r12+10h], rax
test rax, rax
jz loc_39376
mov rdi, rax
xor esi, esi
mov rdx, r13
call _memset
mov rdx, [rsp+48h+var_40]
mov r8, [rsp+48h+arg_0]
mov ecx, [rsp+48h+arg_18]
jmp short loc_394C9
loc_3948A:
xor r12d, r12d
jmp loc_39376
loc_39492:
cmp ebp, 14h
jnz short loc_394BF
mov rax, [r12+170h]
test rax, rax
jz short loc_394BF
mov rdi, [r12+178h]
mov rsi, r8
call rax
mov ecx, [rsp+48h+arg_18]
mov r8, [rsp+48h+arg_0]
mov rdx, [rsp+48h+var_40]
loc_394BF:
mov r12, [rsp+48h+var_38]
mov [r12+10h], r8
loc_394C9:
test ecx, ecx
setz al
test r8, r8
setz cl
lea rsi, [r12+18h]
mov [r12+18h], rsi
mov [r12+20h], rsi
mov byte ptr [r12+8], 0
cmp ebp, 14h
setz byte ptr [r12+9]
mov rsi, [rsp+48h+arg_10]
mov [r12+28h], rsi
mov rsi, [rsp+48h+arg_8]
mov [r12+30h], rsi
or cl, al
jnz short loc_39517
mov rdi, [r12+10h]
mov rsi, r8
call _memcpy
loc_39517:
mov [rbx+30h], r12
jmp loc_39329
loc_39520:
cmp esi, 1
adc esi, 0
mov rdi, r15
call js_mallocz
mov ecx, [rsp+48h+arg_18]
mov r8, [rsp+48h+arg_0]
mov rdx, [rsp+48h+var_40]
mov r12, [rsp+48h+var_38]
mov [r12+10h], rax
test rax, rax
jnz loc_394C9
jmp loc_39376
|
unsigned long long js_array_buffer_constructor3(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
unsigned long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
long long a15,
long long ( *a16)(),
long long a17,
unsigned int a18)
{
int v18; // ebp
_QWORD *v21; // r12
unsigned long long v22; // rbx
long long v23; // rdx
long long v24; // rcx
long long v25; // r8
long long v26; // r9
__m128 v27; // xmm4
__m128 v28; // xmm5
long long v29; // r14
unsigned long long v30; // rcx
const char *v31; // rsi
long long v32; // r12
long long v33; // r8
long long v34; // r9
long long v35; // rdi
int v36; // eax
long long v37; // rcx
_DWORD *v39; // rax
unsigned long long v40; // rdx
int v41; // ecx
unsigned int v42; // ecx
long long ( *v43)(_QWORD, long long, unsigned long long, _QWORD, long long); // rax
long long v44; // rsi
unsigned long long v45; // r13
long long v46; // rax
void ( *v47)(_QWORD, long long); // rax
long long v48; // rax
char v49; // [rsp+0h] [rbp-48h]
_DWORD *v51; // [rsp+10h] [rbp-38h]
v18 = a6;
v21 = *(_QWORD **)(a1 + 24);
if ( a5 && a15 && a16 != js_array_buffer_free && !a18 )
{
LODWORD(v22) = 0;
JS_ThrowInternalError(
a1,
(long long)"resizable ArrayBuffers not supported for externally managed buffers",
a3,
a4,
(long long)a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v49);
LABEL_18:
v30 = 0LL;
return v30 | (unsigned int)v22;
}
v22 = js_create_from_ctor(a1, a2, a3, a6);
v29 = v23;
if ( (_DWORD)v23 != 6 )
{
if ( a4 > 0x7FFFFFFF )
{
v31 = "invalid array buffer length";
LABEL_13:
v32 = 0LL;
JS_ThrowRangeError(a1, (long long)v31, v23, v24, v25, v26, a7, a8, a9, a10, v27, v28, a13, a14, v49);
goto LABEL_14;
}
if ( a5 )
{
if ( *a5 > 0x7FFFFFFF )
{
v31 = "invalid max array buffer length";
goto LABEL_13;
}
v39 = (_DWORD *)js_malloc(a1, 56LL);
if ( v39 )
{
v40 = a4;
*v39 = a4;
v41 = *(_DWORD *)a5;
goto LABEL_24;
}
}
else
{
v39 = (_DWORD *)js_malloc(a1, 56LL);
if ( v39 )
{
v40 = a4;
*v39 = a4;
v41 = -1;
LABEL_24:
v51 = v39;
v39[1] = v41;
v42 = a18;
v33 = a15;
if ( !a18 )
{
if ( v18 == 20 )
{
v47 = (void ( *)(_QWORD, long long))v21[46];
if ( v47 )
{
v47(v21[47], a15);
v42 = 0;
v33 = a15;
v40 = a4;
}
}
v32 = (long long)v51;
*((_QWORD *)v51 + 2) = v33;
goto LABEL_38;
}
if ( v18 == 20 )
{
v43 = (long long ( *)(_QWORD, long long, unsigned long long, _QWORD, long long))v21[44];
if ( v43 )
{
if ( a5 )
v40 = *a5;
v44 = 1LL;
v45 = v40;
if ( (int)v40 >= 2 )
v44 = (unsigned int)v40;
v46 = v43(v21[47], v44, v40, a18, a15);
v32 = (long long)v51;
*((_QWORD *)v51 + 2) = v46;
if ( !v46 )
goto LABEL_14;
memset(v46, 0LL, v45);
v40 = a4;
v33 = a15;
v42 = a18;
LABEL_38:
*(_QWORD *)(v32 + 24) = v32 + 24;
*(_QWORD *)(v32 + 32) = v32 + 24;
*(_BYTE *)(v32 + 8) = 0;
*(_BYTE *)(v32 + 9) = v18 == 20;
*(_QWORD *)(v32 + 40) = a17;
*(_QWORD *)(v32 + 48) = a16;
if ( v42 != 0 && v33 != 0 )
memcpy(*(_QWORD *)(v32 + 16), v33, v40);
*(_QWORD *)(v22 + 48) = v32;
goto LABEL_7;
}
}
v48 = js_mallocz(a1, ((_DWORD)v40 == 0) + (unsigned int)v40);
v42 = a18;
v33 = a15;
v40 = a4;
v32 = (long long)v51;
*((_QWORD *)v51 + 2) = v48;
if ( v48 )
goto LABEL_38;
LABEL_14:
if ( (unsigned int)v29 >= 0xFFFFFFF7 )
{
v35 = *(_QWORD *)(a1 + 24);
v36 = *(_DWORD *)v22;
v37 = (unsigned int)(*(_DWORD *)v22 - 1);
*(_DWORD *)v22 = v37;
if ( v36 <= 1 )
js_free_value_rt(v35, (_QWORD *)v22, v29, v37, v33, v34);
}
js_free(a1, v32);
LODWORD(v22) = 0;
goto LABEL_18;
}
}
v32 = 0LL;
goto LABEL_14;
}
LABEL_7:
v30 = v22 & 0xFFFFFFFF00000000LL;
return v30 | (unsigned int)v22;
}
|
js_array_buffer_constructor3:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,R9D
MOV R13,R8
MOV R15,RDI
MOV R12,qword ptr [RDI + 0x18]
TEST R8,R8
JZ 0x0013930e
CMP qword ptr [RSP + 0x50],0x0
JZ 0x0013930e
LEA RAX,[0x139596]
CMP qword ptr [RSP + 0x58],RAX
JZ 0x0013930e
CMP dword ptr [RSP + 0x68],0x0
JNZ 0x0013930e
LEA RSI,[0x1a3c2b]
XOR EBX,EBX
MOV RDI,R15
XOR EAX,EAX
CALL 0x0012227b
MOV R14D,0x6
JMP 0x001393aa
LAB_0013930e:
MOV qword ptr [RSP + 0x8],RCX
MOV RDI,R15
MOV ECX,EBP
CALL 0x001373f3
MOV RBX,RAX
MOV R14,RDX
CMP R14D,0x6
JNZ 0x0013933b
LAB_00139329:
MOV RAX,-0x100000000
MOV RCX,RBX
AND RCX,RAX
JMP 0x001393ac
LAB_0013933b:
CMP qword ptr [RSP + 0x8],0x7fffffff
JBE 0x0013934f
LEA RSI,[0x1a3c6f]
JMP 0x00139369
LAB_0013934f:
TEST R13,R13
JZ 0x001393c3
CMP qword ptr [R13],0x7fffffff
JBE 0x001393e7
LEA RSI,[0x1a3c8b]
LAB_00139369:
XOR R12D,R12D
MOV RDI,R15
XOR EAX,EAX
CALL 0x001205f0
LAB_00139376:
CMP R14D,-0x9
JC 0x00139397
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX],ECX
CMP EAX,0x1
JG 0x00139397
MOV RSI,RBX
MOV RDX,R14
CALL 0x00120d90
LAB_00139397:
MOV RDI,R15
MOV RSI,R12
CALL 0x0011c845
MOV R14D,0x6
XOR EBX,EBX
LAB_001393aa:
XOR ECX,ECX
LAB_001393ac:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001393c3:
MOV ESI,0x38
MOV RDI,R15
CALL 0x0010ed89
TEST RAX,RAX
JZ 0x0013948a
MOV RDX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],EDX
MOV ECX,0xffffffff
JMP 0x00139408
LAB_001393e7:
MOV ESI,0x38
MOV RDI,R15
CALL 0x0010ed89
TEST RAX,RAX
JZ 0x0013948a
MOV RDX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],EDX
MOV ECX,dword ptr [R13]
LAB_00139408:
MOV ESI,EDX
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RAX + 0x4],ECX
MOV ECX,dword ptr [RSP + 0x68]
TEST ECX,ECX
MOV R8,qword ptr [RSP + 0x50]
JZ 0x00139492
CMP EBP,0x14
JNZ 0x00139520
MOV RAX,qword ptr [R12 + 0x160]
TEST RAX,RAX
JZ 0x00139520
TEST R13,R13
JZ 0x00139442
MOV RDX,qword ptr [R13]
LAB_00139442:
MOV RDI,qword ptr [R12 + 0x178]
CMP EDX,0x2
MOV ESI,0x1
MOV R13,RDX
CMOVGE ESI,EDX
CALL RAX
MOV R12,qword ptr [RSP + 0x10]
MOV qword ptr [R12 + 0x10],RAX
TEST RAX,RAX
JZ 0x00139376
MOV RDI,RAX
XOR ESI,ESI
MOV RDX,R13
CALL 0x0010e340
MOV RDX,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RSP + 0x50]
MOV ECX,dword ptr [RSP + 0x68]
JMP 0x001394c9
LAB_0013948a:
XOR R12D,R12D
JMP 0x00139376
LAB_00139492:
CMP EBP,0x14
JNZ 0x001394bf
MOV RAX,qword ptr [R12 + 0x170]
TEST RAX,RAX
JZ 0x001394bf
MOV RDI,qword ptr [R12 + 0x178]
MOV RSI,R8
CALL RAX
MOV ECX,dword ptr [RSP + 0x68]
MOV R8,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x8]
LAB_001394bf:
MOV R12,qword ptr [RSP + 0x10]
MOV qword ptr [R12 + 0x10],R8
LAB_001394c9:
TEST ECX,ECX
SETZ AL
TEST R8,R8
SETZ CL
LEA RSI,[R12 + 0x18]
MOV qword ptr [R12 + 0x18],RSI
MOV qword ptr [R12 + 0x20],RSI
MOV byte ptr [R12 + 0x8],0x0
CMP EBP,0x14
SETZ byte ptr [R12 + 0x9]
MOV RSI,qword ptr [RSP + 0x60]
MOV qword ptr [R12 + 0x28],RSI
MOV RSI,qword ptr [RSP + 0x58]
MOV qword ptr [R12 + 0x30],RSI
OR CL,AL
JNZ 0x00139517
MOV RDI,qword ptr [R12 + 0x10]
MOV RSI,R8
CALL 0x0010e5a0
LAB_00139517:
MOV qword ptr [RBX + 0x30],R12
JMP 0x00139329
LAB_00139520:
CMP ESI,0x1
ADC ESI,0x0
MOV RDI,R15
CALL 0x0010edb6
MOV ECX,dword ptr [RSP + 0x68]
MOV R8,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x8]
MOV R12,qword ptr [RSP + 0x10]
MOV qword ptr [R12 + 0x10],RAX
TEST RAX,RAX
JNZ 0x001394c9
JMP 0x00139376
|
int1 [16]
js_array_buffer_constructor3
(long param_1,int8 param_2,int8 param_3,ulong param_4,ulong *param_5,
int param_6,void *param_7,code *param_8,int8 param_9,int param_10)
{
int8 uVar1;
int *piVar2;
int *piVar3;
void *__s;
long lVar4;
int iVar5;
ulong uVar6;
int iVar7;
char *pcVar8;
int1 auVar9 [16];
int1 auVar10 [16];
lVar4 = *(long *)(param_1 + 0x18);
if ((((param_5 == (ulong *)0x0) || (param_7 == (void *)0x0)) || (param_8 == js_array_buffer_free))
|| (param_10 != 0)) {
auVar9 = js_create_from_ctor(param_1,param_2,param_3,param_6);
piVar2 = auVar9._0_8_;
if (auVar9._8_4_ == 6) {
LAB_00139329:
uVar6 = (ulong)piVar2 & 0xffffffff00000000;
goto LAB_001393ac;
}
if (param_4 < 0x80000000) {
iVar7 = (int)param_4;
if (param_5 == (ulong *)0x0) {
piVar3 = (int *)js_malloc(param_1,0x38);
if (piVar3 != (int *)0x0) {
*piVar3 = iVar7;
iVar5 = -1;
goto LAB_00139408;
}
LAB_0013948a:
piVar3 = (int *)0x0;
goto LAB_00139376;
}
if (0x7fffffff < *param_5) {
pcVar8 = "invalid max array buffer length";
goto LAB_00139369;
}
piVar3 = (int *)js_malloc(param_1,0x38);
if (piVar3 == (int *)0x0) goto LAB_0013948a;
*piVar3 = iVar7;
iVar5 = (int)*param_5;
LAB_00139408:
piVar3[1] = iVar5;
if (param_10 == 0) {
if ((param_6 == 0x14) && (*(code **)(lVar4 + 0x170) != (code *)0x0)) {
(**(code **)(lVar4 + 0x170))(*(int8 *)(lVar4 + 0x178),param_7);
}
*(void **)(piVar3 + 4) = param_7;
LAB_001394c9:
*(int **)(piVar3 + 6) = piVar3 + 6;
*(int **)(piVar3 + 8) = piVar3 + 6;
*(int1 *)(piVar3 + 2) = 0;
*(bool *)((long)piVar3 + 9) = param_6 == 0x14;
*(int8 *)(piVar3 + 10) = param_9;
*(code **)(piVar3 + 0xc) = param_8;
if (param_7 != (void *)0x0 && param_10 != 0) {
memcpy(*(void **)(piVar3 + 4),param_7,param_4);
}
*(int **)(piVar2 + 0xc) = piVar3;
goto LAB_00139329;
}
if ((param_6 == 0x14) && (*(code **)(lVar4 + 0x160) != (code *)0x0)) {
uVar6 = param_4;
if (param_5 != (ulong *)0x0) {
uVar6 = *param_5;
}
__s = (void *)(**(code **)(lVar4 + 0x160))(*(int8 *)(lVar4 + 0x178));
*(void **)(piVar3 + 4) = __s;
if (__s != (void *)0x0) {
memset(__s,0,uVar6);
goto LAB_001394c9;
}
}
else {
lVar4 = js_mallocz(param_1,iVar7 + (uint)(iVar7 == 0));
*(long *)(piVar3 + 4) = lVar4;
if (lVar4 != 0) goto LAB_001394c9;
}
}
else {
pcVar8 = "invalid array buffer length";
LAB_00139369:
piVar3 = (int *)0x0;
JS_ThrowRangeError(param_1,pcVar8);
}
LAB_00139376:
if (0xfffffff6 < auVar9._8_4_) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar7 = *piVar2;
*piVar2 = iVar7 + -1;
if (iVar7 < 2) {
js_free_value_rt(uVar1,piVar2,auVar9._8_8_);
}
}
js_free(param_1,piVar3);
}
else {
JS_ThrowInternalError
(param_1,"resizable ArrayBuffers not supported for externally managed buffers");
}
auVar9 = ZEXT816(6) << 0x40;
uVar6 = 0;
LAB_001393ac:
auVar10._0_8_ = auVar9._0_8_ & 0xffffffff | uVar6;
auVar10._8_8_ = auVar9._8_8_;
return auVar10;
}
|
|
66,459 |
google::protobuf::DescriptorProto::IsInitialized() const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc
|
bool DescriptorProto::IsInitialized() const {
if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.field_))
return false;
if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.nested_type_))
return false;
if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.enum_type_))
return false;
if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.extension_range_))
return false;
if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.extension_))
return false;
if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.oneof_decl_))
return false;
if (_internal_has_options()) {
if (!_impl_.options_->IsInitialized()) return false;
}
return true;
}
|
O0
|
cpp
|
google::protobuf::DescriptorProto::IsInitialized() const:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x10, %rdi
addq $0x8, %rdi
callq 0xd5730
testb $0x1, %al
jne 0xb0ecd
movb $0x0, 0x17(%rsp)
jmp 0xb0f93
movq (%rsp), %rdi
addq $0x10, %rdi
addq $0x20, %rdi
callq 0xd5610
testb $0x1, %al
jne 0xb0eec
movb $0x0, 0x17(%rsp)
jmp 0xb0f93
movq (%rsp), %rdi
addq $0x10, %rdi
addq $0x38, %rdi
callq 0xd5670
testb $0x1, %al
jne 0xb0f0b
movb $0x0, 0x17(%rsp)
jmp 0xb0f93
movq (%rsp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
callq 0xd6860
testb $0x1, %al
jne 0xb0f27
movb $0x0, 0x17(%rsp)
jmp 0xb0f93
movq (%rsp), %rdi
addq $0x10, %rdi
addq $0x68, %rdi
callq 0xd5730
testb $0x1, %al
jne 0xb0f43
movb $0x0, 0x17(%rsp)
jmp 0xb0f93
movq (%rsp), %rdi
addq $0x10, %rdi
addq $0x80, %rdi
callq 0xd68c0
testb $0x1, %al
jne 0xb0f62
movb $0x0, 0x17(%rsp)
jmp 0xb0f93
movq (%rsp), %rdi
callq 0x87620
testb $0x1, %al
jne 0xb0f71
jmp 0xb0f8e
movq (%rsp), %rax
movq 0xe0(%rax), %rdi
callq 0xb0fa0
testb $0x1, %al
jne 0xb0f8c
movb $0x0, 0x17(%rsp)
jmp 0xb0f93
jmp 0xb0f8e
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
|
_ZNK6google8protobuf15DescriptorProto13IsInitializedEv:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
mov rdi, [rsp+18h+var_10]
mov [rsp+18h+var_18], rdi
add rdi, 10h
add rdi, 8
call _ZN6google8protobuf8internal17AllAreInitializedINS0_20FieldDescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE; google::protobuf::internal::AllAreInitialized<google::protobuf::FieldDescriptorProto>(google::protobuf::RepeatedPtrField<google::protobuf::FieldDescriptorProto> const&)
test al, 1
jnz short loc_B0ECD
mov [rsp+18h+var_1], 0
jmp loc_B0F93
loc_B0ECD:
mov rdi, [rsp+18h+var_18]
add rdi, 10h
add rdi, 20h ; ' '
call _ZN6google8protobuf8internal17AllAreInitializedINS0_15DescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE; google::protobuf::internal::AllAreInitialized<google::protobuf::DescriptorProto>(google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto> const&)
test al, 1
jnz short loc_B0EEC
mov [rsp+18h+var_1], 0
jmp loc_B0F93
loc_B0EEC:
mov rdi, [rsp+18h+var_18]
add rdi, 10h
add rdi, 38h ; '8'
call _ZN6google8protobuf8internal17AllAreInitializedINS0_19EnumDescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE; google::protobuf::internal::AllAreInitialized<google::protobuf::EnumDescriptorProto>(google::protobuf::RepeatedPtrField<google::protobuf::EnumDescriptorProto> const&)
test al, 1
jnz short loc_B0F0B
mov [rsp+18h+var_1], 0
jmp loc_B0F93
loc_B0F0B:
mov rdi, [rsp+18h+var_18]
add rdi, 10h
add rdi, 50h ; 'P'
call _ZN6google8protobuf8internal17AllAreInitializedINS0_30DescriptorProto_ExtensionRangeEEEbRKNS0_16RepeatedPtrFieldIT_EE; google::protobuf::internal::AllAreInitialized<google::protobuf::DescriptorProto_ExtensionRange>(google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto_ExtensionRange> const&)
test al, 1
jnz short loc_B0F27
mov [rsp+18h+var_1], 0
jmp short loc_B0F93
loc_B0F27:
mov rdi, [rsp+18h+var_18]
add rdi, 10h
add rdi, 68h ; 'h'
call _ZN6google8protobuf8internal17AllAreInitializedINS0_20FieldDescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE; google::protobuf::internal::AllAreInitialized<google::protobuf::FieldDescriptorProto>(google::protobuf::RepeatedPtrField<google::protobuf::FieldDescriptorProto> const&)
test al, 1
jnz short loc_B0F43
mov [rsp+18h+var_1], 0
jmp short loc_B0F93
loc_B0F43:
mov rdi, [rsp+18h+var_18]
add rdi, 10h
add rdi, 80h
call _ZN6google8protobuf8internal17AllAreInitializedINS0_20OneofDescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE; google::protobuf::internal::AllAreInitialized<google::protobuf::OneofDescriptorProto>(google::protobuf::RepeatedPtrField<google::protobuf::OneofDescriptorProto> const&)
test al, 1
jnz short loc_B0F62
mov [rsp+18h+var_1], 0
jmp short loc_B0F93
loc_B0F62:
mov rdi, [rsp+18h+var_18]; this
call _ZNK6google8protobuf15DescriptorProto21_internal_has_optionsEv; google::protobuf::DescriptorProto::_internal_has_options(void)
test al, 1
jnz short loc_B0F71
jmp short loc_B0F8E
loc_B0F71:
mov rax, [rsp+18h+var_18]
mov rdi, [rax+0E0h]; this
call _ZNK6google8protobuf14MessageOptions13IsInitializedEv; google::protobuf::MessageOptions::IsInitialized(void)
test al, 1
jnz short loc_B0F8C
mov [rsp+18h+var_1], 0
jmp short loc_B0F93
loc_B0F8C:
jmp short $+2
loc_B0F8E:
mov [rsp+18h+var_1], 1
loc_B0F93:
mov al, [rsp+18h+var_1]
and al, 1
add rsp, 18h
retn
|
bool google::protobuf::DescriptorProto::IsInitialized(google::protobuf::MessageOptions **this)
{
if ( (google::protobuf::internal::AllAreInitialized<google::protobuf::FieldDescriptorProto>(this + 3) & 1) == 0 )
return 0;
if ( (google::protobuf::internal::AllAreInitialized<google::protobuf::DescriptorProto>(this + 6) & 1) == 0 )
return 0;
if ( (google::protobuf::internal::AllAreInitialized<google::protobuf::EnumDescriptorProto>(this + 9) & 1) == 0 )
return 0;
if ( (google::protobuf::internal::AllAreInitialized<google::protobuf::DescriptorProto_ExtensionRange>(this + 12) & 1) == 0 )
return 0;
if ( (google::protobuf::internal::AllAreInitialized<google::protobuf::FieldDescriptorProto>(this + 15) & 1) == 0 )
return 0;
if ( (google::protobuf::internal::AllAreInitialized<google::protobuf::OneofDescriptorProto>(this + 18) & 1) != 0 )
return !google::protobuf::DescriptorProto::_internal_has_options((google::protobuf::DescriptorProto *)this)
|| (google::protobuf::MessageOptions::IsInitialized(this[28]) & 1) != 0;
return 0;
}
|
IsInitialized:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RDI
ADD RDI,0x10
ADD RDI,0x8
CALL 0x001d5730
TEST AL,0x1
JNZ 0x001b0ecd
MOV byte ptr [RSP + 0x17],0x0
JMP 0x001b0f93
LAB_001b0ecd:
MOV RDI,qword ptr [RSP]
ADD RDI,0x10
ADD RDI,0x20
CALL 0x001d5610
TEST AL,0x1
JNZ 0x001b0eec
MOV byte ptr [RSP + 0x17],0x0
JMP 0x001b0f93
LAB_001b0eec:
MOV RDI,qword ptr [RSP]
ADD RDI,0x10
ADD RDI,0x38
CALL 0x001d5670
TEST AL,0x1
JNZ 0x001b0f0b
MOV byte ptr [RSP + 0x17],0x0
JMP 0x001b0f93
LAB_001b0f0b:
MOV RDI,qword ptr [RSP]
ADD RDI,0x10
ADD RDI,0x50
CALL 0x001d6860
TEST AL,0x1
JNZ 0x001b0f27
MOV byte ptr [RSP + 0x17],0x0
JMP 0x001b0f93
LAB_001b0f27:
MOV RDI,qword ptr [RSP]
ADD RDI,0x10
ADD RDI,0x68
CALL 0x001d5730
TEST AL,0x1
JNZ 0x001b0f43
MOV byte ptr [RSP + 0x17],0x0
JMP 0x001b0f93
LAB_001b0f43:
MOV RDI,qword ptr [RSP]
ADD RDI,0x10
ADD RDI,0x80
CALL 0x001d68c0
TEST AL,0x1
JNZ 0x001b0f62
MOV byte ptr [RSP + 0x17],0x0
JMP 0x001b0f93
LAB_001b0f62:
MOV RDI,qword ptr [RSP]
CALL 0x00187620
TEST AL,0x1
JNZ 0x001b0f71
JMP 0x001b0f8e
LAB_001b0f71:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0xe0]
CALL 0x001b0fa0
TEST AL,0x1
JNZ 0x001b0f8c
MOV byte ptr [RSP + 0x17],0x0
JMP 0x001b0f93
LAB_001b0f8c:
JMP 0x001b0f8e
LAB_001b0f8e:
MOV byte ptr [RSP + 0x17],0x1
LAB_001b0f93:
MOV AL,byte ptr [RSP + 0x17]
AND AL,0x1
ADD RSP,0x18
RET
|
/* google::protobuf::DescriptorProto::IsInitialized() const */
int1 __thiscall google::protobuf::DescriptorProto::IsInitialized(DescriptorProto *this)
{
bool bVar1;
ulong uVar2;
int1 local_1;
bVar1 = internal::AllAreInitialized<google::protobuf::FieldDescriptorProto>
((RepeatedPtrField *)(this + 0x18));
if (bVar1) {
bVar1 = internal::AllAreInitialized<google::protobuf::DescriptorProto>
((RepeatedPtrField *)(this + 0x30));
if (bVar1) {
bVar1 = internal::AllAreInitialized<google::protobuf::EnumDescriptorProto>
((RepeatedPtrField *)(this + 0x48));
if (bVar1) {
bVar1 = internal::AllAreInitialized<google::protobuf::DescriptorProto_ExtensionRange>
((RepeatedPtrField *)(this + 0x60));
if (bVar1) {
bVar1 = internal::AllAreInitialized<google::protobuf::FieldDescriptorProto>
((RepeatedPtrField *)(this + 0x78));
if (bVar1) {
bVar1 = internal::AllAreInitialized<google::protobuf::OneofDescriptorProto>
((RepeatedPtrField *)(this + 0x90));
if (bVar1) {
uVar2 = _internal_has_options(this);
if (((uVar2 & 1) == 0) ||
(uVar2 = MessageOptions::IsInitialized(*(MessageOptions **)(this + 0xe0)),
(uVar2 & 1) != 0)) {
local_1 = 1;
}
else {
local_1 = 0;
}
}
else {
local_1 = 0;
}
}
else {
local_1 = 0;
}
}
else {
local_1 = 0;
}
}
else {
local_1 = 0;
}
}
else {
local_1 = 0;
}
}
else {
local_1 = 0;
}
return local_1;
}
|
|
66,460 |
my_wc_mb_sjis
|
eloqsql/strings/ctype-sjis.c
|
static int
my_wc_mb_sjis(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if ((int) wc < 0x80) /* ASCII: [U+0000..U+007F] -> [00-7F] */
{
/*
This branch is for performance purposes on ASCII range,
to avoid using unicode_to_cp932[]: about 10% improvement.
*/
if (wc == 0x5c)
{
/*
Special case when converting from Unicode to SJIS:
U+005C -> [81][5F] FULL WIDTH REVERSE SOLIDUS
*/
code= MB2(0x815F);
goto mb;
}
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= (uchar) wc; /* ASCII */
return 1;
}
if (wc > 0xFFFF ||
!(code= unicode_to_sjis[wc])) /* Bad Unicode code point */
return MY_CS_ILUNI;
if (code <= 0xFF)
{
/* JIS-X-0201 HALF WIDTH KATAKANA [U+FF61..U+FF9F] -> [A1..DF] */
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= code;
return 1;
}
mb:
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, code); /* JIS-X-0208 */
return 2;
}
|
O3
|
c
|
my_wc_mb_sjis:
pushq %rbp
movq %rsp, %rbp
cmpl $0x7f, %esi
jg 0x3a01e
movl $0x815f, %edi # imm = 0x815F
cmpq $0x5c, %rsi
je 0x3a054
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x3a06e
movb %sil, (%rdx)
jmp 0x3a04d
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0x3a06e
leaq 0x1894e0(%rip), %rdi # 0x1c3510
movzwl (%rdi,%rsi,2), %edi
testl %edi, %edi
je 0x3a06e
cmpl $0xff, %edi
ja 0x3a054
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x3a06e
movb %dil, (%rdx)
movl $0x1, %eax
jmp 0x3a06e
leaq 0x2(%rdx), %rsi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rsi
ja 0x3a06e
rolw $0x8, %di
movw %di, (%rdx)
movl $0x2, %eax
popq %rbp
retq
|
my_wc_mb_sjis:
push rbp
mov rbp, rsp
cmp esi, 7Fh
jg short loc_3A01E
mov edi, 815Fh
cmp rsi, 5Ch ; '\'
jz short loc_3A054
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_3A06E
mov [rdx], sil
jmp short loc_3A04D
loc_3A01E:
xor eax, eax
cmp rsi, 0FFFFh
ja short loc_3A06E
lea rdi, unicode_to_sjis
movzx edi, word ptr [rdi+rsi*2]
test edi, edi
jz short loc_3A06E
cmp edi, 0FFh
ja short loc_3A054
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_3A06E
mov [rdx], dil
loc_3A04D:
mov eax, 1
jmp short loc_3A06E
loc_3A054:
lea rsi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rsi, rcx
ja short loc_3A06E
rol di, 8
mov [rdx], di
mov eax, 2
loc_3A06E:
pop rbp
retn
|
long long my_wc_mb_sjis(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
unsigned int v4; // edi
long long result; // rax
if ( (int)a2 <= 127 )
{
LOWORD(v4) = -32417;
if ( a2 != 92 )
{
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
*a3 = a2;
return 1LL;
}
LABEL_11:
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*(_WORD *)a3 = __ROL2__(v4, 8);
return 2LL;
}
return result;
}
result = 0LL;
if ( a2 <= 0xFFFF )
{
v4 = unicode_to_sjis[a2];
if ( unicode_to_sjis[a2] )
{
if ( v4 <= 0xFF )
{
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
*a3 = v4;
return 1LL;
}
goto LABEL_11;
}
}
return result;
}
|
my_wc_mb_sjis:
PUSH RBP
MOV RBP,RSP
CMP ESI,0x7f
JG 0x0013a01e
MOV EDI,0x815f
CMP RSI,0x5c
JZ 0x0013a054
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0013a06e
MOV byte ptr [RDX],SIL
JMP 0x0013a04d
LAB_0013a01e:
XOR EAX,EAX
CMP RSI,0xffff
JA 0x0013a06e
LEA RDI,[0x2c3510]
MOVZX EDI,word ptr [RDI + RSI*0x2]
TEST EDI,EDI
JZ 0x0013a06e
CMP EDI,0xff
JA 0x0013a054
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0013a06e
MOV byte ptr [RDX],DIL
LAB_0013a04d:
MOV EAX,0x1
JMP 0x0013a06e
LAB_0013a054:
LEA RSI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RSI,RCX
JA 0x0013a06e
ROL DI,0x8
MOV word ptr [RDX],DI
MOV EAX,0x2
LAB_0013a06e:
POP RBP
RET
|
int8 my_wc_mb_sjis(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
if ((int)param_2 < 0x80) {
uVar1 = 0x815f;
if (param_2 == 0x5c) {
LAB_0013a054:
if (param_4 < param_3 + 1) {
return 0xffffff9a;
}
*param_3 = uVar1 << 8 | uVar1 >> 8;
return 2;
}
if (param_4 <= param_3) {
return 0xffffff9b;
}
*(char *)param_3 = (char)param_2;
}
else {
if (0xffff < param_2) {
return 0;
}
uVar1 = *(ushort *)(unicode_to_sjis + param_2 * 2);
if (uVar1 == 0) {
return 0;
}
if (0xff < uVar1) goto LAB_0013a054;
if (param_4 <= param_3) {
return 0xffffff9b;
}
*(char *)param_3 = (char)uVar1;
}
return 1;
}
|
|
66,461 |
copy_uca_collation
|
eloqsql/mysys/charset.c
|
static void
copy_uca_collation(struct charset_info_st *to, CHARSET_INFO *from,
CHARSET_INFO *loaded)
{
to->cset= from->cset;
to->coll= from->coll;
/*
Single-level UCA collation have strnxfrm_multiple=8.
In case of a multi-level UCA collation we use strnxfrm_multiply=4.
That means MY_COLLATION_HANDLER::strnfrmlen() will request the caller
to allocate a buffer smaller size for each level, for performance purpose,
and to fit longer VARCHARs to @@max_sort_length.
This makes filesort produce non-precise order for some rare Unicode
characters that produce more than 4 weights (long expansions).
UCA requires 2 bytes per weight multiplied by the number of levels.
In case of a 2-level collation, each character requires 4*2=8 bytes.
Therefore, the longest VARCHAR that fits into the default @@max_sort_length
is 1024/8=VARCHAR(128). With strnxfrm_multiply==8, only VARCHAR(64)
would fit.
Note, the built-in collation utf8_thai_520_w2 also uses strnxfrm_multiply=4,
for the same purpose.
TODO: we could add a new LDML syntax to choose strxfrm_multiply value.
*/
to->strxfrm_multiply= loaded->levels_for_order > 1 ?
4 : from->strxfrm_multiply;
to->min_sort_char= from->min_sort_char;
to->max_sort_char= from->max_sort_char;
to->mbminlen= from->mbminlen;
to->mbmaxlen= from->mbmaxlen;
to->caseup_multiply= from->caseup_multiply;
to->casedn_multiply= from->casedn_multiply;
to->state|= MY_CS_AVAILABLE | MY_CS_LOADED |
MY_CS_STRNXFRM | MY_CS_UNICODE;
}
|
O3
|
c
|
copy_uca_collation:
pushq %rbp
movq %rsp, %rbp
movq 0xb8(%rsi), %rax
movq %rax, 0xb8(%rdi)
movq 0xc0(%rsi), %rax
movq %rax, 0xc0(%rdi)
movl $0x4, %eax
cmpb $0x1, 0xb2(%rdx)
ja 0x2eb7f
movl 0x90(%rsi), %eax
movl %eax, 0x90(%rdi)
movq 0xa0(%rsi), %rax
movq %rax, 0xa0(%rdi)
movq 0xa8(%rsi), %rax
movq %rax, 0xa8(%rdi)
movl 0x98(%rsi), %eax
movl %eax, 0x98(%rdi)
movl 0x9c(%rsi), %eax
movl %eax, 0x9c(%rdi)
movb 0x94(%rsi), %al
movb %al, 0x94(%rdi)
movb 0x95(%rsi), %al
movb %al, 0x95(%rdi)
orl $0x2c8, 0xc(%rdi) # imm = 0x2C8
popq %rbp
retq
|
copy_uca_collation:
push rbp
mov rbp, rsp
mov rax, [rsi+0B8h]
mov [rdi+0B8h], rax
mov rax, [rsi+0C0h]
mov [rdi+0C0h], rax
mov eax, 4
cmp byte ptr [rdx+0B2h], 1
ja short loc_2EB7F
mov eax, [rsi+90h]
loc_2EB7F:
mov [rdi+90h], eax
mov rax, [rsi+0A0h]
mov [rdi+0A0h], rax
mov rax, [rsi+0A8h]
mov [rdi+0A8h], rax
mov eax, [rsi+98h]
mov [rdi+98h], eax
mov eax, [rsi+9Ch]
mov [rdi+9Ch], eax
mov al, [rsi+94h]
mov [rdi+94h], al
mov al, [rsi+95h]
mov [rdi+95h], al
or dword ptr [rdi+0Ch], 2C8h
pop rbp
retn
|
char copy_uca_collation(long long a1, long long a2, long long a3)
{
int v3; // eax
char result; // al
*(_QWORD *)(a1 + 184) = *(_QWORD *)(a2 + 184);
*(_QWORD *)(a1 + 192) = *(_QWORD *)(a2 + 192);
v3 = 4;
if ( *(_BYTE *)(a3 + 178) <= 1u )
v3 = *(_DWORD *)(a2 + 144);
*(_DWORD *)(a1 + 144) = v3;
*(_QWORD *)(a1 + 160) = *(_QWORD *)(a2 + 160);
*(_QWORD *)(a1 + 168) = *(_QWORD *)(a2 + 168);
*(_DWORD *)(a1 + 152) = *(_DWORD *)(a2 + 152);
*(_DWORD *)(a1 + 156) = *(_DWORD *)(a2 + 156);
*(_BYTE *)(a1 + 148) = *(_BYTE *)(a2 + 148);
result = *(_BYTE *)(a2 + 149);
*(_BYTE *)(a1 + 149) = result;
*(_DWORD *)(a1 + 12) |= 0x2C8u;
return result;
}
|
copy_uca_collation:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RSI + 0xb8]
MOV qword ptr [RDI + 0xb8],RAX
MOV RAX,qword ptr [RSI + 0xc0]
MOV qword ptr [RDI + 0xc0],RAX
MOV EAX,0x4
CMP byte ptr [RDX + 0xb2],0x1
JA 0x0012eb7f
MOV EAX,dword ptr [RSI + 0x90]
LAB_0012eb7f:
MOV dword ptr [RDI + 0x90],EAX
MOV RAX,qword ptr [RSI + 0xa0]
MOV qword ptr [RDI + 0xa0],RAX
MOV RAX,qword ptr [RSI + 0xa8]
MOV qword ptr [RDI + 0xa8],RAX
MOV EAX,dword ptr [RSI + 0x98]
MOV dword ptr [RDI + 0x98],EAX
MOV EAX,dword ptr [RSI + 0x9c]
MOV dword ptr [RDI + 0x9c],EAX
MOV AL,byte ptr [RSI + 0x94]
MOV byte ptr [RDI + 0x94],AL
MOV AL,byte ptr [RSI + 0x95]
MOV byte ptr [RDI + 0x95],AL
OR dword ptr [RDI + 0xc],0x2c8
POP RBP
RET
|
void copy_uca_collation(long param_1,long param_2,long param_3)
{
int4 uVar1;
*(int8 *)(param_1 + 0xb8) = *(int8 *)(param_2 + 0xb8);
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_2 + 0xc0);
uVar1 = 4;
if (*(byte *)(param_3 + 0xb2) < 2) {
uVar1 = *(int4 *)(param_2 + 0x90);
}
*(int4 *)(param_1 + 0x90) = uVar1;
*(int8 *)(param_1 + 0xa0) = *(int8 *)(param_2 + 0xa0);
*(int8 *)(param_1 + 0xa8) = *(int8 *)(param_2 + 0xa8);
*(int4 *)(param_1 + 0x98) = *(int4 *)(param_2 + 0x98);
*(int4 *)(param_1 + 0x9c) = *(int4 *)(param_2 + 0x9c);
*(int1 *)(param_1 + 0x94) = *(int1 *)(param_2 + 0x94);
*(int1 *)(param_1 + 0x95) = *(int1 *)(param_2 + 0x95);
*(uint *)(param_1 + 0xc) = *(uint *)(param_1 + 0xc) | 0x2c8;
return;
}
|
|
66,462 |
mi_enlarge_root
|
eloqsql/storage/myisam/mi_write.c
|
int _mi_enlarge_root(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
my_off_t *root)
{
uint t_length,nod_flag;
MI_KEY_PARAM s_temp;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("_mi_enlarge_root");
nod_flag= (*root != HA_OFFSET_ERROR) ? share->base.key_reflength : 0;
_mi_kpointer(info,info->buff+2,*root); /* if nod */
t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar*) 0,
(uchar*) 0, (uchar*) 0, key,&s_temp);
mi_putint(info->buff,t_length+2+nod_flag,nod_flag);
(*keyinfo->store_key)(keyinfo,info->buff+2+nod_flag,&s_temp);
info->buff_used=info->page_changed=1; /* info->buff is used */
if ((*root= _mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR ||
_mi_write_keypage(info,keyinfo,*root,DFLT_INIT_HITS,info->buff))
DBUG_RETURN(-1);
DBUG_RETURN(0);
}
|
O3
|
c
|
mi_enlarge_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, -0x30(%rbp)
movq (%rcx), %rdx
cmpq $-0x1, %rdx
je 0x8875b
movq (%r14), %rax
movl 0x17c(%rax), %r13d
jmp 0x8875e
xorl %r13d, %r13d
movq 0x100(%r14), %rsi
addq $0x2, %rsi
movq %r14, %rdi
callq 0x85129
leaq -0x70(%rbp), %rax
movq %rax, (%rsp)
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq *0x50(%rbx)
xorl %ecx, %ecx
testl %r13d, %r13d
setne %cl
shll $0xf, %ecx
leal (%rax,%r13), %edx
addl %r13d, %eax
addl $0x2, %eax
leal 0x2(%rcx,%rdx), %ecx
movq 0x100(%r14), %rdx
movb %al, 0x1(%rdx)
movq 0x100(%r14), %rax
movb %ch, (%rax)
movq 0x100(%r14), %rax
movl %r13d, %ecx
leaq (%rax,%rcx), %rsi
addq $0x2, %rsi
movq %rbx, %rdi
leaq -0x70(%rbp), %rdx
callq *0x58(%rbx)
movw $0x101, 0x33c(%r14) # imm = 0x101
movq %r14, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq 0x83ea2
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
cmpq $-0x1, %rax
je 0x8881f
movq 0x100(%r14), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl $0x3, %ecx
callq 0x83cf0
negl %eax
sbbl %r12d, %r12d
jmp 0x88825
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_mi_enlarge_root:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov [rbp+var_30], rcx
mov rdx, [rcx]
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz short loc_8875B
mov rax, [r14]
mov r13d, [rax+17Ch]
jmp short loc_8875E
loc_8875B:
xor r13d, r13d
loc_8875E:
mov rsi, [r14+100h]
add rsi, 2
mov rdi, r14
call _mi_kpointer
lea rax, [rbp+var_70]
mov [rsp+80h+var_80], rax
xor r12d, r12d
mov rdi, rbx
mov esi, r13d
xor edx, edx
xor ecx, ecx
xor r8d, r8d
mov r9, r15
call qword ptr [rbx+50h]
xor ecx, ecx
test r13d, r13d
setnz cl
shl ecx, 0Fh
lea edx, [rax+r13]
add eax, r13d
add eax, 2
lea ecx, [rcx+rdx+2]
mov rdx, [r14+100h]
mov [rdx+1], al
mov rax, [r14+100h]
mov [rax], ch
mov rax, [r14+100h]
mov ecx, r13d
lea rsi, [rax+rcx]
add rsi, 2
mov rdi, rbx
lea rdx, [rbp+var_70]
call qword ptr [rbx+58h]
mov word ptr [r14+33Ch], 101h
mov rdi, r14
mov rsi, rbx
mov edx, 3
call _mi_new
mov rcx, [rbp+var_30]
mov [rcx], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_8881F
mov r8, [r14+100h]
mov rdi, r14
mov rsi, rbx
mov rdx, rax
mov ecx, 3
call _mi_write_keypage
neg eax
sbb r12d, r12d
jmp short loc_88825
loc_8881F:
mov r12d, 0FFFFFFFFh
loc_88825:
mov eax, r12d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mi_enlarge_root(long long a1, long long a2, long long a3, unsigned long long *a4)
{
unsigned int v5; // r13d
__int16 v6; // ax
unsigned long long v7; // rax
_BYTE v10[64]; // [rsp+10h] [rbp-70h] BYREF
unsigned long long *v11; // [rsp+50h] [rbp-30h]
v11 = a4;
if ( *a4 == -1LL )
v5 = 0;
else
v5 = *(_DWORD *)(*(_QWORD *)a1 + 380LL);
mi_kpointer(a1, (_BYTE *)(*(_QWORD *)(a1 + 256) + 2LL), *a4);
v6 = (*(long long ( **)(long long, _QWORD, _QWORD, _QWORD, _QWORD, long long, _BYTE *))(a2 + 80))(
a2,
v5,
0LL,
0LL,
0LL,
a3,
v10);
*(_BYTE *)(*(_QWORD *)(a1 + 256) + 1LL) = v5 + v6 + 2;
**(_BYTE **)(a1 + 256) = (unsigned __int16)(((v5 != 0) << 15) + v6 + v5 + 2) >> 8;
(*(void ( **)(long long, long long, _BYTE *))(a2 + 88))(a2, *(_QWORD *)(a1 + 256) + v5 + 2LL, v10);
*(_WORD *)(a1 + 828) = 257;
v7 = mi_new((_QWORD *)a1, a2);
*v11 = v7;
if ( v7 == -1LL )
return (unsigned int)-1;
else
return (unsigned int)-((unsigned int)mi_write_keypage((long long *)a1, a2, v7, 3u, *(_BYTE **)(a1 + 256)) != 0);
}
|
_mi_enlarge_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV qword ptr [RBP + -0x30],RCX
MOV RDX,qword ptr [RCX]
CMP RDX,-0x1
JZ 0x0018875b
MOV RAX,qword ptr [R14]
MOV R13D,dword ptr [RAX + 0x17c]
JMP 0x0018875e
LAB_0018875b:
XOR R13D,R13D
LAB_0018875e:
MOV RSI,qword ptr [R14 + 0x100]
ADD RSI,0x2
MOV RDI,R14
CALL 0x00185129
LEA RAX,[RBP + -0x70]
MOV qword ptr [RSP],RAX
XOR R12D,R12D
MOV RDI,RBX
MOV ESI,R13D
XOR EDX,EDX
XOR ECX,ECX
XOR R8D,R8D
MOV R9,R15
CALL qword ptr [RBX + 0x50]
XOR ECX,ECX
TEST R13D,R13D
SETNZ CL
SHL ECX,0xf
LEA EDX,[RAX + R13*0x1]
ADD EAX,R13D
ADD EAX,0x2
LEA ECX,[RCX + RDX*0x1 + 0x2]
MOV RDX,qword ptr [R14 + 0x100]
MOV byte ptr [RDX + 0x1],AL
MOV RAX,qword ptr [R14 + 0x100]
MOV byte ptr [RAX],CH
MOV RAX,qword ptr [R14 + 0x100]
MOV ECX,R13D
LEA RSI,[RAX + RCX*0x1]
ADD RSI,0x2
MOV RDI,RBX
LEA RDX,[RBP + -0x70]
CALL qword ptr [RBX + 0x58]
MOV word ptr [R14 + 0x33c],0x101
MOV RDI,R14
MOV RSI,RBX
MOV EDX,0x3
CALL 0x00183ea2
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RCX],RAX
CMP RAX,-0x1
JZ 0x0018881f
MOV R8,qword ptr [R14 + 0x100]
MOV RDI,R14
MOV RSI,RBX
MOV RDX,RAX
MOV ECX,0x3
CALL 0x00183cf0
NEG EAX
SBB R12D,R12D
JMP 0x00188825
LAB_0018881f:
MOV R12D,0xffffffff
LAB_00188825:
MOV EAX,R12D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int _mi_enlarge_root(long *param_1,long param_2,int8 param_3,long *param_4)
{
int iVar1;
long lVar2;
ulong uVar3;
int1 local_78 [64];
long *local_38;
if (*param_4 == -1) {
uVar3 = 0;
}
else {
uVar3 = (ulong)*(uint *)(*param_1 + 0x17c);
}
local_38 = param_4;
_mi_kpointer(param_1,param_1[0x20] + 2);
iVar1 = (**(code **)(param_2 + 0x50))(param_2,uVar3,0,0,0,param_3,local_78);
*(char *)(param_1[0x20] + 1) = (char)iVar1 + (char)uVar3 + '\x02';
*(char *)param_1[0x20] = (char)((uint)((int)uVar3 != 0) * 0x8000 + 2 + iVar1 + (int)uVar3 >> 8);
(**(code **)(param_2 + 0x58))(param_2,param_1[0x20] + uVar3 + 2,local_78);
*(int2 *)((long)param_1 + 0x33c) = 0x101;
lVar2 = _mi_new(param_1,param_2,3);
*local_38 = lVar2;
if (lVar2 == -1) {
iVar1 = -1;
}
else {
iVar1 = _mi_write_keypage(param_1,param_2,lVar2,3,param_1[0x20]);
iVar1 = -(uint)(iVar1 != 0);
}
return iVar1;
}
|
|
66,463 |
js_c_function_data_call
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_c_function_data_call(JSContext *ctx, JSValue func_obj,
JSValue this_val,
int argc, JSValue *argv, int flags)
{
JSCFunctionDataRecord *s = JS_GetOpaque(func_obj, JS_CLASS_C_FUNCTION_DATA);
JSValue *arg_buf;
int i;
/* XXX: could add the function on the stack for debug */
if (unlikely(argc < s->length)) {
arg_buf = alloca(sizeof(arg_buf[0]) * s->length);
for(i = 0; i < argc; i++)
arg_buf[i] = argv[i];
for(i = argc; i < s->length; i++)
arg_buf[i] = JS_UNDEFINED;
} else {
arg_buf = argv;
}
return s->func(ctx, this_val, argc, arg_buf, s->magic, s->data);
}
|
O0
|
c
|
js_c_function_data_call:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x28(%rbp)
movq %rdi, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xf, %edx
callq 0x3e640
movq %rax, -0x48(%rbp)
movl -0x3c(%rbp), %eax
movq -0x48(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
setl %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x291f1
movq -0x48(%rbp), %rax
movzbl 0x8(%rax), %eax
shll $0x4, %eax
movl %eax, %ecx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x291a2
movq -0x50(%rbp), %rax
movslq -0x54(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x10(%rbp), %rcx
movslq -0x54(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x29163
movl -0x3c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x48(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x291ef
movq -0x50(%rbp), %rax
movslq -0x54(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, -0x68(%rbp)
movq $0x3, -0x60(%rbp)
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x291a8
jmp 0x291f9
movq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %r11
movq (%r11), %rax
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %ecx
movq -0x50(%rbp), %r8
movzwl 0xa(%r11), %r9d
addq $0x10, %r11
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
subq $0x10, %rsp
movq %rsp, %r10
movq %r11, (%r10)
callq *%rax
addq $0x10, %rsp
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
js_c_function_data_call:
push rbp
mov rbp, rsp
sub rsp, 70h
mov eax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_20], rsi
mov [rbp+var_18], rdx
mov [rbp+var_30], rcx
mov [rbp+var_28], r8
mov [rbp+var_38], rdi
mov [rbp+var_3C], r9d
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_18]
mov edx, 0Fh
call JS_GetOpaque
mov [rbp+var_48], rax
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_48]
movzx ecx, byte ptr [rcx+8]
cmp eax, ecx
setl al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_291F1
mov rax, [rbp+var_48]
movzx eax, byte ptr [rax+8]
shl eax, 4
mov ecx, eax
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_50], rax
mov [rbp+var_54], 0
loc_29163:
mov eax, [rbp+var_54]
cmp eax, [rbp+var_3C]
jge short loc_291A2
mov rax, [rbp+var_50]
movsxd rcx, [rbp+var_54]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+arg_0]
movsxd rdx, [rbp+var_54]
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov eax, [rbp+var_54]
add eax, 1
mov [rbp+var_54], eax
jmp short loc_29163
loc_291A2:
mov eax, [rbp+var_3C]
mov [rbp+var_54], eax
loc_291A8:
mov eax, [rbp+var_54]
mov rcx, [rbp+var_48]
movzx ecx, byte ptr [rcx+8]
cmp eax, ecx
jge short loc_291EF
mov rax, [rbp+var_50]
movsxd rcx, [rbp+var_54]
shl rcx, 4
add rax, rcx
mov dword ptr [rbp+var_68], 0
mov [rbp+var_60], 3
mov rcx, [rbp+var_68]
mov [rax], rcx
mov rcx, [rbp+var_60]
mov [rax+8], rcx
mov eax, [rbp+var_54]
add eax, 1
mov [rbp+var_54], eax
jmp short loc_291A8
loc_291EF:
jmp short loc_291F9
loc_291F1:
mov rax, [rbp+arg_0]
mov [rbp+var_50], rax
loc_291F9:
mov r11, [rbp+var_48]
mov rax, [r11]
mov rdi, [rbp+var_38]
mov ecx, [rbp+var_3C]
mov r8, [rbp+var_50]
movzx r9d, word ptr [r11+0Ah]
add r11, 10h
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_28]
sub rsp, 10h
mov r10, rsp
mov [r10], r11
call rax
add rsp, 10h
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
mov rsp, rbp
pop rbp
retn
|
long long js_c_function_data_call(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6,
long long *a7)
{
long long *v7; // rax
long long *v8; // rcx
long long *v9; // rax
long long v11; // [rsp+0h] [rbp-70h] BYREF
long long v12; // [rsp+8h] [rbp-68h]
long long v13; // [rsp+10h] [rbp-60h]
int i; // [rsp+1Ch] [rbp-54h]
long long *v15; // [rsp+20h] [rbp-50h]
long long Opaque; // [rsp+28h] [rbp-48h]
int v17; // [rsp+34h] [rbp-3Ch]
long long v18; // [rsp+38h] [rbp-38h]
long long v19; // [rsp+40h] [rbp-30h]
long long v20; // [rsp+48h] [rbp-28h]
long long v21; // [rsp+50h] [rbp-20h]
long long v22; // [rsp+58h] [rbp-18h]
v21 = a2;
v22 = a3;
v19 = a4;
v20 = a5;
v18 = a1;
v17 = a6;
Opaque = JS_GetOpaque(a2, a3, 15LL);
if ( v17 >= *(unsigned __int8 *)(Opaque + 8) )
{
v15 = a7;
}
else
{
v15 = &v11 - 2 * (unsigned int)*(unsigned __int8 *)(Opaque + 8);
for ( i = 0; i < v17; ++i )
{
v7 = &v15[2 * i];
v8 = &a7[2 * i];
*v7 = *v8;
v7[1] = v8[1];
}
for ( i = v17; i < *(unsigned __int8 *)(Opaque + 8); ++i )
{
v9 = &v15[2 * i];
LODWORD(v12) = 0;
v13 = 3LL;
*v9 = v12;
v9[1] = v13;
}
}
return (*(long long ( **)(long long, long long, long long, _QWORD, long long *, _QWORD, long long))Opaque)(
v18,
v19,
v20,
(unsigned int)v17,
v15,
*(unsigned __int16 *)(Opaque + 10),
Opaque + 16);
}
|
js_c_function_data_call:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV EAX,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],R9D
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0xf
CALL 0x0013e640
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x48]
MOVZX ECX,byte ptr [RCX + 0x8]
CMP EAX,ECX
SETL AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001291f1
MOV RAX,qword ptr [RBP + -0x48]
MOVZX EAX,byte ptr [RAX + 0x8]
SHL EAX,0x4
MOV ECX,EAX
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x50],RAX
MOV dword ptr [RBP + -0x54],0x0
LAB_00129163:
MOV EAX,dword ptr [RBP + -0x54]
CMP EAX,dword ptr [RBP + -0x3c]
JGE 0x001291a2
MOV RAX,qword ptr [RBP + -0x50]
MOVSXD RCX,dword ptr [RBP + -0x54]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + 0x10]
MOVSXD RDX,dword ptr [RBP + -0x54]
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x00129163
LAB_001291a2:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x54],EAX
LAB_001291a8:
MOV EAX,dword ptr [RBP + -0x54]
MOV RCX,qword ptr [RBP + -0x48]
MOVZX ECX,byte ptr [RCX + 0x8]
CMP EAX,ECX
JGE 0x001291ef
MOV RAX,qword ptr [RBP + -0x50]
MOVSXD RCX,dword ptr [RBP + -0x54]
SHL RCX,0x4
ADD RAX,RCX
MOV dword ptr [RBP + -0x68],0x0
MOV qword ptr [RBP + -0x60],0x3
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x001291a8
LAB_001291ef:
JMP 0x001291f9
LAB_001291f1:
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x50],RAX
LAB_001291f9:
MOV R11,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [R11]
MOV RDI,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x3c]
MOV R8,qword ptr [RBP + -0x50]
MOVZX R9D,word ptr [R11 + 0xa]
ADD R11,0x10
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x28]
SUB RSP,0x10
MOV R10,RSP
MOV qword ptr [R10],R11
CALL RAX
ADD RSP,0x10
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
MOV RSP,RBP
POP RBP
RET
|
int1 [16]
js_c_function_data_call
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int param_6,long *param_7)
{
int2 uVar1;
code *pcVar2;
int1 auVar3 [16];
long *plVar4;
int iVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
long *plVar9;
long lStack_78;
int4 local_70;
uint uStack_6c;
int8 local_68;
int local_5c;
long *local_58;
int8 *local_50;
int local_44;
int8 local_40;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
plVar9 = &lStack_78;
local_44 = param_6;
local_40 = param_1;
local_38 = param_4;
local_30 = param_5;
local_28 = param_2;
local_20 = param_3;
local_50 = (int8 *)JS_GetOpaque(param_2,param_3,0xf);
uVar8 = local_30;
uVar7 = local_38;
uVar6 = local_40;
iVar5 = local_44;
if (local_44 < (int)(uint)*(byte *)(local_50 + 1)) {
plVar9 = &lStack_78 + (ulong)*(byte *)(local_50 + 1) * -2;
for (local_5c = 0; local_5c < local_44; local_5c = local_5c + 1) {
plVar9[(long)local_5c * 2] = param_7[(long)local_5c * 2];
(plVar9 + (long)local_5c * 2)[1] = (param_7 + (long)local_5c * 2)[1];
}
for (local_5c = local_44; local_58 = plVar9, local_5c < (int)(uint)*(byte *)(local_50 + 1);
local_5c = local_5c + 1) {
local_70 = 0;
local_68 = 3;
plVar9[(long)local_5c * 2] = (ulong)uStack_6c << 0x20;
(plVar9 + (long)local_5c * 2)[1] = 3;
}
}
else {
local_58 = param_7;
}
plVar4 = local_58;
pcVar2 = (code *)*local_50;
uVar1 = *(int2 *)((long)local_50 + 10);
plVar9[-2] = (long)(local_50 + 2);
plVar9[-3] = 0x129228;
auVar3 = (*pcVar2)(uVar6,uVar7,uVar8,iVar5,plVar4,uVar1);
return auVar3;
}
|
|
66,464 |
namelist_add
|
bluesky950520[P]quickjs/run-test262.c
|
void namelist_add(namelist_t *lp, const char *base, const char *name)
{
char *s;
s = compose_path(base, name);
if (!s)
goto fail;
if (lp->count == lp->size) {
size_t newsize = lp->size + (lp->size >> 1) + 4;
char **a = realloc(lp->array, sizeof(lp->array[0]) * newsize);
if (!a)
goto fail;
lp->array = a;
lp->size = newsize;
}
lp->array[lp->count] = s;
lp->count++;
return;
fail:
fatal(1, "allocation failure\n");
}
|
O0
|
c
|
namelist_add:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf0f0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xf5a4
jmp 0xf63f
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x30(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jne 0xf615
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x30(%rsp), %rcx
movl 0xc(%rcx), %ecx
sarl %ecx
addl %ecx, %eax
addl $0x4, %eax
cltq
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
shlq $0x3, %rsi
callq 0xe730
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xf5f9
jmp 0xf63f
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0xf652
movl $0x1, %edi
leaq 0xffa96(%rip), %rsi # 0x10f0e1
movb $0x0, %al
callq 0xec80
addq $0x38, %rsp
retq
nopw (%rax,%rax)
|
namelist_add:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_18], rdx
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_18]
call compose_path
mov [rsp+38h+var_20], rax
cmp [rsp+38h+var_20], 0
jnz short loc_F5A4
jmp loc_F63F
loc_F5A4:
mov rax, [rsp+38h+var_8]
mov eax, [rax+8]
mov rcx, [rsp+38h+var_8]
cmp eax, [rcx+0Ch]
jnz short loc_F615
mov rax, [rsp+38h+var_8]
mov eax, [rax+0Ch]
mov rcx, [rsp+38h+var_8]
mov ecx, [rcx+0Ch]
sar ecx, 1
add eax, ecx
add eax, 4
cdqe
mov [rsp+38h+var_28], rax
mov rax, [rsp+38h+var_8]
mov rdi, [rax]
mov rsi, [rsp+38h+var_28]
shl rsi, 3
call _realloc
mov [rsp+38h+var_30], rax
cmp [rsp+38h+var_30], 0
jnz short loc_F5F9
jmp short loc_F63F
loc_F5F9:
mov rcx, [rsp+38h+var_30]
mov rax, [rsp+38h+var_8]
mov [rax], rcx
mov rax, [rsp+38h+var_28]
mov ecx, eax
mov rax, [rsp+38h+var_8]
mov [rax+0Ch], ecx
loc_F615:
mov rdx, [rsp+38h+var_20]
mov rax, [rsp+38h+var_8]
mov rax, [rax]
mov rcx, [rsp+38h+var_8]
movsxd rcx, dword ptr [rcx+8]
mov [rax+rcx*8], rdx
mov rax, [rsp+38h+var_8]
mov ecx, [rax+8]
add ecx, 1
mov [rax+8], ecx
jmp short loc_F652
loc_F63F:
mov edi, 1
lea rsi, aAllocationFail; "allocation failure\n"
mov al, 0
call fatal
loc_F652:
add rsp, 38h
retn
|
long long namelist_add(long long a1, _BYTE *a2, _BYTE *a3)
{
long long result; // rax
long long v4; // [rsp+8h] [rbp-30h]
long long v5; // [rsp+10h] [rbp-28h]
long long v6; // [rsp+18h] [rbp-20h]
v6 = compose_path(a2, a3);
if ( !v6 )
goto LABEL_6;
if ( *(_DWORD *)(a1 + 8) == *(_DWORD *)(a1 + 12) )
{
v5 = (*(int *)(a1 + 12) >> 1) + *(_DWORD *)(a1 + 12) + 4;
v4 = realloc(*(_QWORD *)a1, 8 * v5);
if ( v4 )
{
*(_QWORD *)a1 = v4;
*(_DWORD *)(a1 + 12) = v5;
goto LABEL_5;
}
LABEL_6:
fatal(1u, (long long)"allocation failure\n");
}
LABEL_5:
*(_QWORD *)(*(_QWORD *)a1 + 8LL * *(int *)(a1 + 8)) = v6;
result = a1;
++*(_DWORD *)(a1 + 8);
return result;
}
|
namelist_add:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x0010f0f0
MOV qword ptr [RSP + 0x18],RAX
CMP qword ptr [RSP + 0x18],0x0
JNZ 0x0010f5a4
JMP 0x0010f63f
LAB_0010f5a4:
MOV RAX,qword ptr [RSP + 0x30]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RSP + 0x30]
CMP EAX,dword ptr [RCX + 0xc]
JNZ 0x0010f615
MOV RAX,qword ptr [RSP + 0x30]
MOV EAX,dword ptr [RAX + 0xc]
MOV RCX,qword ptr [RSP + 0x30]
MOV ECX,dword ptr [RCX + 0xc]
SAR ECX,0x1
ADD EAX,ECX
ADD EAX,0x4
CDQE
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x10]
SHL RSI,0x3
CALL 0x0010e730
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x0010f5f9
JMP 0x0010f63f
LAB_0010f5f9:
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x30]
MOV dword ptr [RAX + 0xc],ECX
LAB_0010f615:
MOV RDX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x30]
MOVSXD RCX,dword ptr [RCX + 0x8]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV ECX,dword ptr [RAX + 0x8]
ADD ECX,0x1
MOV dword ptr [RAX + 0x8],ECX
JMP 0x0010f652
LAB_0010f63f:
MOV EDI,0x1
LEA RSI,[0x20f0e1]
MOV AL,0x0
CALL 0x0010ec80
LAB_0010f652:
ADD RSP,0x38
RET
|
void namelist_add(long *param_1,int8 param_2,int8 param_3)
{
int iVar1;
long lVar2;
void *pvVar3;
lVar2 = compose_path(param_2,param_3);
if (lVar2 == 0) {
LAB_0010f63f:
fatal(1,"allocation failure\n");
}
else {
if ((int)param_1[1] == *(int *)((long)param_1 + 0xc)) {
iVar1 = *(int *)((long)param_1 + 0xc) + (*(int *)((long)param_1 + 0xc) >> 1) + 4;
pvVar3 = realloc((void *)*param_1,(long)iVar1 << 3);
if (pvVar3 == (void *)0x0) goto LAB_0010f63f;
*param_1 = (long)pvVar3;
*(int *)((long)param_1 + 0xc) = iVar1;
}
*(long *)(*param_1 + (long)(int)param_1[1] * 8) = lVar2;
*(int *)(param_1 + 1) = (int)param_1[1] + 1;
}
return;
}
|
|
66,465 |
my_thread_end
|
eloqsql/mysys/my_thr_init.c
|
void my_thread_end(void)
{
struct st_my_thread_var *tmp;
tmp= my_thread_var;
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_end(): tmp: %p pthread_self: %p thread_id: %ld\n",
tmp, pthread_self(), tmp ? (long) tmp->id : 0L);
#endif
/*
Remove the instrumentation for this thread.
This must be done before trashing st_my_thread_var,
because the LF_HASH depends on it.
*/
PSI_CALL_delete_current_thread();
/*
We need to disable DBUG early for this thread to ensure that the
the mutex calls doesn't enable it again
To this we have to both do DBUG_POP() and also reset THR_KEY_mysys
as the key is used by DBUG.
*/
DBUG_POP();
set_mysys_var(NULL);
if (tmp && tmp->init)
{
#if !defined(DBUG_OFF)
/* tmp->dbug is allocated inside DBUG library */
if (tmp->dbug)
{
free(tmp->dbug);
tmp->dbug=0;
}
#endif
my_thread_destory_thr_mutex(tmp);
/*
Decrement counter for number of running threads. We are using this
in my_thread_global_end() to wait until all threads have called
my_thread_end and thus freed all memory they have allocated in
my_thread_init() and DBUG_xxxx
*/
mysql_mutex_lock(&THR_LOCK_threads);
DBUG_ASSERT(THR_thread_count != 0);
if (--THR_thread_count == 0)
mysql_cond_signal(&THR_COND_threads);
mysql_mutex_unlock(&THR_LOCK_threads);
/* Trash variable so that we can detect false accesses to my_thread_var */
tmp->init= 2;
free(tmp);
}
}
|
O0
|
c
|
my_thread_end:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x38f00
movq %rax, -0x8(%rbp)
leaq 0x1a87c0(%rip), %rax # 0x1e1bb8
movq (%rax), %rax
callq *0x138(%rax)
jmp 0x39403
xorl %eax, %eax
movl %eax, %edi
callq 0x393b0
cmpq $0x0, -0x8(%rbp)
je 0x3948c
movq -0x8(%rbp), %rax
movsbl 0xe8(%rax), %eax
cmpl $0x0, %eax
je 0x3948c
movq -0x8(%rbp), %rdi
callq 0x38f20
leaq 0x368375(%rip), %rdi # 0x3a17a8
leaq 0x50cfb(%rip), %rsi # 0x8a135
movl $0x175, %edx # imm = 0x175
callq 0x39260
jmp 0x39446
leaq 0x36815b(%rip), %rax # 0x3a15a8
movl (%rax), %eax
addl $-0x1, %eax
leaq 0x36814f(%rip), %rcx # 0x3a15a8
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x3946c
leaq 0x3683d1(%rip), %rdi # 0x3a1838
callq 0x394a0
leaq 0x368335(%rip), %rdi # 0x3a17a8
callq 0x39350
movq -0x8(%rbp), %rax
movb $0x2, 0xe8(%rax)
movq -0x8(%rbp), %rdi
callq 0x253f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_thread_end:
push rbp
mov rbp, rsp
sub rsp, 10h
call _my_thread_var
mov [rbp+var_8], rax
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+138h]
jmp short $+2
loc_39403:
xor eax, eax
mov edi, eax
call set_mysys_var
cmp [rbp+var_8], 0
jz short loc_3948C
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax+0E8h]
cmp eax, 0
jz short loc_3948C
mov rdi, [rbp+var_8]
call my_thread_destory_thr_mutex
lea rdi, THR_LOCK_threads
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 175h
call inline_mysql_mutex_lock_1
jmp short $+2
loc_39446:
lea rax, THR_thread_count
mov eax, [rax]
add eax, 0FFFFFFFFh
lea rcx, THR_thread_count
mov [rcx], eax
cmp eax, 0
jnz short loc_3946C
lea rdi, THR_COND_threads
call inline_mysql_cond_signal_0
loc_3946C:
lea rdi, THR_LOCK_threads
call inline_mysql_mutex_unlock_1
mov rax, [rbp+var_8]
mov byte ptr [rax+0E8h], 2
mov rdi, [rbp+var_8]
call _free
loc_3948C:
add rsp, 10h
pop rbp
retn
|
long long my_thread_end()
{
long long result; // rax
long long v1; // [rsp+8h] [rbp-8h]
v1 = my_thread_var();
(*((void (**)(void))PSI_server + 39))();
result = set_mysys_var(0LL);
if ( v1 )
{
result = (unsigned int)*(char *)(v1 + 232);
if ( *(_BYTE *)(v1 + 232) )
{
my_thread_destory_thr_mutex(v1);
inline_mysql_mutex_lock_1(
(long long)&THR_LOCK_threads,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
0x175u);
if ( !--THR_thread_count )
inline_mysql_cond_signal_0(&THR_COND_threads);
inline_mysql_mutex_unlock_1((long long)&THR_LOCK_threads);
*(_BYTE *)(v1 + 232) = 2;
return free(v1);
}
}
return result;
}
|
my_thread_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CALL 0x00138f00
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[0x2e1bb8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x138]
JMP 0x00139403
LAB_00139403:
XOR EAX,EAX
MOV EDI,EAX
CALL 0x001393b0
CMP qword ptr [RBP + -0x8],0x0
JZ 0x0013948c
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + 0xe8]
CMP EAX,0x0
JZ 0x0013948c
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00138f20
LEA RDI,[0x4a17a8]
LEA RSI,[0x18a135]
MOV EDX,0x175
CALL 0x00139260
JMP 0x00139446
LAB_00139446:
LEA RAX,[0x4a15a8]
MOV EAX,dword ptr [RAX]
ADD EAX,-0x1
LEA RCX,[0x4a15a8]
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JNZ 0x0013946c
LEA RDI,[0x4a1838]
CALL 0x001394a0
LAB_0013946c:
LEA RDI,[0x4a17a8]
CALL 0x00139350
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xe8],0x2
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001253f0
LAB_0013948c:
ADD RSP,0x10
POP RBP
RET
|
void my_thread_end(void)
{
void *__ptr;
__ptr = (void *)_my_thread_var();
(**(code **)(PSI_server + 0x138))();
set_mysys_var(0);
if ((__ptr != (void *)0x0) && (*(char *)((long)__ptr + 0xe8) != '\0')) {
my_thread_destory_thr_mutex(__ptr);
inline_mysql_mutex_lock
(THR_LOCK_threads,"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",0x175
);
THR_thread_count = THR_thread_count + -1;
if (THR_thread_count == 0) {
inline_mysql_cond_signal(THR_COND_threads);
}
inline_mysql_mutex_unlock(THR_LOCK_threads);
*(int1 *)((long)__ptr + 0xe8) = 2;
free(__ptr);
}
return;
}
|
|
66,466 |
ma_save_session_track_info
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
void ma_save_session_track_info(void *ptr, enum enum_mariadb_status_info type, ...)
{
MYSQL *mysql= (MYSQL *)ptr;
enum enum_session_state_type track_type;
va_list ap;
DBUG_ASSERT(mysql != NULL);
/* We only handle SESSION_TRACK_TYPE here */
if (type != SESSION_TRACK_TYPE)
return;
va_start(ap, type);
track_type= va_arg(ap, enum enum_session_state_type);
switch (track_type) {
case SESSION_TRACK_SCHEMA:
case SESSION_TRACK_STATE_CHANGE:
case SESSION_TRACK_TRANSACTION_CHARACTERISTICS:
case SESSION_TRACK_TRANSACTION_STATE:
case SESSION_TRACK_GTIDS:
case SESSION_TRACK_SYSTEM_VARIABLES:
{
LIST *session_item;
MYSQL_LEX_STRING *str;
char *tmp;
MARIADB_CONST_STRING *data1= va_arg(ap, MARIADB_CONST_STRING *);
if (!(session_item= ma_multi_malloc(0,
&session_item, sizeof(LIST),
&str, sizeof(MYSQL_LEX_STRING),
&tmp, data1->length,
NULL)))
goto mem_error;
str->str= tmp;
memcpy(str->str, data1->str, data1->length);
str->length= data1->length;
session_item->data= str;
mysql->extension->session_state[track_type].list= list_add(mysql->extension->session_state[track_type].list,
session_item);
if (track_type == SESSION_TRACK_SYSTEM_VARIABLES)
{
MARIADB_CONST_STRING *data2= va_arg(ap, MARIADB_CONST_STRING *);
if (!(session_item= ma_multi_malloc(0,
&session_item, sizeof(LIST),
&str, sizeof(MYSQL_LEX_STRING),
&tmp, data2->length,
NULL)))
goto mem_error;
str->str= tmp;
memcpy(str->str, data2->str, data2->length);
str->length= data2->length;
session_item->data= str;
mysql->extension->session_state[track_type].list= list_add(mysql->extension->session_state[track_type].list,
session_item);
}
}
break;
}
return;
mem_error:
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return;
}
|
O0
|
c
|
ma_save_session_track_info:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
testb %al, %al
je 0x28ec4
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %r9, -0xf8(%rbp)
movq %r8, -0x100(%rbp)
movq %rcx, -0x108(%rbp)
movq %rdx, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
je 0x28efa
jmp 0x2926b
leaq -0x40(%rbp), %rax
leaq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x130(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x124(%rbp)
cmpl $0x28, %eax
ja 0x28f59
movq -0x130(%rbp), %rcx
movl -0x124(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x138(%rbp)
jmp 0x28f76
movq -0x130(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x5, %eax
ja 0x29202
jmp 0x28f90
leaq -0x40(%rbp), %rax
movq %rax, -0x148(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x13c(%rbp)
cmpl $0x28, %eax
ja 0x28fcb
movq -0x148(%rbp), %rcx
movl -0x13c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x150(%rbp)
jmp 0x28fe8
movq -0x148(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x150(%rbp)
movq -0x150(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq -0x48(%rbp), %rsi
movl $0x18, %edx
leaq -0x50(%rbp), %rcx
movl $0x10, %r8d
leaq -0x58(%rbp), %r9
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, %al
callq 0x2f970
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x2903d
jmp 0x29204
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x60(%rbp), %rax
movq (%rax), %rsi
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x174a0
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x4f0(%rax), %rax
addq $0x8, %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x48(%rbp), %rsi
callq 0x2d8c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x4f0(%rax), %rax
addq $0x8, %rax
movl -0x1c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
cmpl $0x0, -0x1c(%rbp)
jne 0x29200
leaq -0x40(%rbp), %rax
movq %rax, -0x160(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x154(%rbp)
cmpl $0x28, %eax
ja 0x29108
movq -0x160(%rbp), %rcx
movl -0x154(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x168(%rbp)
jmp 0x29125
movq -0x160(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x168(%rbp)
movq -0x168(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq -0x48(%rbp), %rsi
movl $0x18, %edx
leaq -0x50(%rbp), %rcx
movl $0x10, %r8d
leaq -0x58(%rbp), %r9
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, %al
callq 0x2f970
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x2917a
jmp 0x29204
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x68(%rbp), %rax
movq (%rax), %rsi
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x174a0
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x4f0(%rax), %rax
addq $0x8, %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x48(%rbp), %rsi
callq 0x2d8c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x4f0(%rax), %rax
addq $0x8, %rax
movl -0x1c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x29202
jmp 0x2926b
jmp 0x29206
movq -0x18(%rbp), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x39e7a(%rip), %rax # 0x630a0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x172e0
movq -0x18(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rdi
addq $0x97, %rdi
leaq 0x39e60(%rip), %rax # 0x630b0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x172e0
movq -0x18(%rbp), %rax
movb $0x0, 0x296(%rax)
jmp 0x2926b
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_save_session_track_info:
push rbp
mov rbp, rsp
sub rsp, 180h
test al, al
jz short loc_28EC4
movaps [rbp+var_F0], xmm0
movaps [rbp+var_E0], xmm1
movaps [rbp+var_D0], xmm2
movaps [rbp+var_C0], xmm3
movaps [rbp+var_B0], xmm4
movaps [rbp+var_A0], xmm5
movaps [rbp+var_90], xmm6
movaps [rbp+var_80], xmm7
loc_28EC4:
mov [rbp+var_F8], r9
mov [rbp+var_100], r8
mov [rbp+var_108], rcx
mov [rbp+var_110], rdx
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
cmp [rbp+var_C], 1
jz short loc_28EFA
jmp loc_2926B
loc_28EFA:
lea rax, [rbp+var_40]
lea rcx, [rbp+var_120]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
lea rax, [rbp+var_40]
mov [rbp+var_130], rax
mov eax, [rbp+var_40]
mov [rbp+var_124], eax
cmp eax, 28h ; '('
ja short loc_28F59
mov rcx, [rbp+var_130]
mov edx, [rbp+var_124]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_138], rax
jmp short loc_28F76
loc_28F59:
mov rcx, [rbp+var_130]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_138], rax
loc_28F76:
mov rax, [rbp+var_138]
mov eax, [rax]
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
sub eax, 5
ja loc_29202
jmp short $+2
loc_28F90:
lea rax, [rbp+var_40]
mov [rbp+var_148], rax
mov eax, [rbp+var_40]
mov [rbp+var_13C], eax
cmp eax, 28h ; '('
ja short loc_28FCB
mov rcx, [rbp+var_148]
mov edx, [rbp+var_13C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_150], rax
jmp short loc_28FE8
loc_28FCB:
mov rcx, [rbp+var_148]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_150], rax
loc_28FE8:
mov rax, [rbp+var_150]
mov rax, [rax]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov rax, [rax+8]
xor edi, edi
lea rsi, [rbp+var_48]
mov edx, 18h
lea rcx, [rbp+var_50]
mov r8d, 10h
lea r9, [rbp+var_58]
xor r10d, r10d
mov [rsp+180h+var_180], rax
mov [rsp+180h+var_178], 0
mov al, 0
call ma_multi_malloc
mov [rbp+var_48], rax
cmp rax, 0
jnz short loc_2903D
jmp loc_29204
loc_2903D:
mov rcx, [rbp+var_58]
mov rax, [rbp+var_50]
mov [rax], rcx
mov rax, [rbp+var_50]
mov rdi, [rax]
mov rax, [rbp+var_60]
mov rsi, [rax]
mov rax, [rbp+var_60]
mov rdx, [rax+8]
call _memcpy
mov rax, [rbp+var_60]
mov rcx, [rax+8]
mov rax, [rbp+var_50]
mov [rax+8], rcx
mov rcx, [rbp+var_50]
mov rax, [rbp+var_48]
mov [rax+10h], rcx
mov rax, [rbp+var_18]
mov rax, [rax+4F0h]
add rax, 8
mov ecx, [rbp+var_1C]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rsi, [rbp+var_48]
call list_add
mov rcx, rax
mov rax, [rbp+var_18]
mov rax, [rax+4F0h]
add rax, 8
mov edx, [rbp+var_1C]
shl rdx, 4
add rax, rdx
mov [rax], rcx
cmp [rbp+var_1C], 0
jnz loc_29200
lea rax, [rbp+var_40]
mov [rbp+var_160], rax
mov eax, [rbp+var_40]
mov [rbp+var_154], eax
cmp eax, 28h ; '('
ja short loc_29108
mov rcx, [rbp+var_160]
mov edx, [rbp+var_154]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_168], rax
jmp short loc_29125
loc_29108:
mov rcx, [rbp+var_160]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_168], rax
loc_29125:
mov rax, [rbp+var_168]
mov rax, [rax]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
mov rax, [rax+8]
xor edi, edi
lea rsi, [rbp+var_48]
mov edx, 18h
lea rcx, [rbp+var_50]
mov r8d, 10h
lea r9, [rbp+var_58]
xor r10d, r10d
mov [rsp+180h+var_180], rax
mov [rsp+180h+var_178], 0
mov al, 0
call ma_multi_malloc
mov [rbp+var_48], rax
cmp rax, 0
jnz short loc_2917A
jmp loc_29204
loc_2917A:
mov rcx, [rbp+var_58]
mov rax, [rbp+var_50]
mov [rax], rcx
mov rax, [rbp+var_50]
mov rdi, [rax]
mov rax, [rbp+var_68]
mov rsi, [rax]
mov rax, [rbp+var_68]
mov rdx, [rax+8]
call _memcpy
mov rax, [rbp+var_68]
mov rcx, [rax+8]
mov rax, [rbp+var_50]
mov [rax+8], rcx
mov rcx, [rbp+var_50]
mov rax, [rbp+var_48]
mov [rax+10h], rcx
mov rax, [rbp+var_18]
mov rax, [rax+4F0h]
add rax, 8
mov ecx, [rbp+var_1C]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rsi, [rbp+var_48]
call list_add
mov rcx, rax
mov rax, [rbp+var_18]
mov rax, [rax+4F0h]
add rax, 8
mov edx, [rbp+var_1C]
shl rdx, 4
add rax, rdx
mov [rax], rcx
loc_29200:
jmp short $+2
loc_29202:
jmp short loc_2926B
loc_29204:
jmp short $+2
loc_29206:
mov rax, [rbp+var_18]
mov dword ptr [rax+90h], 7D8h
mov rdi, [rbp+var_18]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_18]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+296h], 0
jmp short $+2
loc_2926B:
add rsp, 180h
pop rbp
retn
|
long long ma_save_session_track_info(long long a1, int a2, unsigned int a3, ...)
{
long long result; // rax
char *v4; // rax
long long v5; // rcx
char *overflow_arg_area; // rax
long long v7; // rcx
_QWORD *v8; // [rsp+118h] [rbp-68h]
_QWORD *v9; // [rsp+120h] [rbp-60h]
long long v10; // [rsp+128h] [rbp-58h] BYREF
_QWORD *v11; // [rsp+130h] [rbp-50h] BYREF
long long v12; // [rsp+138h] [rbp-48h] BYREF
va_list va; // [rsp+140h] [rbp-40h] BYREF
unsigned int v14; // [rsp+164h] [rbp-1Ch]
long long v15; // [rsp+168h] [rbp-18h]
int v16; // [rsp+174h] [rbp-Ch]
long long v17; // [rsp+178h] [rbp-8h]
v17 = a1;
v16 = a2;
result = a1;
v15 = a1;
if ( a2 == 1 )
{
va_start(va, a3);
v14 = a3;
result = a3 - 5;
if ( a3 <= 5 )
{
v4 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
v9 = *(_QWORD **)v4;
v12 = ma_multi_malloc(
0,
(unsigned int)&v12,
24,
(unsigned int)&v11,
16,
(unsigned int)&v10,
*(_QWORD *)(*(_QWORD *)v4 + 8LL),
0LL);
if ( !v12 )
goto LABEL_11;
*v11 = v10;
memcpy(*v11, *v9, v9[1]);
v11[1] = v9[1];
*(_QWORD *)(v12 + 16) = v11;
v5 = list_add(*(_QWORD *)(16LL * v14 + *(_QWORD *)(v15 + 1264) + 8LL), v12);
result = 16LL * v14 + *(_QWORD *)(v15 + 1264) + 8LL;
*(_QWORD *)result = v5;
if ( v14 )
return result;
if ( va[0].gp_offset > 0x28 )
{
overflow_arg_area = (char *)va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
overflow_arg_area = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
v8 = *(_QWORD **)overflow_arg_area;
v12 = ma_multi_malloc(
0,
(unsigned int)&v12,
24,
(unsigned int)&v11,
16,
(unsigned int)&v10,
*(_QWORD *)(*(_QWORD *)overflow_arg_area + 8LL),
0LL);
if ( !v12 )
{
LABEL_11:
*(_DWORD *)(v15 + 144) = 2008;
strncpy(v15 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v15 + 668) = 0;
strncpy(v15 + 151, client_errors[8], 511LL);
result = v15;
*(_BYTE *)(v15 + 662) = 0;
return result;
}
*v11 = v10;
memcpy(*v11, *v8, v8[1]);
v11[1] = v8[1];
*(_QWORD *)(v12 + 16) = v11;
v7 = list_add(*(_QWORD *)(16LL * v14 + *(_QWORD *)(v15 + 1264) + 8LL), v12);
result = 16LL * v14 + *(_QWORD *)(v15 + 1264) + 8LL;
*(_QWORD *)result = v7;
}
}
return result;
}
|
ma_save_session_track_info:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x180
TEST AL,AL
JZ 0x00128ec4
MOVAPS xmmword ptr [RBP + -0xf0],XMM0
MOVAPS xmmword ptr [RBP + -0xe0],XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM2
MOVAPS xmmword ptr [RBP + -0xc0],XMM3
MOVAPS xmmword ptr [RBP + -0xb0],XMM4
MOVAPS xmmword ptr [RBP + -0xa0],XMM5
MOVAPS xmmword ptr [RBP + -0x90],XMM6
MOVAPS xmmword ptr [RBP + -0x80],XMM7
LAB_00128ec4:
MOV qword ptr [RBP + -0xf8],R9
MOV qword ptr [RBP + -0x100],R8
MOV qword ptr [RBP + -0x108],RCX
MOV qword ptr [RBP + -0x110],RDX
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP dword ptr [RBP + -0xc],0x1
JZ 0x00128efa
JMP 0x0012926b
LAB_00128efa:
LEA RAX,[RBP + -0x40]
LEA RCX,[RBP + -0x120]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x130],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x124],EAX
CMP EAX,0x28
JA 0x00128f59
MOV RCX,qword ptr [RBP + -0x130]
MOV EDX,dword ptr [RBP + -0x124]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x138],RAX
JMP 0x00128f76
LAB_00128f59:
MOV RCX,qword ptr [RBP + -0x130]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x138],RAX
LAB_00128f76:
MOV RAX,qword ptr [RBP + -0x138]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x5
JA 0x00129202
JMP 0x00128f90
LAB_00128f90:
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x148],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x13c],EAX
CMP EAX,0x28
JA 0x00128fcb
MOV RCX,qword ptr [RBP + -0x148]
MOV EDX,dword ptr [RBP + -0x13c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x150],RAX
JMP 0x00128fe8
LAB_00128fcb:
MOV RCX,qword ptr [RBP + -0x148]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x150],RAX
LAB_00128fe8:
MOV RAX,qword ptr [RBP + -0x150]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x8]
XOR EDI,EDI
LEA RSI,[RBP + -0x48]
MOV EDX,0x18
LEA RCX,[RBP + -0x50]
MOV R8D,0x10
LEA R9,[RBP + -0x58]
XOR R10D,R10D
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
MOV AL,0x0
CALL 0x0012f970
MOV qword ptr [RBP + -0x48],RAX
CMP RAX,0x0
JNZ 0x0012903d
JMP 0x00129204
LAB_0012903d:
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001174a0
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x4f0]
ADD RAX,0x8
MOV ECX,dword ptr [RBP + -0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x0012d8c0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x4f0]
ADD RAX,0x8
MOV EDX,dword ptr [RBP + -0x1c]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00129200
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x160],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x154],EAX
CMP EAX,0x28
JA 0x00129108
MOV RCX,qword ptr [RBP + -0x160]
MOV EDX,dword ptr [RBP + -0x154]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x168],RAX
JMP 0x00129125
LAB_00129108:
MOV RCX,qword ptr [RBP + -0x160]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x168],RAX
LAB_00129125:
MOV RAX,qword ptr [RBP + -0x168]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x8]
XOR EDI,EDI
LEA RSI,[RBP + -0x48]
MOV EDX,0x18
LEA RCX,[RBP + -0x50]
MOV R8D,0x10
LEA R9,[RBP + -0x58]
XOR R10D,R10D
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
MOV AL,0x0
CALL 0x0012f970
MOV qword ptr [RBP + -0x48],RAX
CMP RAX,0x0
JNZ 0x0012917a
JMP 0x00129204
LAB_0012917a:
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001174a0
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x4f0]
ADD RAX,0x8
MOV ECX,dword ptr [RBP + -0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x0012d8c0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x4f0]
ADD RAX,0x8
MOV EDX,dword ptr [RBP + -0x1c]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
LAB_00129200:
JMP 0x00129202
LAB_00129202:
JMP 0x0012926b
LAB_00129204:
JMP 0x00129206
LAB_00129206:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x297
LEA RAX,[0x1630a0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x001172e0
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x97
LEA RAX,[0x1630b0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x001172e0
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x296],0x0
JMP 0x0012926b
LAB_0012926b:
ADD RSP,0x180
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00128f59) */
/* WARNING: Removing unreachable block (ram,0x00128fcb) */
/* WARNING: Heritage AFTER dead removal. Example location: s0xfffffffffffffee8 : 0x00128f7d */
/* WARNING: Restarted to delay deadcode elimination for space: stack */
void ma_save_session_track_info
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long param_9,int param_10,int8 param_11,int8 param_12,int8 param_13
,int8 param_14)
{
int8 *puVar1;
char in_AL;
int8 uVar2;
long *local_170;
int1 local_128 [16];
int8 local_118;
int8 *local_110;
int8 local_108;
int8 local_100;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 *local_70;
int8 *local_68;
int8 local_60;
int8 *local_58;
long local_50;
uint local_48;
int4 local_44;
long *local_40;
int1 *local_38;
uint local_24;
long local_20;
int local_14;
long local_10;
if (in_AL != '\0') {
local_f8 = param_1;
local_e8 = param_2;
local_d8 = param_3;
local_c8 = param_4;
local_b8 = param_5;
local_a8 = param_6;
local_98 = param_7;
local_88 = param_8;
}
if (param_10 == 1) {
local_38 = local_128;
local_40 = (long *)&stack0x00000008;
local_44 = 0x30;
local_24 = (uint)local_118;
if ((uint)local_118 < 6) {
local_48 = 0x20;
local_68 = local_110;
puVar1 = local_110 + 1;
local_118 = param_11;
local_110 = (int8 *)param_12;
local_108 = param_13;
local_100 = param_14;
local_20 = param_9;
local_14 = param_10;
local_10 = param_9;
local_50 = ma_multi_malloc(0,&local_50,0x18,&local_58,0x10,&local_60,*puVar1,0);
if (local_50 != 0) {
*local_58 = local_60;
memcpy((void *)*local_58,(void *)*local_68,local_68[1]);
local_58[1] = local_68[1];
*(int8 **)(local_50 + 0x10) = local_58;
uVar2 = list_add(*(int8 *)(*(long *)(local_20 + 0x4f0) + 8 + (ulong)local_24 * 0x10),
local_50);
*(int8 *)(*(long *)(local_20 + 0x4f0) + 8 + (ulong)local_24 * 0x10) = uVar2;
if (local_24 != 0) {
return;
}
if (local_48 < 0x29) {
local_170 = (long *)(local_38 + (int)local_48);
local_48 = local_48 + 8;
}
else {
local_170 = local_40;
local_40 = local_40 + 1;
}
local_70 = (int8 *)*local_170;
local_50 = ma_multi_malloc(0,&local_50,0x18,&local_58,0x10,&local_60,local_70[1],0);
if (local_50 != 0) {
*local_58 = local_60;
memcpy((void *)*local_58,(void *)*local_70,local_70[1]);
local_58[1] = local_70[1];
*(int8 **)(local_50 + 0x10) = local_58;
uVar2 = list_add(*(int8 *)(*(long *)(local_20 + 0x4f0) + 8 + (ulong)local_24 * 0x10)
,local_50);
*(int8 *)(*(long *)(local_20 + 0x4f0) + 8 + (ulong)local_24 * 0x10) = uVar2;
return;
}
}
local_50 = 0;
*(int4 *)(local_20 + 0x90) = 0x7d8;
strncpy((char *)(local_20 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_20 + 0x29c) = 0;
strncpy((char *)(local_20 + 0x97),PTR_s_Client_run_out_of_memory_001630f0,0x1ff);
*(int1 *)(local_20 + 0x296) = 0;
}
}
return;
}
|
|
66,467 |
cleanup_instrument_config()
|
eloqsql/storage/perfschema/pfs_server.cc
|
void cleanup_instrument_config()
{
if (pfs_instr_config_array != NULL)
{
PFS_instr_config **it= pfs_instr_config_array->front();
for ( ; it != pfs_instr_config_array->end(); it++)
my_free(*it);
}
delete pfs_instr_config_array;
pfs_instr_config_array= NULL;
}
|
O0
|
cpp
|
cleanup_instrument_config():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x3caef9(%rip), %rax # 0x40a038
cmpq $0x0, (%rax)
je 0x3f197
leaq 0x3caeec(%rip), %rax # 0x40a038
movq (%rax), %rdi
callq 0x3ddc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x3caed1(%rip), %rax # 0x40a038
movq (%rax), %rdi
callq 0x3dde0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
je 0x3f195
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x590e0
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x3f158
jmp 0x3f197
leaq 0x3cae9a(%rip), %rax # 0x40a038
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3f1c2
movq -0x18(%rbp), %rdi
callq 0x3f560
movq -0x18(%rbp), %rdi
movl $0x28, %esi
callq 0x26320
leaq 0x3cae6f(%rip), %rax # 0x40a038
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_Z25cleanup_instrument_configv:
push rbp
mov rbp, rsp
sub rsp, 20h
lea rax, pfs_instr_config_array
cmp qword ptr [rax], 0
jz short loc_3F197
lea rax, pfs_instr_config_array
mov rdi, [rax]
call _ZN13Dynamic_arrayIP16PFS_instr_configE5frontEv; Dynamic_array<PFS_instr_config *>::front(void)
mov [rbp+var_8], rax
loc_3F158:
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
lea rax, pfs_instr_config_array
mov rdi, [rax]
call _ZNK13Dynamic_arrayIP16PFS_instr_configE3endEv; Dynamic_array<PFS_instr_config *>::end(void)
mov rcx, rax
mov rax, [rbp+var_10]
cmp rax, rcx
jz short loc_3F195
mov rax, [rbp+var_8]
mov rdi, [rax]
call my_free
mov rax, [rbp+var_8]
add rax, 8
mov [rbp+var_8], rax
jmp short loc_3F158
loc_3F195:
jmp short $+2
loc_3F197:
lea rax, pfs_instr_config_array
mov rax, [rax]
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_3F1C2
mov rdi, [rbp+var_18]
call _ZN13Dynamic_arrayIP16PFS_instr_configED2Ev; Dynamic_array<PFS_instr_config *>::~Dynamic_array()
mov rdi, [rbp+var_18]; void *
mov esi, 28h ; '('; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3F1C2:
lea rax, pfs_instr_config_array
mov qword ptr [rax], 0
add rsp, 20h
pop rbp
retn
|
long long *cleanup_instrument_config(void)
{
long long *result; // rax
void *v1; // [rsp+8h] [rbp-18h]
_QWORD *i; // [rsp+18h] [rbp-8h]
if ( pfs_instr_config_array )
{
for ( i = (_QWORD *)Dynamic_array<PFS_instr_config *>::front(pfs_instr_config_array);
i != (_QWORD *)Dynamic_array<PFS_instr_config *>::end(pfs_instr_config_array);
++i )
{
my_free(*i);
}
}
v1 = (void *)pfs_instr_config_array;
if ( pfs_instr_config_array )
{
Dynamic_array<PFS_instr_config *>::~Dynamic_array(pfs_instr_config_array);
operator delete(v1, 0x28uLL);
}
result = &pfs_instr_config_array;
pfs_instr_config_array = 0LL;
return result;
}
|
cleanup_instrument_config:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
LEA RAX,[0x50a038]
CMP qword ptr [RAX],0x0
JZ 0x0013f197
LEA RAX,[0x50a038]
MOV RDI,qword ptr [RAX]
CALL 0x0013ddc0
MOV qword ptr [RBP + -0x8],RAX
LAB_0013f158:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
LEA RAX,[0x50a038]
MOV RDI,qword ptr [RAX]
CALL 0x0013dde0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,RCX
JZ 0x0013f195
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
CALL 0x001590e0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x8
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0013f158
LAB_0013f195:
JMP 0x0013f197
LAB_0013f197:
LEA RAX,[0x50a038]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x0013f1c2
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0013f560
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,0x28
CALL 0x00126320
LAB_0013f1c2:
LEA RAX,[0x50a038]
MOV qword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cleanup_instrument_config() */
void cleanup_instrument_config(void)
{
Dynamic_array<PFS_instr_config*> *pDVar1;
int8 *puVar2;
int8 *local_10;
if (pfs_instr_config_array != (Dynamic_array<PFS_instr_config*> *)0x0) {
for (local_10 = (int8 *)Dynamic_array<PFS_instr_config*>::front(pfs_instr_config_array);
puVar2 = (int8 *)Dynamic_array<PFS_instr_config*>::end(pfs_instr_config_array),
local_10 != puVar2; local_10 = local_10 + 1) {
my_free(*local_10);
}
}
pDVar1 = pfs_instr_config_array;
if (pfs_instr_config_array != (Dynamic_array<PFS_instr_config*> *)0x0) {
Dynamic_array<PFS_instr_config*>::~Dynamic_array(pfs_instr_config_array);
operator_delete(pDVar1,0x28);
}
pfs_instr_config_array = (Dynamic_array<PFS_instr_config*> *)0x0;
return;
}
|
|
66,468 |
my_thread_init_common_mutex
|
eloqsql/mysys/my_thr_init.c
|
static void my_thread_init_common_mutex(void)
{
mysql_mutex_init(key_THR_LOCK_open, &THR_LOCK_open, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_lock, &THR_LOCK_lock, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_myisam, &THR_LOCK_myisam, MY_MUTEX_INIT_SLOW);
mysql_mutex_init(key_THR_LOCK_myisam_mmap, &THR_LOCK_myisam_mmap, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_heap, &THR_LOCK_heap, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_net, &THR_LOCK_net, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_charset, &THR_LOCK_charset, MY_MUTEX_INIT_FAST);
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
mysql_mutex_init(key_LOCK_localtime_r, &LOCK_localtime_r, MY_MUTEX_INIT_SLOW);
#endif
}
|
O3
|
c
|
my_thread_init_common_mutex:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x33e979(%rip), %rax # 0x364cb8
movl (%rax), %edi
leaq 0x2c84d8(%rip), %r15 # 0x2ee820
movq (%r15), %rax
leaq 0x33f336(%rip), %r14 # 0x365688
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
leaq 0x33f5e9(%rip), %rbx # 0x365958
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24490
leaq 0x33e923(%rip), %rax # 0x364ca4
movl (%rax), %edi
movq (%r15), %rax
leaq 0x33f343(%rip), %r14 # 0x3656d0
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24490
leaq 0x33e8fb(%rip), %rax # 0x364cb0
movl (%rax), %edi
movq (%r15), %rax
leaq 0x33f357(%rip), %r14 # 0x365718
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0x24490
leaq 0x33e8dc(%rip), %rax # 0x364cc4
movl (%rax), %edi
movq (%r15), %rax
leaq 0x33f36c(%rip), %r14 # 0x365760
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24490
leaq 0x33e884(%rip), %rax # 0x364ca0
movl (%rax), %edi
movq (%r15), %rax
leaq 0x33f380(%rip), %r14 # 0x3657a8
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24490
leaq 0x33e864(%rip), %rax # 0x364cb4
movl (%rax), %edi
movq (%r15), %rax
leaq 0x33f394(%rip), %r14 # 0x3657f0
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24490
leaq 0x33e818(%rip), %rax # 0x364c9c
movl (%rax), %edi
movq (%r15), %rax
leaq 0x33f3a8(%rip), %r14 # 0x365838
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24490
|
my_thread_init_common_mutex:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
lea rax, key_THR_LOCK_open
mov edi, [rax]
lea r15, PSI_server
mov rax, [r15]
lea r14, THR_LOCK_open
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
lea rbx, my_fast_mutexattr
mov rdi, r14
mov rsi, rbx
call _pthread_mutex_init
lea rax, key_THR_LOCK_lock
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_lock
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
mov rsi, rbx
call _pthread_mutex_init
lea rax, key_THR_LOCK_myisam
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_myisam
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
xor esi, esi
call _pthread_mutex_init
lea rax, key_THR_LOCK_myisam_mmap
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_myisam_mmap
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
mov rsi, rbx
call _pthread_mutex_init
lea rax, key_THR_LOCK_heap
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_heap
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
mov rsi, rbx
call _pthread_mutex_init
lea rax, key_THR_LOCK_net
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_net
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
mov rsi, rbx
call _pthread_mutex_init
lea rax, key_THR_LOCK_charset
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_charset
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _pthread_mutex_init
|
long long my_thread_init_common_mutex()
{
THR_LOCK_open[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server[0] + 8))(key_THR_LOCK_open, THR_LOCK_open);
THR_LOCK_open[7] = THR_LOCK_open;
*(_OWORD *)&THR_LOCK_open[5] = 0LL;
pthread_mutex_init(THR_LOCK_open, &my_fast_mutexattr);
THR_LOCK_lock[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server[0] + 8))(key_THR_LOCK_lock, THR_LOCK_lock);
THR_LOCK_lock[7] = THR_LOCK_lock;
*(_OWORD *)&THR_LOCK_lock[5] = 0LL;
pthread_mutex_init(THR_LOCK_lock, &my_fast_mutexattr);
THR_LOCK_myisam[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server[0] + 8))(
key_THR_LOCK_myisam,
THR_LOCK_myisam);
THR_LOCK_myisam[7] = THR_LOCK_myisam;
*(_OWORD *)&THR_LOCK_myisam[5] = 0LL;
pthread_mutex_init(THR_LOCK_myisam, 0LL);
THR_LOCK_myisam_mmap[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server[0] + 8))(
key_THR_LOCK_myisam_mmap,
THR_LOCK_myisam_mmap);
THR_LOCK_myisam_mmap[7] = THR_LOCK_myisam_mmap;
*(_OWORD *)&THR_LOCK_myisam_mmap[5] = 0LL;
pthread_mutex_init(THR_LOCK_myisam_mmap, &my_fast_mutexattr);
THR_LOCK_heap[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server[0] + 8))(key_THR_LOCK_heap, THR_LOCK_heap);
THR_LOCK_heap[7] = THR_LOCK_heap;
*(_OWORD *)&THR_LOCK_heap[5] = 0LL;
pthread_mutex_init(THR_LOCK_heap, &my_fast_mutexattr);
THR_LOCK_net[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server[0] + 8))(key_THR_LOCK_net, THR_LOCK_net);
THR_LOCK_net[7] = THR_LOCK_net;
*(_OWORD *)&THR_LOCK_net[5] = 0LL;
pthread_mutex_init(THR_LOCK_net, &my_fast_mutexattr);
THR_LOCK_charset[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server[0] + 8))(
key_THR_LOCK_charset,
THR_LOCK_charset);
THR_LOCK_charset[7] = THR_LOCK_charset;
*(_OWORD *)&THR_LOCK_charset[5] = 0LL;
return pthread_mutex_init(THR_LOCK_charset, &my_fast_mutexattr);
}
|
my_thread_init_common_mutex:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
LEA RAX,[0x464cb8]
MOV EDI,dword ptr [RAX]
LEA R15,[0x3ee820]
MOV RAX,qword ptr [R15]
LEA R14,[0x465688]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
LEA RBX,[0x465958]
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124490
LEA RAX,[0x464ca4]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x4656d0]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124490
LEA RAX,[0x464cb0]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x465718]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00124490
LEA RAX,[0x464cc4]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x465760]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124490
LEA RAX,[0x464ca0]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x4657a8]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124490
LEA RAX,[0x464cb4]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x4657f0]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124490
LEA RAX,[0x464c9c]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x465838]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00124490
|
void my_thread_init_common_mutex(void)
{
THR_LOCK_open._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_open,THR_LOCK_open);
THR_LOCK_open._56_8_ = THR_LOCK_open;
THR_LOCK_open._40_8_ = 0;
THR_LOCK_open._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_open,(pthread_mutexattr_t *)&my_fast_mutexattr);
THR_LOCK_lock._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_lock,THR_LOCK_lock);
THR_LOCK_lock._56_8_ = THR_LOCK_lock;
THR_LOCK_lock._40_8_ = 0;
THR_LOCK_lock._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_lock,(pthread_mutexattr_t *)&my_fast_mutexattr);
THR_LOCK_myisam._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_myisam);
THR_LOCK_myisam._56_8_ = THR_LOCK_myisam;
THR_LOCK_myisam._40_8_ = 0;
THR_LOCK_myisam._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_myisam,(pthread_mutexattr_t *)0x0);
THR_LOCK_myisam_mmap._64_8_ =
(**(code **)(PSI_server + 0x40))(key_THR_LOCK_myisam_mmap,THR_LOCK_myisam_mmap);
THR_LOCK_myisam_mmap._56_8_ = THR_LOCK_myisam_mmap;
THR_LOCK_myisam_mmap._40_8_ = 0;
THR_LOCK_myisam_mmap._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_myisam_mmap,
(pthread_mutexattr_t *)&my_fast_mutexattr);
THR_LOCK_heap._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_heap,THR_LOCK_heap);
THR_LOCK_heap._56_8_ = THR_LOCK_heap;
THR_LOCK_heap._40_8_ = 0;
THR_LOCK_heap._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_heap,(pthread_mutexattr_t *)&my_fast_mutexattr);
THR_LOCK_net._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_net,THR_LOCK_net);
THR_LOCK_net._56_8_ = THR_LOCK_net;
THR_LOCK_net._40_8_ = 0;
THR_LOCK_net._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_net,(pthread_mutexattr_t *)&my_fast_mutexattr);
THR_LOCK_charset._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_charset,THR_LOCK_charset);
THR_LOCK_charset._56_8_ = THR_LOCK_charset;
THR_LOCK_charset._40_8_ = 0;
THR_LOCK_charset._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_charset,(pthread_mutexattr_t *)&my_fast_mutexattr);
return;
}
|
|
66,469 |
my_fill_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static void
my_fill_ucs2(CHARSET_INFO *cs __attribute__((unused)),
char *s, size_t l, int fill)
{
DBUG_ASSERT(fill <= 0xFFFF);
#ifdef WAITING_FOR_GCC_VECTORIZATION_BUG_TO_BE_FIXED
/*
This code with int2store() is known to be faster on some processors,
but crashes on other processors due to a possible bug in GCC's
-ftree-vectorization (which is enabled in -O3) in case of
a non-aligned memory. See here for details:
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58039
*/
char *last= s + l - 2;
uint16 tmp= (fill >> 8) + ((fill & 0xFF) << 8); /* swap bytes */
DBUG_ASSERT(fill <= 0xFFFF);
for ( ; s <= last; s+= 2)
int2store(s, tmp); /* store little-endian */
#else
for ( ; l >= 2; s[0]= (fill >> 8), s[1]= (fill & 0xFF), s+= 2, l-= 2);
#endif
}
|
O0
|
c
|
my_fill_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
jmp 0x5ed35
jmp 0x5ed37
cmpq $0x2, -0x18(%rbp)
jb 0x5ed79
jmp 0x5ed40
movl -0x1c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x5ed37
popq %rbp
retq
nopl (%rax,%rax)
|
my_fill_ucs2:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
jmp short $+2
loc_5ED35:
jmp short $+2
loc_5ED37:
cmp [rbp+var_18], 2
jb short loc_5ED79
jmp short $+2
loc_5ED40:
mov eax, [rbp+var_1C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov eax, [rbp+var_1C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
mov rax, [rbp+var_18]
sub rax, 2
mov [rbp+var_18], rax
jmp short loc_5ED37
loc_5ED79:
pop rbp
retn
|
unsigned long long my_fill_ucs2(long long a1, _BYTE *a2, unsigned long long a3, __int16 a4)
{
unsigned long long result; // rax
while ( a3 >= 2 )
{
*a2 = HIBYTE(a4);
a2[1] = a4;
a2 += 2;
result = a3 - 2;
a3 -= 2LL;
}
return result;
}
|
my_fill_ucs2:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
JMP 0x0015ed35
LAB_0015ed35:
JMP 0x0015ed37
LAB_0015ed37:
CMP qword ptr [RBP + -0x18],0x2
JC 0x0015ed79
JMP 0x0015ed40
LAB_0015ed40:
MOV EAX,dword ptr [RBP + -0x1c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x2
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0015ed37
LAB_0015ed79:
POP RBP
RET
|
void my_fill_ucs2(int8 param_1,int1 *param_2,ulong param_3,int4 param_4)
{
ulong local_20;
int1 *local_18;
local_18 = param_2;
for (local_20 = param_3; 1 < local_20; local_20 = local_20 - 2) {
*local_18 = (char)((uint)param_4 >> 8);
local_18[1] = (char)param_4;
local_18 = local_18 + 2;
}
return;
}
|
|
66,470 |
my_fill_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static void
my_fill_ucs2(CHARSET_INFO *cs __attribute__((unused)),
char *s, size_t l, int fill)
{
DBUG_ASSERT(fill <= 0xFFFF);
#ifdef WAITING_FOR_GCC_VECTORIZATION_BUG_TO_BE_FIXED
/*
This code with int2store() is known to be faster on some processors,
but crashes on other processors due to a possible bug in GCC's
-ftree-vectorization (which is enabled in -O3) in case of
a non-aligned memory. See here for details:
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58039
*/
char *last= s + l - 2;
uint16 tmp= (fill >> 8) + ((fill & 0xFF) << 8); /* swap bytes */
DBUG_ASSERT(fill <= 0xFFFF);
for ( ; s <= last; s+= 2)
int2store(s, tmp); /* store little-endian */
#else
for ( ; l >= 2; s[0]= (fill >> 8), s[1]= (fill & 0xFF), s+= 2, l-= 2);
#endif
}
|
O3
|
c
|
my_fill_ucs2:
cmpq $0x2, %rdx
jb 0x49d0a
pushq %rbp
movq %rsp, %rbp
movl %ecx, %eax
shrl $0x8, %eax
movb %al, (%rsi)
movb %cl, 0x1(%rsi)
addq $0x2, %rsi
addq $-0x2, %rdx
cmpq $0x1, %rdx
ja 0x49cf6
popq %rbp
retq
|
my_fill_ucs2:
cmp rdx, 2
jb short locret_49D0A
push rbp
mov rbp, rsp
mov eax, ecx
shr eax, 8
loc_49CF6:
mov [rsi], al
mov [rsi+1], cl
add rsi, 2
add rdx, 0FFFFFFFFFFFFFFFEh
cmp rdx, 1
ja short loc_49CF6
pop rbp
locret_49D0A:
retn
|
void my_fill_ucs2(long long a1, _BYTE *a2, unsigned long long a3, __int16 a4)
{
bool v4; // cf
if ( a3 >= 2 )
{
do
{
*a2 = HIBYTE(a4);
a2[1] = a4;
a2 += 2;
v4 = a3 == 2;
a3 -= 2LL;
}
while ( !v4 && a3 != 1 );
}
}
|
my_fill_ucs2:
CMP RDX,0x2
JC 0x00149d0a
PUSH RBP
MOV RBP,RSP
MOV EAX,ECX
SHR EAX,0x8
LAB_00149cf6:
MOV byte ptr [RSI],AL
MOV byte ptr [RSI + 0x1],CL
ADD RSI,0x2
ADD RDX,-0x2
CMP RDX,0x1
JA 0x00149cf6
POP RBP
LAB_00149d0a:
RET
|
void my_fill_ucs2(int8 param_1,int1 *param_2,ulong param_3,int4 param_4)
{
if (1 < param_3) {
do {
*param_2 = (char)((uint)param_4 >> 8);
param_2[1] = (char)param_4;
param_2 = param_2 + 2;
param_3 = param_3 - 2;
} while (1 < param_3);
}
return;
}
|
|
66,471 |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::~lexer()
|
11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp
|
~lexer() = default;
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::~lexer():
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x17ff4
movq (%rax), %rsi
incq %rsi
callq 0x119a0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1800a
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x119a0
popq %rbx
retq
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev:
push rbx
mov rbx, rdi
mov rdi, [rdi+50h]; void *
lea rax, [rbx+60h]
cmp rdi, rax
jz short loc_17FF4
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_17FF4:
mov rdi, [rbx+38h]; void *
test rdi, rdi
jz short loc_1800A
mov rsi, [rbx+48h]
sub rsi, rdi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_1800A:
pop rbx
retn
|
void nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~lexer(
_QWORD *a1)
{
_QWORD *v2; // rdi
void *v3; // rdi
v2 = (_QWORD *)a1[10];
if ( v2 != a1 + 12 )
operator delete(v2, a1[12] + 1LL);
v3 = (void *)a1[7];
if ( v3 )
operator delete(v3, a1[9] - (_QWORD)v3);
}
|
~lexer:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x50]
LEA RAX,[RBX + 0x60]
CMP RDI,RAX
JZ 0x00117ff4
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001119a0
LAB_00117ff4:
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JZ 0x0011800a
MOV RSI,qword ptr [RBX + 0x48]
SUB RSI,RDI
POP RBX
JMP 0x001119a0
LAB_0011800a:
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::~lexer() */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::~lexer(lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
void *pvVar1;
if (*(lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
**)(this + 0x50) != this + 0x60) {
operator_delete(*(lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
**)(this + 0x50),*(long *)(this + 0x60) + 1);
}
pvVar1 = *(void **)(this + 0x38);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x48) - (long)pvVar1);
return;
}
return;
}
|
|
66,472 |
aria_get_capabilities
|
eloqsql/storage/maria/ma_backup.c
|
int aria_get_capabilities(File kfile, ARIA_TABLE_CAPABILITIES *cap)
{
MARIA_SHARE share;
int error= 0;
uint head_length= sizeof(share.state.header), base_pos;
uint aligned_bit_blocks;
size_t info_length;
uchar *disc_cache;
DBUG_ENTER("aria_get_capabilities");
bzero(cap, sizeof(*cap));
if (my_pread(kfile,share.state.header.file_version, head_length, 0,
MYF(MY_NABP)))
DBUG_RETURN(HA_ERR_NOT_A_TABLE);
if (memcmp(share.state.header.file_version, maria_file_magic, 4))
DBUG_RETURN(HA_ERR_NOT_A_TABLE);
share.options= mi_uint2korr(share.state.header.options);
info_length= mi_uint2korr(share.state.header.header_length);
base_pos= mi_uint2korr(share.state.header.base_pos);
/*
Allocate space for header information and for data that is too
big to keep on stack
*/
if (!(disc_cache= my_malloc(PSI_NOT_INSTRUMENTED, info_length, MYF(MY_WME))))
DBUG_RETURN(ENOMEM);
if (my_pread(kfile, disc_cache, info_length, 0L, MYF(MY_NABP)))
{
error= my_errno;
goto err;
}
_ma_base_info_read(disc_cache + base_pos, &share.base);
cap->transactional= share.base.born_transactional;
cap->checksum= MY_TEST(share.options & HA_OPTION_PAGE_CHECKSUM);
cap->online_backup_safe= cap->transactional && cap->checksum;
cap->header_size= share.base.keystart;
cap->keypage_header= ((share.base.born_transactional ?
LSN_STORE_SIZE + TRANSID_SIZE :
0) + KEYPAGE_KEYID_SIZE + KEYPAGE_FLAG_SIZE +
KEYPAGE_USED_SIZE);
cap->block_size= share.base.block_size;
cap->data_file_type= share.state.header.data_file_type;
cap->s3_block_size= share.base.s3_block_size;
cap->compression= share.base.compression_algorithm;
cap->encrypted= MY_TEST(share.base.extra_options &
MA_EXTRA_OPTIONS_ENCRYPTED);
if (share.state.header.data_file_type == BLOCK_RECORD)
{
/* Calulate how man pages the row bitmap covers. From _ma_bitmap_init() */
aligned_bit_blocks= (cap->block_size - PAGE_SUFFIX_SIZE) / 6;
/*
In each 6 bytes, we have 6*8/3 = 16 pages covered
The +1 is to add the bitmap page, as this doesn't have to be covered
*/
cap->bitmap_pages_covered= aligned_bit_blocks * 16 + 1;
}
/* Do a check that that we got things right */
if (share.state.header.data_file_type != BLOCK_RECORD &&
cap->online_backup_safe)
error= HA_ERR_NOT_A_TABLE;
err:
my_free(disc_cache);
DBUG_RETURN(error);
}
|
O0
|
c
|
aria_get_capabilities:
pushq %rbp
movq %rsp, %rbp
subq $0xc80, %rsp # imm = 0xC80
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0xc48(%rbp)
movq %rsi, -0xc50(%rbp)
movl $0x0, -0xc54(%rbp)
movl $0x18, -0xc58(%rbp)
movq -0xc50(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2a2c0
movl -0xc48(%rbp), %edi
leaq -0xc40(%rbp), %rsi
movl -0xc58(%rbp), %eax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x4, %r8d
callq 0xf59e0
cmpq $0x0, %rax
je 0x9ded7
jmp 0x9dec8
movl $0x82, -0xc44(%rbp)
jmp 0x9e19e
leaq -0xc40(%rbp), %rax
leaq 0x2203ab(%rip), %rcx # 0x2be290
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x9df07
jmp 0x9def8
movl $0x82, -0xc44(%rbp)
jmp 0x9e19e
movzbl -0xc3b(%rbp), %eax
movzwl %ax, %eax
movzbl -0xc3c(%rbp), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movq %rax, -0x520(%rbp)
movzbl -0xc39(%rbp), %eax
movzwl %ax, %eax
movzbl -0xc3a(%rbp), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movq %rax, -0xc68(%rbp)
movzbl -0xc33(%rbp), %eax
movzwl %ax, %eax
movzbl -0xc34(%rbp), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0xc5c(%rbp)
movq -0xc68(%rbp), %rsi
xorl %edi, %edi
movl $0x10, %edx
callq 0xf4be0
movq %rax, -0xc70(%rbp)
cmpq $0x0, %rax
jne 0x9dfa0
jmp 0x9df91
movl $0xc, -0xc44(%rbp)
jmp 0x9e19e
movl -0xc48(%rbp), %edi
movq -0xc70(%rbp), %rsi
movq -0xc68(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x4, %r8d
callq 0xf59e0
cmpq $0x0, %rax
je 0x9dfdb
callq 0xf7440
movl (%rax), %eax
movl %eax, -0xc54(%rbp)
jmp 0x9e186
movq -0xc70(%rbp), %rdi
movl -0xc5c(%rbp), %eax
addq %rax, %rdi
leaq -0xc40(%rbp), %rsi
addq $0x360, %rsi # imm = 0x360
callq 0x9e1d0
movb -0x7f4(%rbp), %cl
movq -0xc50(%rbp), %rax
movb %cl, 0x1d(%rax)
movq -0x520(%rbp), %rdx
andq $0x800, %rdx # imm = 0x800
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movb %al, %cl
movq -0xc50(%rbp), %rax
movb %cl, 0x1c(%rax)
movq -0xc50(%rbp), %rax
movsbl 0x1d(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xc71(%rbp)
je 0x9e065
movq -0xc50(%rbp), %rax
movsbl 0x1c(%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xc71(%rbp)
movb -0xc71(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0xc50(%rbp), %rax
movb %cl, 0x1f(%rax)
movq -0x8e0(%rbp), %rcx
movq -0xc50(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x7f4(%rbp), %edx
xorl %ecx, %ecx
movl $0xd, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
addl $0x1, %ecx
addl $0x1, %ecx
addl $0x2, %ecx
movq -0xc50(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x824(%rbp), %ecx
movq -0xc50(%rbp), %rax
movl %ecx, 0x10(%rax)
movzbl -0xc2a(%rbp), %ecx
movq -0xc50(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x880(%rbp), %rcx
movq -0xc50(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x810(%rbp), %eax
movb %al, %cl
movq -0xc50(%rbp), %rax
movb %cl, 0x28(%rax)
movl -0x818(%rbp), %edx
andl $0x1, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0xc50(%rbp), %rax
movb %cl, 0x1e(%rax)
movzbl -0xc2a(%rbp), %eax
cmpl $0x3, %eax
jne 0x9e15e
movq -0xc50(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x4, %eax
movl $0x6, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc60(%rbp)
movl -0xc60(%rbp), %eax
shll $0x4, %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0xc50(%rbp), %rax
movq %rcx, 0x8(%rax)
movzbl -0xc2a(%rbp), %eax
cmpl $0x3, %eax
je 0x9e184
movq -0xc50(%rbp), %rax
movsbl 0x1f(%rax), %eax
cmpl $0x0, %eax
je 0x9e184
movl $0x82, -0xc54(%rbp)
jmp 0x9e186
movq -0xc70(%rbp), %rdi
callq 0xf4f60
movl -0xc54(%rbp), %eax
movl %eax, -0xc44(%rbp)
movl -0xc44(%rbp), %eax
movl %eax, -0xc78(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9e1cb
movl -0xc78(%rbp), %eax
addq $0xc80, %rsp # imm = 0xC80
popq %rbp
retq
callq 0x2a270
|
aria_get_capabilities:
push rbp
mov rbp, rsp
sub rsp, 0C80h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_C48], edi
mov [rbp+var_C50], rsi
mov [rbp+var_C54], 0
mov [rbp+var_C58], 18h
mov rdi, [rbp+var_C50]
xor esi, esi
mov edx, 30h ; '0'
call _memset
mov edi, [rbp+var_C48]
lea rsi, [rbp+var_C40]
mov eax, [rbp+var_C58]
mov edx, eax
xor eax, eax
mov ecx, eax
mov r8d, 4
call my_pread
cmp rax, 0
jz short loc_9DED7
jmp short $+2
loc_9DEC8:
mov [rbp+var_C44], 82h
jmp loc_9E19E
loc_9DED7:
lea rax, [rbp+var_C40]
lea rcx, maria_file_magic
mov ecx, [rcx]
mov eax, [rax]
sub eax, ecx
setnz al
movzx eax, al
cmp eax, 0
jz short loc_9DF07
jmp short $+2
loc_9DEF8:
mov [rbp+var_C44], 82h
jmp loc_9E19E
loc_9DF07:
movzx eax, [rbp+var_C3B]
movzx eax, ax
movzx ecx, [rbp+var_C3C]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_520], rax
movzx eax, [rbp+var_C39]
movzx eax, ax
movzx ecx, [rbp+var_C3A]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_C68], rax
movzx eax, [rbp+var_C33]
movzx eax, ax
movzx ecx, [rbp+var_C34]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_C5C], eax
mov rsi, [rbp+var_C68]
xor edi, edi
mov edx, 10h
call my_malloc
mov [rbp+var_C70], rax
cmp rax, 0
jnz short loc_9DFA0
jmp short $+2
loc_9DF91:
mov [rbp+var_C44], 0Ch
jmp loc_9E19E
loc_9DFA0:
mov edi, [rbp+var_C48]
mov rsi, [rbp+var_C70]
mov rdx, [rbp+var_C68]
xor eax, eax
mov ecx, eax
mov r8d, 4
call my_pread
cmp rax, 0
jz short loc_9DFDB
call _my_thread_var
mov eax, [rax]
mov [rbp+var_C54], eax
jmp loc_9E186
loc_9DFDB:
mov rdi, [rbp+var_C70]
mov eax, [rbp+var_C5C]
add rdi, rax
lea rsi, [rbp+var_C40]
add rsi, 360h
call _ma_base_info_read
mov cl, [rbp+var_7F4]
mov rax, [rbp+var_C50]
mov [rax+1Dh], cl
mov rdx, [rbp+var_520]
and rdx, 800h
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
mov cl, al
mov rax, [rbp+var_C50]
mov [rax+1Ch], cl
mov rax, [rbp+var_C50]
movsx ecx, byte ptr [rax+1Dh]
xor eax, eax
cmp ecx, 0
mov [rbp+var_C71], al
jz short loc_9E065
mov rax, [rbp+var_C50]
movsx eax, byte ptr [rax+1Ch]
cmp eax, 0
setnz al
mov [rbp+var_C71], al
loc_9E065:
mov al, [rbp+var_C71]
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_C50]
mov [rax+1Fh], cl
mov rcx, [rbp+var_8E0]
mov rax, [rbp+var_C50]
mov [rax], rcx
movsx edx, [rbp+var_7F4]
xor ecx, ecx
mov eax, 0Dh
cmp edx, 0
cmovnz ecx, eax
add ecx, 1
add ecx, 1
add ecx, 2
mov rax, [rbp+var_C50]
mov [rax+14h], ecx
mov ecx, [rbp+var_824]
mov rax, [rbp+var_C50]
mov [rax+10h], ecx
movzx ecx, [rbp+var_C2A]
mov rax, [rbp+var_C50]
mov [rax+18h], ecx
mov rcx, [rbp+var_880]
mov rax, [rbp+var_C50]
mov [rax+20h], rcx
mov eax, [rbp+var_810]
mov cl, al
mov rax, [rbp+var_C50]
mov [rax+28h], cl
mov edx, [rbp+var_818]
and edx, 1
xor eax, eax
mov ecx, 1
cmp edx, 0
cmovnz eax, ecx
mov cl, al
mov rax, [rbp+var_C50]
mov [rax+1Eh], cl
movzx eax, [rbp+var_C2A]
cmp eax, 3
jnz short loc_9E15E
mov rax, [rbp+var_C50]
mov eax, [rax+10h]
sub eax, 4
mov ecx, 6
xor edx, edx
div ecx
mov [rbp+var_C60], eax
mov eax, [rbp+var_C60]
shl eax, 4
add eax, 1
mov eax, eax
mov ecx, eax
mov rax, [rbp+var_C50]
mov [rax+8], rcx
loc_9E15E:
movzx eax, [rbp+var_C2A]
cmp eax, 3
jz short loc_9E184
mov rax, [rbp+var_C50]
movsx eax, byte ptr [rax+1Fh]
cmp eax, 0
jz short loc_9E184
mov [rbp+var_C54], 82h
loc_9E184:
jmp short $+2
loc_9E186:
mov rdi, [rbp+var_C70]
call my_free
mov eax, [rbp+var_C54]
mov [rbp+var_C44], eax
loc_9E19E:
mov eax, [rbp+var_C44]
mov [rbp+var_C78], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_9E1CB
mov eax, [rbp+var_C78]
add rsp, 0C80h
pop rbp
retn
loc_9E1CB:
call ___stack_chk_fail
|
long long aria_get_capabilities(unsigned int a1, long long a2)
{
int v2; // ecx
bool v4; // [rsp+Fh] [rbp-C71h]
const char *v5; // [rsp+10h] [rbp-C70h]
long long v6; // [rsp+18h] [rbp-C68h]
int v7; // [rsp+24h] [rbp-C5Ch]
unsigned int v8; // [rsp+2Ch] [rbp-C54h]
int v10; // [rsp+40h] [rbp-C40h] BYREF
unsigned __int16 v11; // [rsp+44h] [rbp-C3Ch]
unsigned __int16 v12; // [rsp+46h] [rbp-C3Ah]
unsigned __int16 v13; // [rsp+4Ch] [rbp-C34h]
unsigned __int8 v14; // [rsp+56h] [rbp-C2Ah]
_QWORD v15[23]; // [rsp+3A0h] [rbp-8E0h] BYREF
int v16; // [rsp+45Ch] [rbp-824h]
int v17; // [rsp+468h] [rbp-818h]
int v18; // [rsp+470h] [rbp-810h]
char v19; // [rsp+48Ch] [rbp-7F4h]
long long v20; // [rsp+760h] [rbp-520h]
unsigned long long v21; // [rsp+C78h] [rbp-8h]
v21 = __readfsqword(0x28u);
v8 = 0;
memset(a2, 0LL, 48LL);
if ( my_pread(a1, &v10, 24LL, 0LL, 4LL) )
{
return 130;
}
else if ( v10 == maria_file_magic )
{
v20 = _byteswap_ushort(v11);
v6 = _byteswap_ushort(v12);
v7 = _byteswap_ushort(v13);
v5 = (const char *)my_malloc(0LL, v6, 16LL);
if ( v5 )
{
if ( my_pread(a1, v5, v6, 0LL, 4LL) )
{
v8 = *(_DWORD *)my_thread_var(a1, v5);
}
else
{
ma_base_info_read(&v5[v7], v15);
*(_BYTE *)(a2 + 29) = v19;
*(_BYTE *)(a2 + 28) = (v20 & 0x800) != 0;
v4 = 0;
if ( *(_BYTE *)(a2 + 29) )
v4 = *(_BYTE *)(a2 + 28) != 0;
*(_BYTE *)(a2 + 31) = v4;
*(_QWORD *)a2 = v15[0];
v2 = 0;
if ( v19 )
v2 = 13;
*(_DWORD *)(a2 + 20) = v2 + 4;
*(_DWORD *)(a2 + 16) = v16;
*(_DWORD *)(a2 + 24) = v14;
*(_QWORD *)(a2 + 32) = v15[12];
*(_BYTE *)(a2 + 40) = v18;
*(_BYTE *)(a2 + 30) = (v17 & 1) != 0;
if ( v14 == 3 )
*(_QWORD *)(a2 + 8) = 16 * ((*(_DWORD *)(a2 + 16) - 4) / 6u) + 1;
if ( v14 != 3 && *(_BYTE *)(a2 + 31) )
v8 = 130;
}
my_free(v5);
return v8;
}
else
{
return 12;
}
}
else
{
return 130;
}
}
|
aria_get_capabilities:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc48],EDI
MOV qword ptr [RBP + -0xc50],RSI
MOV dword ptr [RBP + -0xc54],0x0
MOV dword ptr [RBP + -0xc58],0x18
MOV RDI,qword ptr [RBP + -0xc50]
XOR ESI,ESI
MOV EDX,0x30
CALL 0x0012a2c0
MOV EDI,dword ptr [RBP + -0xc48]
LEA RSI,[RBP + -0xc40]
MOV EAX,dword ptr [RBP + -0xc58]
MOV EDX,EAX
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0x4
CALL 0x001f59e0
CMP RAX,0x0
JZ 0x0019ded7
JMP 0x0019dec8
LAB_0019dec8:
MOV dword ptr [RBP + -0xc44],0x82
JMP 0x0019e19e
LAB_0019ded7:
LEA RAX,[RBP + -0xc40]
LEA RCX,[0x3be290]
MOV ECX,dword ptr [RCX]
MOV EAX,dword ptr [RAX]
SUB EAX,ECX
SETNZ AL
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0019df07
JMP 0x0019def8
LAB_0019def8:
MOV dword ptr [RBP + -0xc44],0x82
JMP 0x0019e19e
LAB_0019df07:
MOVZX EAX,byte ptr [RBP + -0xc3b]
MOVZX EAX,AX
MOVZX ECX,byte ptr [RBP + -0xc3c]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV qword ptr [RBP + -0x520],RAX
MOVZX EAX,byte ptr [RBP + -0xc39]
MOVZX EAX,AX
MOVZX ECX,byte ptr [RBP + -0xc3a]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV qword ptr [RBP + -0xc68],RAX
MOVZX EAX,byte ptr [RBP + -0xc33]
MOVZX EAX,AX
MOVZX ECX,byte ptr [RBP + -0xc34]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0xc5c],EAX
MOV RSI,qword ptr [RBP + -0xc68]
XOR EDI,EDI
MOV EDX,0x10
CALL 0x001f4be0
MOV qword ptr [RBP + -0xc70],RAX
CMP RAX,0x0
JNZ 0x0019dfa0
JMP 0x0019df91
LAB_0019df91:
MOV dword ptr [RBP + -0xc44],0xc
JMP 0x0019e19e
LAB_0019dfa0:
MOV EDI,dword ptr [RBP + -0xc48]
MOV RSI,qword ptr [RBP + -0xc70]
MOV RDX,qword ptr [RBP + -0xc68]
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0x4
CALL 0x001f59e0
CMP RAX,0x0
JZ 0x0019dfdb
CALL 0x001f7440
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc54],EAX
JMP 0x0019e186
LAB_0019dfdb:
MOV RDI,qword ptr [RBP + -0xc70]
MOV EAX,dword ptr [RBP + -0xc5c]
ADD RDI,RAX
LEA RSI,[RBP + -0xc40]
ADD RSI,0x360
CALL 0x0019e1d0
MOV CL,byte ptr [RBP + -0x7f4]
MOV RAX,qword ptr [RBP + -0xc50]
MOV byte ptr [RAX + 0x1d],CL
MOV RDX,qword ptr [RBP + -0x520]
AND RDX,0x800
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xc50]
MOV byte ptr [RAX + 0x1c],CL
MOV RAX,qword ptr [RBP + -0xc50]
MOVSX ECX,byte ptr [RAX + 0x1d]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0xc71],AL
JZ 0x0019e065
MOV RAX,qword ptr [RBP + -0xc50]
MOVSX EAX,byte ptr [RAX + 0x1c]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xc71],AL
LAB_0019e065:
MOV AL,byte ptr [RBP + -0xc71]
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xc50]
MOV byte ptr [RAX + 0x1f],CL
MOV RCX,qword ptr [RBP + -0x8e0]
MOV RAX,qword ptr [RBP + -0xc50]
MOV qword ptr [RAX],RCX
MOVSX EDX,byte ptr [RBP + -0x7f4]
XOR ECX,ECX
MOV EAX,0xd
CMP EDX,0x0
CMOVNZ ECX,EAX
ADD ECX,0x1
ADD ECX,0x1
ADD ECX,0x2
MOV RAX,qword ptr [RBP + -0xc50]
MOV dword ptr [RAX + 0x14],ECX
MOV ECX,dword ptr [RBP + -0x824]
MOV RAX,qword ptr [RBP + -0xc50]
MOV dword ptr [RAX + 0x10],ECX
MOVZX ECX,byte ptr [RBP + -0xc2a]
MOV RAX,qword ptr [RBP + -0xc50]
MOV dword ptr [RAX + 0x18],ECX
MOV RCX,qword ptr [RBP + -0x880]
MOV RAX,qword ptr [RBP + -0xc50]
MOV qword ptr [RAX + 0x20],RCX
MOV EAX,dword ptr [RBP + -0x810]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xc50]
MOV byte ptr [RAX + 0x28],CL
MOV EDX,dword ptr [RBP + -0x818]
AND EDX,0x1
XOR EAX,EAX
MOV ECX,0x1
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xc50]
MOV byte ptr [RAX + 0x1e],CL
MOVZX EAX,byte ptr [RBP + -0xc2a]
CMP EAX,0x3
JNZ 0x0019e15e
MOV RAX,qword ptr [RBP + -0xc50]
MOV EAX,dword ptr [RAX + 0x10]
SUB EAX,0x4
MOV ECX,0x6
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0xc60],EAX
MOV EAX,dword ptr [RBP + -0xc60]
SHL EAX,0x4
ADD EAX,0x1
MOV EAX,EAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xc50]
MOV qword ptr [RAX + 0x8],RCX
LAB_0019e15e:
MOVZX EAX,byte ptr [RBP + -0xc2a]
CMP EAX,0x3
JZ 0x0019e184
MOV RAX,qword ptr [RBP + -0xc50]
MOVSX EAX,byte ptr [RAX + 0x1f]
CMP EAX,0x0
JZ 0x0019e184
MOV dword ptr [RBP + -0xc54],0x82
LAB_0019e184:
JMP 0x0019e186
LAB_0019e186:
MOV RDI,qword ptr [RBP + -0xc70]
CALL 0x001f4f60
MOV EAX,dword ptr [RBP + -0xc54]
MOV dword ptr [RBP + -0xc44],EAX
LAB_0019e19e:
MOV EAX,dword ptr [RBP + -0xc44]
MOV dword ptr [RBP + -0xc78],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0019e1cb
MOV EAX,dword ptr [RBP + -0xc78]
ADD RSP,0xc80
POP RBP
RET
LAB_0019e1cb:
CALL 0x0012a270
|
int4 aria_get_capabilities(int4 param_1,int8 *param_2)
{
long lVar1;
long lVar2;
int4 *puVar3;
int iVar4;
long in_FS_OFFSET;
bool local_c79;
int4 local_c5c;
int4 local_c4c;
int local_c48;
int1 local_c44;
int1 local_c43;
int1 local_c42;
int1 local_c41;
int1 local_c3c;
int1 local_c3b;
byte local_c32;
int8 local_8e8 [12];
int8 local_888;
int4 local_82c;
uint local_820;
int1 local_818;
char local_7fc;
ulong local_528;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_c5c = 0;
memset(param_2,0,0x30);
lVar1 = my_pread(param_1,&local_c48,0x18,0,4);
if (lVar1 == 0) {
if (local_c48 == maria_file_magic) {
local_528 = (ulong)CONCAT11(local_c44,local_c43);
lVar1 = my_malloc(0,CONCAT11(local_c42,local_c41),0x10);
if (lVar1 == 0) {
local_c4c = 0xc;
}
else {
lVar2 = my_pread(param_1,lVar1,CONCAT11(local_c42,local_c41),0,4);
if (lVar2 == 0) {
_ma_base_info_read(lVar1 + (ulong)CONCAT11(local_c3c,local_c3b),local_8e8);
*(char *)((long)param_2 + 0x1d) = local_7fc;
*(bool *)((long)param_2 + 0x1c) = (local_528 & 0x800) != 0;
local_c79 = false;
if (*(char *)((long)param_2 + 0x1d) != '\0') {
local_c79 = *(char *)((long)param_2 + 0x1c) != '\0';
}
*(bool *)((long)param_2 + 0x1f) = local_c79;
*param_2 = local_8e8[0];
iVar4 = 0;
if (local_7fc != '\0') {
iVar4 = 0xd;
}
*(int *)((long)param_2 + 0x14) = iVar4 + 4;
*(int4 *)(param_2 + 2) = local_82c;
*(uint *)(param_2 + 3) = (uint)local_c32;
param_2[4] = local_888;
*(int1 *)(param_2 + 5) = local_818;
*(bool *)((long)param_2 + 0x1e) = (local_820 & 1) != 0;
if (local_c32 == 3) {
param_2[1] = (ulong)(((*(int *)(param_2 + 2) - 4U) / 6) * 0x10 + 1);
}
else if (*(char *)((long)param_2 + 0x1f) != '\0') {
local_c5c = 0x82;
}
}
else {
puVar3 = (int4 *)_my_thread_var();
local_c5c = *puVar3;
}
my_free(lVar1);
local_c4c = local_c5c;
}
}
else {
local_c4c = 0x82;
}
}
else {
local_c4c = 0x82;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_c4c;
}
|
|
66,473 |
JS_LoadModule
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_LoadModule(JSContext *ctx, const char *basename,
const char *filename)
{
JSValue promise, resolving_funcs[2];
promise = JS_NewPromiseCapability(ctx, resolving_funcs);
if (JS_IsException(promise))
return JS_EXCEPTION;
JS_LoadModuleInternal(ctx, basename, filename,
(JSValueConst *)resolving_funcs);
JS_FreeValue(ctx, resolving_funcs[0]);
JS_FreeValue(ctx, resolving_funcs[1]);
return promise;
}
|
O0
|
c
|
JS_LoadModule:
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x50780
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x50715
movl $0x0, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
jmp 0x5076a
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x507e0
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x29f80
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x29f80
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rdx
addq $0x68, %rsp
retq
nopl (%rax)
|
JS_LoadModule:
sub rsp, 68h
mov [rsp+68h+var_18], rdi
mov [rsp+68h+var_20], rsi
mov [rsp+68h+var_28], rdx
mov rdi, [rsp+68h+var_18]
lea rsi, [rsp+68h+var_58]
call JS_NewPromiseCapability
mov [rsp+68h+var_68], rax
mov [rsp+68h+var_60], rdx
mov rax, [rsp+68h+var_68]
mov [rsp+68h+var_38], rax
mov rax, [rsp+68h+var_60]
mov [rsp+68h+var_30], rax
mov rdi, [rsp+68h+var_38]
mov rsi, [rsp+68h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_50715
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 6
jmp short loc_5076A
loc_50715:
mov rdi, [rsp+68h+var_18]
mov rsi, [rsp+68h+var_20]
mov rdx, [rsp+68h+var_28]
lea rcx, [rsp+68h+var_58]
call JS_LoadModuleInternal
mov rdi, [rsp+68h+var_18]
mov rsi, [rsp+68h+var_58]
mov rdx, [rsp+68h+var_50]
call JS_FreeValue
mov rdi, [rsp+68h+var_18]
mov rsi, [rsp+68h+var_48]
mov rdx, [rsp+68h+var_40]
call JS_FreeValue
mov rax, [rsp+68h+var_38]
mov [rsp+68h+var_10], rax
mov rax, [rsp+68h+var_30]
mov [rsp+68h+var_8], rax
loc_5076A:
mov rax, [rsp+68h+var_10]
mov rdx, [rsp+68h+var_8]
add rsp, 68h
retn
|
long long JS_LoadModule(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long v5[4]; // [rsp+10h] [rbp-58h] BYREF
long long v6; // [rsp+30h] [rbp-38h]
long long v7; // [rsp+38h] [rbp-30h]
long long v8; // [rsp+40h] [rbp-28h]
long long v9; // [rsp+48h] [rbp-20h]
long long v10; // [rsp+50h] [rbp-18h]
long long v11; // [rsp+58h] [rbp-10h]
long long v12; // [rsp+60h] [rbp-8h]
v10 = a1;
v9 = a2;
v8 = a3;
v6 = JS_NewPromiseCapability(a1, v5);
v7 = v3;
if ( JS_IsException_1(v6, v3) )
{
LODWORD(v11) = 0;
v12 = 6LL;
}
else
{
JS_LoadModuleInternal(v10, v9, v8, v5);
JS_FreeValue(v10, v5[0], v5[1]);
JS_FreeValue(v10, v5[2], v5[3]);
v11 = v6;
v12 = v7;
}
return v11;
}
|
JS_LoadModule:
SUB RSP,0x68
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV RDI,qword ptr [RSP + 0x50]
LEA RSI,[RSP + 0x10]
CALL 0x00150780
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x00150715
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x6
JMP 0x0015076a
LAB_00150715:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x40]
LEA RCX,[RSP + 0x10]
CALL 0x001507e0
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x00129f80
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x60],RAX
LAB_0015076a:
MOV RAX,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
ADD RSP,0x68
RET
|
int1 [16] JS_LoadModule(int8 param_1,int8 param_2,int8 param_3)
{
int1 auVar1 [16];
int iVar2;
int8 local_58;
int8 local_50;
int8 local_48;
int8 local_40;
int1 local_38 [16];
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_38 = JS_NewPromiseCapability(param_1,&local_58);
iVar2 = JS_IsException(local_38._0_8_,local_38._8_8_);
if (iVar2 == 0) {
JS_LoadModuleInternal(local_18,local_20,local_28,&local_58);
JS_FreeValue(local_18,local_58,local_50);
JS_FreeValue(local_18,local_48,local_40);
local_10 = local_38._0_4_;
uStack_c = local_38._4_4_;
local_8 = local_38._8_8_;
}
else {
local_10 = 0;
local_8 = 6;
}
auVar1._4_4_ = uStack_c;
auVar1._0_4_ = local_10;
auVar1._8_8_ = local_8;
return auVar1;
}
|
|
66,474 |
JS_LoadModule
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_LoadModule(JSContext *ctx, const char *basename,
const char *filename)
{
JSValue promise, resolving_funcs[2];
promise = JS_NewPromiseCapability(ctx, resolving_funcs);
if (JS_IsException(promise))
return JS_EXCEPTION;
JS_LoadModuleInternal(ctx, basename, filename,
(JSValueConst *)resolving_funcs);
JS_FreeValue(ctx, resolving_funcs[0]);
JS_FreeValue(ctx, resolving_funcs[1]);
return promise;
}
|
O2
|
c
|
JS_LoadModule:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq %rsp, %rsi
callq 0x2d11d
movq %rdx, %rbx
cmpl $0x6, %ebx
jne 0x2d0d1
pushq $0x6
popq %rbx
xorl %r14d, %r14d
jmp 0x2d108
movq %rax, %r14
movq %rsp, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x2d127
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %r15, %rdi
callq 0x1bbce
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rdx
movq %r15, %rdi
callq 0x1bbce
movq %r14, %rax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
JS_LoadModule:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, rdx
mov r13, rsi
mov r15, rdi
mov rsi, rsp
call JS_NewPromiseCapability
mov rbx, rdx
cmp ebx, 6
jnz short loc_2D0D1
push 6
pop rbx
xor r14d, r14d
jmp short loc_2D108
loc_2D0D1:
mov r14, rax
mov rbp, rsp
mov rdi, r15
mov rsi, r13
mov rdx, r12
mov rcx, rbp
call JS_LoadModuleInternal
mov rsi, [rbp+0]
mov rdx, [rbp+8]
mov rdi, r15
call JS_FreeValue
mov rsi, [rbp+10h]
mov rdx, [rbp+18h]
mov rdi, r15
call JS_FreeValue
loc_2D108:
mov rax, r14
mov rdx, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long JS_LoadModule(long long a1, long long a2, long long a3)
{
long long v4; // rax
int v5; // edx
long long v6; // r14
long long v8[11]; // [rsp+0h] [rbp-58h] BYREF
v4 = JS_NewPromiseCapability(a1, v8);
if ( v5 == 6 )
return 0LL;
v6 = v4;
JS_LoadModuleInternal(a1, a2, a3, v8);
JS_FreeValue(a1, v8[0], v8[1]);
JS_FreeValue(a1, v8[2], v8[3]);
return v6;
}
|
JS_LoadModule:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,RDX
MOV R13,RSI
MOV R15,RDI
MOV RSI,RSP
CALL 0x0012d11d
MOV RBX,RDX
CMP EBX,0x6
JNZ 0x0012d0d1
PUSH 0x6
POP RBX
XOR R14D,R14D
JMP 0x0012d108
LAB_0012d0d1:
MOV R14,RAX
MOV RBP,RSP
MOV RDI,R15
MOV RSI,R13
MOV RDX,R12
MOV RCX,RBP
CALL 0x0012d127
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
MOV RDI,R15
CALL 0x0011bbce
MOV RSI,qword ptr [RBP + 0x10]
MOV RDX,qword ptr [RBP + 0x18]
MOV RDI,R15
CALL 0x0011bbce
LAB_0012d108:
MOV RAX,R14
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] JS_LoadModule(int8 param_1,int8 param_2,int8 param_3)
{
int1 auVar1 [16];
int8 local_58;
int8 local_50;
int8 local_48;
int8 local_40;
auVar1 = JS_NewPromiseCapability(param_1,&local_58);
if (auVar1._8_4_ == 6) {
auVar1 = ZEXT816(6) << 0x40;
}
else {
JS_LoadModuleInternal(param_1,param_2,param_3,&local_58);
JS_FreeValue(param_1,local_58,local_50);
JS_FreeValue(param_1,local_48,local_40);
}
return auVar1;
}
|
|
66,475 |
LefDefParser::defiComponent::reverseNetOrder()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiComponent.cpp
|
void defiComponent::reverseNetOrder() {
// Reverse the order of the items in the nets array.
int one = 0;
int two = numNets_ - 1;
char* t;
while (one < two) {
t = nets_[one];
nets_[one] = nets_[two];
nets_[two] = t;
one++;
two--;
}
}
|
O0
|
cpp
|
LefDefParser::defiComponent::reverseNetOrder():
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0xc(%rsp)
movl 0x7c(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
cmpl -0x10(%rsp), %eax
jge 0x15f02
movq -0x20(%rsp), %rax
movq 0x88(%rax), %rcx
movslq -0xc(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x18(%rsp)
movq 0x88(%rax), %rcx
movslq -0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x88(%rax), %rcx
movslq -0xc(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x18(%rsp), %rdx
movq 0x88(%rax), %rax
movslq -0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x15e91
retq
nopw %cs:(%rax,%rax)
|
_ZN12LefDefParser13defiComponent15reverseNetOrderEv:
mov [rsp+var_8], rdi
mov rax, [rsp+var_8]
mov [rsp+var_20], rax
mov [rsp+var_C], 0
mov eax, [rax+7Ch]
sub eax, 1
mov [rsp+var_10], eax
loc_15E91:
mov eax, [rsp+var_C]
cmp eax, [rsp+var_10]
jge short locret_15F02
mov rax, [rsp+var_20]
mov rcx, [rax+88h]
movsxd rdx, [rsp+var_C]
mov rcx, [rcx+rdx*8]
mov [rsp+var_18], rcx
mov rcx, [rax+88h]
movsxd rdx, [rsp+var_10]
mov rsi, [rcx+rdx*8]
mov rcx, [rax+88h]
movsxd rdx, [rsp+var_C]
mov [rcx+rdx*8], rsi
mov rdx, [rsp+var_18]
mov rax, [rax+88h]
movsxd rcx, [rsp+var_10]
mov [rax+rcx*8], rdx
mov eax, [rsp+var_C]
add eax, 1
mov [rsp+var_C], eax
mov eax, [rsp+var_10]
add eax, 0FFFFFFFFh
mov [rsp+var_10], eax
jmp short loc_15E91
locret_15F02:
retn
|
long long LefDefParser::defiComponent::reverseNetOrder(LefDefParser::defiComponent *this)
{
long long result; // rax
long long v2; // [rsp+8h] [rbp-18h]
int i; // [rsp+10h] [rbp-10h]
int v4; // [rsp+14h] [rbp-Ch]
v4 = 0;
for ( i = *((_DWORD *)this + 31) - 1; ; --i )
{
result = (unsigned int)v4;
if ( v4 >= i )
break;
v2 = *(_QWORD *)(*((_QWORD *)this + 17) + 8LL * v4);
*(_QWORD *)(*((_QWORD *)this + 17) + 8LL * v4) = *(_QWORD *)(*((_QWORD *)this + 17) + 8LL * i);
*(_QWORD *)(*((_QWORD *)this + 17) + 8LL * i) = v2;
++v4;
}
return result;
}
|
reverseNetOrder:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
MOV qword ptr [RSP + -0x20],RAX
MOV dword ptr [RSP + -0xc],0x0
MOV EAX,dword ptr [RAX + 0x7c]
SUB EAX,0x1
MOV dword ptr [RSP + -0x10],EAX
LAB_00115e91:
MOV EAX,dword ptr [RSP + -0xc]
CMP EAX,dword ptr [RSP + -0x10]
JGE 0x00115f02
MOV RAX,qword ptr [RSP + -0x20]
MOV RCX,qword ptr [RAX + 0x88]
MOVSXD RDX,dword ptr [RSP + -0xc]
MOV RCX,qword ptr [RCX + RDX*0x8]
MOV qword ptr [RSP + -0x18],RCX
MOV RCX,qword ptr [RAX + 0x88]
MOVSXD RDX,dword ptr [RSP + -0x10]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RAX + 0x88]
MOVSXD RDX,dword ptr [RSP + -0xc]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RDX,qword ptr [RSP + -0x18]
MOV RAX,qword ptr [RAX + 0x88]
MOVSXD RCX,dword ptr [RSP + -0x10]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV EAX,dword ptr [RSP + -0xc]
ADD EAX,0x1
MOV dword ptr [RSP + -0xc],EAX
MOV EAX,dword ptr [RSP + -0x10]
ADD EAX,-0x1
MOV dword ptr [RSP + -0x10],EAX
JMP 0x00115e91
LAB_00115f02:
RET
|
/* LefDefParser::defiComponent::reverseNetOrder() */
void __thiscall LefDefParser::defiComponent::reverseNetOrder(defiComponent *this)
{
int8 uVar1;
int local_10;
int local_c;
local_c = 0;
local_10 = *(int *)(this + 0x7c);
for (; local_10 = local_10 + -1, local_c < local_10; local_c = local_c + 1) {
uVar1 = *(int8 *)(*(long *)(this + 0x88) + (long)local_c * 8);
*(int8 *)(*(long *)(this + 0x88) + (long)local_c * 8) =
*(int8 *)(*(long *)(this + 0x88) + (long)local_10 * 8);
*(int8 *)(*(long *)(this + 0x88) + (long)local_10 * 8) = uVar1;
}
return;
}
|
|
66,476 |
process_str_arg
|
eloqsql/strings/my_vsnprintf.c
|
static char *process_str_arg(CHARSET_INFO *cs, char *to, const char *end,
longlong length_arg, size_t width, char *par,
uint print_type, my_bool nice_cut)
{
int well_formed_error;
uint dots= 0;
size_t plen, left_len= (size_t) (end - to) + 1, slen=0;
my_bool left_fill= 1;
size_t length;
/*
The sign of the length argument specific the string should be right
or left adjusted
*/
if (length_arg < 0)
{
length= (size_t) -length_arg;
left_fill= 0;
}
else
length= (size_t) length_arg;
if (!par)
par = (char*) "(null)";
if (nice_cut)
{
plen= slen= strnlen(par, width + 1);
if (plen > width)
plen= width;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
if ((slen > plen))
{
if (plen < 3)
{
dots= (uint) plen;
plen= 0;
}
else
{
dots= 3;
plen-= 3;
}
}
}
else
{
plen= slen= strnlen(par, width);
dots= 0;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
}
plen= my_well_formed_length(cs, par, par + plen, width, &well_formed_error);
if (print_type & ESCAPED_ARG)
{
const char *org_to= to;
to= backtick_string(cs, to, end, par, plen + dots, '`', MY_TEST(dots));
plen= (size_t) (to - org_to);
dots= 0;
}
else
{
if (left_fill)
{
if (plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
}
to= strnmov(to,par,plen);
if (dots)
to= strfill(to, dots, '.');
}
if (!left_fill && plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
return to;
}
|
O3
|
c
|
process_str_arg:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movq %rdi, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
subq %rsi, %r14
leaq 0x1(%r14), %rbx
movq %rcx, %r13
negq %r13
movq %rcx, -0x40(%rbp)
cmovsq %rcx, %r13
testq %r9, %r9
leaq 0x643c(%rip), %r12 # 0x8187e
cmovneq %r9, %r12
cmpb $0x0, 0x18(%rbp)
je 0x7b48a
leaq 0x1(%r15), %rsi
movq %r12, %rdi
callq 0x26570
cmpq %r15, %rax
movq %r15, %rdx
cmovbq %rax, %rdx
cmpq %rdx, %rbx
cmovbeq %r14, %rdx
cmovbeq %r14, %r13
movl $0x0, -0x2c(%rbp)
cmpq %rdx, %rax
movq %r13, -0x48(%rbp)
jbe 0x7b4bb
cmpq $0x2, %rdx
ja 0x7b4b0
movl %edx, -0x2c(%rbp)
xorl %edx, %edx
jmp 0x7b4bb
movq %r12, %rdi
movq %r15, %rsi
callq 0x26570
movq %rax, %rdx
cmpq %rax, %rbx
cmovbeq %r14, %rdx
cmovbeq %r14, %r13
movq %r13, -0x48(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0x7b4bb
addq $-0x3, %rdx
movl $0x3, -0x2c(%rbp)
addq %r12, %rdx
movq -0x58(%rbp), %rdi
movq 0xb8(%rdi), %rax
leaq -0x70(%rbp), %rbx
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
callq *0xc8(%rax)
movq (%rbx), %r13
subq %r12, %r13
movl 0x10(%rbp), %eax
testb $0x8, %al
jne 0x7b523
movq -0x40(%rbp), %rbx
testq %rbx, %rbx
js 0x7b5f6
movl -0x2c(%rbp), %r14d
movl %r14d, %eax
addq %r13, %rax
movq -0x48(%rbp), %rsi
subq %rax, %rsi
jbe 0x7b600
movq -0x38(%rbp), %rdi
movl $0x20, %edx
callq 0x7bd28
movq %rax, %rdi
jmp 0x7b604
movl -0x2c(%rbp), %eax
addq %rax, %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x60(%rbp)
cmpq %r13, %r14
jbe 0x7b680
movq -0x38(%rbp), %rax
leaq 0x1(%rax), %r15
movb $0x60, (%rax)
testq %r13, %r13
jle 0x7b62f
addq %r12, %r13
xorl %r14d, %r14d
cmpl $0x0, -0x2c(%rbp)
je 0x7b586
movl %r14d, %eax
movq %r15, -0x70(%rbp,%rax,8)
movl %r14d, %eax
incl %eax
movl $0xaaaaaaab, %ecx # imm = 0xAAAAAAAB
imulq %rcx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
negl %eax
addl %eax, %r14d
incl %r14d
movb (%r12), %bl
movq -0x58(%rbp), %rdi
movq 0xb8(%rdi), %rax
movq %r12, %rsi
movq %r13, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
movl $0x1, %ecx
cmovll %ecx, %eax
jge 0x7b5c7
cmpb $0x60, %bl
jne 0x7b5c7
leaq 0x1(%r15), %rdi
cmpq -0x50(%rbp), %rdi
jae 0x7b680
movb $0x60, (%r15)
jmp 0x7b5ca
movq %r15, %rdi
movl %eax, %ebx
leaq (%rdi,%rbx), %rax
cmpq -0x50(%rbp), %rax
jae 0x7b680
movq %r12, %rsi
movq %rbx, %rdx
callq 0x7bd88
movq %rax, %r15
addq %rbx, %r12
cmpq %r13, %r12
jb 0x7b55b
jmp 0x7b632
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %r14d
jmp 0x7b604
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x7bd88
movq %rax, %r15
testl %r14d, %r14d
je 0x7b694
movl %r14d, %r14d
movq %r15, %rdi
movq %r14, %rsi
movl $0x2e, %edx
callq 0x7bd28
movq %rax, %r15
jmp 0x7b697
xorl %r14d, %r14d
leaq 0x1(%r15), %rax
cmpq -0x50(%rbp), %rax
jae 0x7b680
cmpl $0x0, -0x2c(%rbp)
je 0x7b6e2
subl $0x1, %r14d
movl $0x2, %eax
cmovbl %eax, %r14d
movq -0x70(%rbp,%r14,8), %rdx
testq %rdx, %rdx
je 0x7b680
movl $0x1, %ecx
subl $0x1, %r14d
cmovbl %eax, %r14d
movq -0x70(%rbp,%r14,8), %r15
testq %r15, %r15
je 0x7b6ca
incl %ecx
movq %r15, %rdx
cmpl $0x3, %ecx
jne 0x7b662
jmp 0x7b6cd
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq %rax, %r15
movq -0x40(%rbp), %rbx
movq %r15, %r13
subq %rax, %r13
xorl %r14d, %r14d
testq %rbx, %rbx
jns 0x7b6b8
addq %r14, %r13
movq -0x48(%rbp), %rsi
subq %r13, %rsi
jbe 0x7b6b8
movq %r15, %rdi
movl $0x20, %edx
callq 0x7bd28
movq %rax, %r15
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movl %ecx, %ebx
movq %r15, %rdi
movl $0x2e, %esi
movq %rbx, %rdx
callq 0x261c0
addq %rbx, %r15
movb $0x60, (%r15)
incq %r15
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %rax
jmp 0x7b68e
|
process_str_arg:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, r8
mov [rbp+var_58], rdi
mov [rbp+var_50], rdx
mov r14, rdx
mov [rbp+var_38], rsi
sub r14, rsi
lea rbx, [r14+1]
mov r13, rcx
neg r13
mov [rbp+var_40], rcx
cmovs r13, rcx
test r9, r9
lea r12, aNull; "(null)"
cmovnz r12, r9
cmp [rbp+arg_8], 0
jz short loc_7B48A
lea rsi, [r15+1]
mov rdi, r12
call _strnlen
cmp rax, r15
mov rdx, r15
cmovb rdx, rax
cmp rbx, rdx
cmovbe rdx, r14
cmovbe r13, r14
mov [rbp+var_2C], 0
cmp rax, rdx
mov [rbp+var_48], r13
jbe short loc_7B4BB
cmp rdx, 2
ja short loc_7B4B0
mov [rbp+var_2C], edx
xor edx, edx
jmp short loc_7B4BB
loc_7B48A:
mov rdi, r12
mov rsi, r15
call _strnlen
mov rdx, rax
cmp rbx, rax
cmovbe rdx, r14
cmovbe r13, r14
mov [rbp+var_48], r13
mov [rbp+var_2C], 0
jmp short loc_7B4BB
loc_7B4B0:
add rdx, 0FFFFFFFFFFFFFFFDh
mov [rbp+var_2C], 3
loc_7B4BB:
add rdx, r12
mov rdi, [rbp+var_58]
mov rax, [rdi+0B8h]
lea rbx, [rbp+var_70]
mov rsi, r12
mov rcx, r15
mov r8, rbx
call qword ptr [rax+0C8h]
mov r13, [rbx]
sub r13, r12
mov eax, [rbp+arg_0]
test al, 8
jnz short loc_7B523
mov rbx, [rbp+var_40]
test rbx, rbx
js loc_7B5F6
mov r14d, [rbp+var_2C]
mov eax, r14d
add rax, r13
mov rsi, [rbp+var_48]
sub rsi, rax
jbe loc_7B600
mov rdi, [rbp+var_38]
mov edx, 20h ; ' '
call strfill
mov rdi, rax
jmp loc_7B604
loc_7B523:
mov eax, [rbp+var_2C]
add r13, rax
xorps xmm0, xmm0
movaps [rbp+var_70], xmm0
mov [rbp+var_60], 0
cmp r14, r13
jbe loc_7B680
mov rax, [rbp+var_38]
lea r15, [rax+1]
mov byte ptr [rax], 60h ; '`'
test r13, r13
jle loc_7B62F
add r13, r12
xor r14d, r14d
loc_7B55B:
cmp [rbp+var_2C], 0
jz short loc_7B586
mov eax, r14d
mov qword ptr [rbp+rax*8+var_70], r15
mov eax, r14d
inc eax
mov ecx, 0AAAAAAABh
imul rax, rcx
shr rax, 21h
lea eax, [rax+rax*2]
neg eax
add r14d, eax
inc r14d
loc_7B586:
mov bl, [r12]
mov rdi, [rbp+var_58]
mov rax, [rdi+0B8h]
mov rsi, r12
mov rdx, r13
call qword ptr [rax+0C0h]
cmp eax, 2
mov ecx, 1
cmovl eax, ecx
jge short loc_7B5C7
cmp bl, 60h ; '`'
jnz short loc_7B5C7
lea rdi, [r15+1]
cmp rdi, [rbp+var_50]
jnb loc_7B680
mov byte ptr [r15], 60h ; '`'
jmp short loc_7B5CA
loc_7B5C7:
mov rdi, r15
loc_7B5CA:
mov ebx, eax
lea rax, [rdi+rbx]
cmp rax, [rbp+var_50]
jnb loc_7B680
mov rsi, r12
mov rdx, rbx
call strnmov
mov r15, rax
add r12, rbx
cmp r12, r13
jb loc_7B55B
jmp short loc_7B632
loc_7B5F6:
mov rdi, [rbp+var_38]
mov r14d, [rbp+var_2C]
jmp short loc_7B604
loc_7B600:
mov rdi, [rbp+var_38]
loc_7B604:
mov rsi, r12
mov rdx, r13
call strnmov
mov r15, rax
test r14d, r14d
jz short loc_7B694
mov r14d, r14d
mov rdi, r15
mov rsi, r14
mov edx, 2Eh ; '.'
call strfill
mov r15, rax
jmp short loc_7B697
loc_7B62F:
xor r14d, r14d
loc_7B632:
lea rax, [r15+1]
cmp rax, [rbp+var_50]
jnb short loc_7B680
cmp [rbp+var_2C], 0
jz loc_7B6E2
sub r14d, 1
mov eax, 2
cmovb r14d, eax
mov rdx, qword ptr [rbp+r14*8+var_70]
test rdx, rdx
jz short loc_7B680
mov ecx, 1
loc_7B662:
sub r14d, 1
cmovb r14d, eax
mov r15, qword ptr [rbp+r14*8+var_70]
test r15, r15
jz short loc_7B6CA
inc ecx
mov rdx, r15
cmp ecx, 3
jnz short loc_7B662
jmp short loc_7B6CD
loc_7B680:
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov r15, rax
mov rbx, [rbp+var_40]
loc_7B68E:
mov r13, r15
sub r13, rax
loc_7B694:
xor r14d, r14d
loc_7B697:
test rbx, rbx
jns short loc_7B6B8
add r13, r14
mov rsi, [rbp+var_48]
sub rsi, r13
jbe short loc_7B6B8
mov rdi, r15
mov edx, 20h ; ' '
call strfill
mov r15, rax
loc_7B6B8:
mov rax, r15
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7B6CA:
mov r15, rdx
loc_7B6CD:
mov ebx, ecx
mov rdi, r15
mov esi, 2Eh ; '.'
mov rdx, rbx
call _memset
add r15, rbx
loc_7B6E2:
mov byte ptr [r15], 60h ; '`'
inc r15
mov rbx, [rbp+var_40]
mov rax, [rbp+var_38]
jmp short loc_7B68E
|
long long process_str_arg(
long long a1,
_BYTE *a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
const char *a6,
char a7,
char a8)
{
unsigned long long v9; // r14
unsigned long long v10; // rbx
long long v11; // r13
const char *v12; // r12
unsigned long long v13; // rax
unsigned long long v14; // rdx
long long v15; // rcx
long long v16; // r8
long long v17; // r9
long long v18; // r13
long long v19; // rbx
long long v20; // r14
unsigned long long v21; // rax
long long v22; // rdi
long long v23; // r13
_BYTE *v24; // r15
const char *v25; // r13
unsigned int v26; // r14d
char v27; // bl
unsigned int v28; // eax
_BYTE *v29; // rdi
long long v30; // rbx
long long v31; // rax
long long v32; // r15
bool v33; // cf
long long v34; // r14
long long v35; // rdx
unsigned int v36; // ecx
long long v37; // r15
_BYTE *v38; // rax
unsigned long long v39; // r13
long long v41; // rbx
__int128 v42; // [rsp+0h] [rbp-70h] BYREF
long long v43; // [rsp+10h] [rbp-60h]
long long v44; // [rsp+18h] [rbp-58h]
unsigned long long v45; // [rsp+20h] [rbp-50h]
unsigned long long v46; // [rsp+28h] [rbp-48h]
long long v47; // [rsp+30h] [rbp-40h]
_BYTE *v48; // [rsp+38h] [rbp-38h]
unsigned int v49; // [rsp+44h] [rbp-2Ch]
v44 = a1;
v45 = a3;
v48 = a2;
v9 = a3 - (_QWORD)a2;
v10 = a3 - (_QWORD)a2 + 1;
v11 = -a4;
v47 = a4;
if ( a4 > 0 )
v11 = a4;
v12 = "(null)";
if ( a6 )
v12 = a6;
if ( a8 )
{
v13 = strnlen(v12, a5 + 1);
v14 = a5;
if ( v13 < a5 )
v14 = v13;
if ( v10 <= v14 )
{
v14 = v9;
v11 = v9;
}
v49 = 0;
v46 = v11;
if ( v13 > v14 )
{
if ( v14 > 2 )
{
v14 -= 3LL;
v49 = 3;
}
else
{
v49 = v14;
v14 = 0LL;
}
}
}
else
{
v14 = strnlen(v12, a5);
if ( v10 <= v14 )
{
v14 = v9;
v11 = v9;
}
v46 = v11;
v49 = 0;
}
(*(void ( **)(long long, const char *, const char *, unsigned long long, __int128 *))(*(_QWORD *)(v44 + 184)
+ 200LL))(
v44,
v12,
&v12[v14],
a5,
&v42);
v18 = v42 - (_QWORD)v12;
if ( (a7 & 8) != 0 )
{
v23 = v49 + v18;
v42 = 0LL;
v43 = 0LL;
if ( v9 > v23 )
{
v24 = v48 + 1;
*v48 = 96;
if ( v23 > 0 )
{
v25 = &v12[v23];
v26 = 0;
while ( 1 )
{
if ( v49 )
{
*((_QWORD *)&v42 + v26) = v24;
v15 = 2863311531LL;
v26 += -3 * ((v26 + 1) / 3) + 1;
}
v27 = *v12;
v28 = (*(long long ( **)(long long, const char *, const char *, long long, long long, long long, _QWORD, _QWORD, long long))(*(_QWORD *)(v44 + 184) + 192LL))(
v44,
v12,
v25,
v15,
v16,
v17,
v42,
*((_QWORD *)&v42 + 1),
v43);
if ( (int)v28 < 2 && (v28 = 1, v27 == 96) )
{
v29 = v24 + 1;
if ( (unsigned long long)(v24 + 1) >= v45 )
goto LABEL_50;
*v24 = 96;
}
else
{
v29 = v24;
}
v30 = v28;
if ( (unsigned long long)&v29[v28] >= v45 )
goto LABEL_50;
v24 = (_BYTE *)strnmov(v29, v12, v28);
v12 += v30;
if ( v12 >= v25 )
goto LABEL_39;
}
}
v26 = 0;
LABEL_39:
if ( (unsigned long long)(v24 + 1) >= v45 )
goto LABEL_50;
if ( !v49 )
{
LABEL_59:
*v24 = 96;
v32 = (long long)(v24 + 1);
v19 = v47;
v38 = v48;
goto LABEL_51;
}
v33 = v26 == 0;
v34 = v26 - 1;
if ( v33 )
v34 = 2LL;
v35 = *((_QWORD *)&v42 + v34);
if ( v35 )
{
v36 = 1;
while ( 1 )
{
v33 = (_DWORD)v34 == 0;
v34 = (unsigned int)(v34 - 1);
if ( v33 )
v34 = 2LL;
v37 = *((_QWORD *)&v42 + v34);
if ( !v37 )
break;
++v36;
v35 = *((_QWORD *)&v42 + v34);
if ( v36 == 3 )
goto LABEL_58;
}
v37 = v35;
LABEL_58:
v41 = v36;
memset(v37, 46LL, v36);
v24 = (_BYTE *)(v41 + v37);
goto LABEL_59;
}
}
LABEL_50:
v38 = v48;
*v48 = 0;
v32 = (long long)v38;
v19 = v47;
LABEL_51:
v18 = v32 - (_QWORD)v38;
LABEL_52:
v20 = 0LL;
goto LABEL_53;
}
v19 = v47;
if ( v47 < 0 )
{
v22 = (long long)v48;
LODWORD(v20) = v49;
}
else
{
LODWORD(v20) = v49;
v21 = v18 + v49;
if ( v46 <= v21 )
v22 = (long long)v48;
else
v22 = strfill(v48, v46 - v21, 32LL);
}
v31 = strnmov(v22, v12, v18);
v32 = v31;
if ( !(_DWORD)v20 )
goto LABEL_52;
v20 = (unsigned int)v20;
v32 = strfill(v31, (unsigned int)v20, 46LL);
LABEL_53:
if ( v19 < 0 )
{
v39 = v20 + v18;
if ( v46 > v39 )
return strfill(v32, v46 - v39, 32LL);
}
return v32;
}
|
process_str_arg:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,R8
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x50],RDX
MOV R14,RDX
MOV qword ptr [RBP + -0x38],RSI
SUB R14,RSI
LEA RBX,[R14 + 0x1]
MOV R13,RCX
NEG R13
MOV qword ptr [RBP + -0x40],RCX
CMOVS R13,RCX
TEST R9,R9
LEA R12,[0x18187e]
CMOVNZ R12,R9
CMP byte ptr [RBP + 0x18],0x0
JZ 0x0017b48a
LEA RSI,[R15 + 0x1]
MOV RDI,R12
CALL 0x00126570
CMP RAX,R15
MOV RDX,R15
CMOVC RDX,RAX
CMP RBX,RDX
CMOVBE RDX,R14
CMOVBE R13,R14
MOV dword ptr [RBP + -0x2c],0x0
CMP RAX,RDX
MOV qword ptr [RBP + -0x48],R13
JBE 0x0017b4bb
CMP RDX,0x2
JA 0x0017b4b0
MOV dword ptr [RBP + -0x2c],EDX
XOR EDX,EDX
JMP 0x0017b4bb
LAB_0017b48a:
MOV RDI,R12
MOV RSI,R15
CALL 0x00126570
MOV RDX,RAX
CMP RBX,RAX
CMOVBE RDX,R14
CMOVBE R13,R14
MOV qword ptr [RBP + -0x48],R13
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x0017b4bb
LAB_0017b4b0:
ADD RDX,-0x3
MOV dword ptr [RBP + -0x2c],0x3
LAB_0017b4bb:
ADD RDX,R12
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RDI + 0xb8]
LEA RBX,[RBP + -0x70]
MOV RSI,R12
MOV RCX,R15
MOV R8,RBX
CALL qword ptr [RAX + 0xc8]
MOV R13,qword ptr [RBX]
SUB R13,R12
MOV EAX,dword ptr [RBP + 0x10]
TEST AL,0x8
JNZ 0x0017b523
MOV RBX,qword ptr [RBP + -0x40]
TEST RBX,RBX
JS 0x0017b5f6
MOV R14D,dword ptr [RBP + -0x2c]
MOV EAX,R14D
ADD RAX,R13
MOV RSI,qword ptr [RBP + -0x48]
SUB RSI,RAX
JBE 0x0017b600
MOV RDI,qword ptr [RBP + -0x38]
MOV EDX,0x20
CALL 0x0017bd28
MOV RDI,RAX
JMP 0x0017b604
LAB_0017b523:
MOV EAX,dword ptr [RBP + -0x2c]
ADD R13,RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOV qword ptr [RBP + -0x60],0x0
CMP R14,R13
JBE 0x0017b680
MOV RAX,qword ptr [RBP + -0x38]
LEA R15,[RAX + 0x1]
MOV byte ptr [RAX],0x60
TEST R13,R13
JLE 0x0017b62f
ADD R13,R12
XOR R14D,R14D
LAB_0017b55b:
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0017b586
MOV EAX,R14D
MOV qword ptr [RBP + RAX*0x8 + -0x70],R15
MOV EAX,R14D
INC EAX
MOV ECX,0xaaaaaaab
IMUL RAX,RCX
SHR RAX,0x21
LEA EAX,[RAX + RAX*0x2]
NEG EAX
ADD R14D,EAX
INC R14D
LAB_0017b586:
MOV BL,byte ptr [R12]
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RDI + 0xb8]
MOV RSI,R12
MOV RDX,R13
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
MOV ECX,0x1
CMOVL EAX,ECX
JGE 0x0017b5c7
CMP BL,0x60
JNZ 0x0017b5c7
LEA RDI,[R15 + 0x1]
CMP RDI,qword ptr [RBP + -0x50]
JNC 0x0017b680
MOV byte ptr [R15],0x60
JMP 0x0017b5ca
LAB_0017b5c7:
MOV RDI,R15
LAB_0017b5ca:
MOV EBX,EAX
LEA RAX,[RDI + RBX*0x1]
CMP RAX,qword ptr [RBP + -0x50]
JNC 0x0017b680
MOV RSI,R12
MOV RDX,RBX
CALL 0x0017bd88
MOV R15,RAX
ADD R12,RBX
CMP R12,R13
JC 0x0017b55b
JMP 0x0017b632
LAB_0017b5f6:
MOV RDI,qword ptr [RBP + -0x38]
MOV R14D,dword ptr [RBP + -0x2c]
JMP 0x0017b604
LAB_0017b600:
MOV RDI,qword ptr [RBP + -0x38]
LAB_0017b604:
MOV RSI,R12
MOV RDX,R13
CALL 0x0017bd88
MOV R15,RAX
TEST R14D,R14D
JZ 0x0017b694
MOV R14D,R14D
MOV RDI,R15
MOV RSI,R14
MOV EDX,0x2e
CALL 0x0017bd28
MOV R15,RAX
JMP 0x0017b697
LAB_0017b62f:
XOR R14D,R14D
LAB_0017b632:
LEA RAX,[R15 + 0x1]
CMP RAX,qword ptr [RBP + -0x50]
JNC 0x0017b680
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0017b6e2
SUB R14D,0x1
MOV EAX,0x2
CMOVC R14D,EAX
MOV RDX,qword ptr [RBP + R14*0x8 + -0x70]
TEST RDX,RDX
JZ 0x0017b680
MOV ECX,0x1
LAB_0017b662:
SUB R14D,0x1
CMOVC R14D,EAX
MOV R15,qword ptr [RBP + R14*0x8 + -0x70]
TEST R15,R15
JZ 0x0017b6ca
INC ECX
MOV RDX,R15
CMP ECX,0x3
JNZ 0x0017b662
JMP 0x0017b6cd
LAB_0017b680:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV R15,RAX
MOV RBX,qword ptr [RBP + -0x40]
LAB_0017b68e:
MOV R13,R15
SUB R13,RAX
LAB_0017b694:
XOR R14D,R14D
LAB_0017b697:
TEST RBX,RBX
JNS 0x0017b6b8
ADD R13,R14
MOV RSI,qword ptr [RBP + -0x48]
SUB RSI,R13
JBE 0x0017b6b8
MOV RDI,R15
MOV EDX,0x20
CALL 0x0017bd28
MOV R15,RAX
LAB_0017b6b8:
MOV RAX,R15
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017b6ca:
MOV R15,RDX
LAB_0017b6cd:
MOV EBX,ECX
MOV RDI,R15
MOV ESI,0x2e
MOV RDX,RBX
CALL 0x001261c0
ADD R15,RBX
LAB_0017b6e2:
MOV byte ptr [R15],0x60
INC R15
MOV RBX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x38]
JMP 0x0017b68e
|
int1 *
process_str_arg(long param_1,int1 *param_2,int1 *param_3,ulong param_4,ulong param_5,
char *param_6,uint param_7,char param_8)
{
char cVar1;
void *pvVar2;
uint uVar3;
uint uVar4;
size_t sVar5;
int1 *puVar6;
void *__s;
long lVar7;
char *__string;
long lVar8;
ulong uVar9;
char *pcVar10;
int iVar11;
ulong uVar12;
long local_78 [4];
int1 *local_58;
ulong local_50;
ulong local_48;
int1 *local_40;
uint local_34;
uVar12 = (long)param_3 - (long)param_2;
local_50 = -param_4;
if (0 < (long)param_4) {
local_50 = param_4;
}
__string = "(null)";
if (param_6 != (char *)0x0) {
__string = param_6;
}
local_78[3] = param_1;
local_58 = param_3;
local_48 = param_4;
local_40 = param_2;
if (param_8 == '\0') {
uVar9 = strnlen(__string,param_5);
if (uVar12 + 1 <= uVar9) {
local_50 = uVar12;
uVar9 = uVar12;
}
local_34 = 0;
}
else {
sVar5 = strnlen(__string,param_5 + 1);
uVar9 = param_5;
if (sVar5 < param_5) {
uVar9 = sVar5;
}
if (uVar12 + 1 <= uVar9) {
local_50 = uVar12;
uVar9 = uVar12;
}
local_34 = 0;
if (uVar9 < sVar5) {
if (uVar9 < 3) {
local_34 = (uint)uVar9;
uVar9 = 0;
}
else {
uVar9 = uVar9 - 3;
local_34 = 3;
}
}
}
(**(code **)(*(long *)(local_78[3] + 0xb8) + 200))
(local_78[3],__string,__string + uVar9,param_5,local_78);
uVar4 = local_34;
uVar9 = local_48;
lVar8 = local_78[0] - (long)__string;
if ((param_7 & 8) == 0) {
puVar6 = local_40;
if ((-1 < (long)local_48) &&
(lVar7 = local_50 - ((ulong)local_34 + lVar8),
(ulong)local_34 + lVar8 <= local_50 && lVar7 != 0)) {
puVar6 = (int1 *)strfill(local_40,lVar7,0x20);
}
uVar12 = (ulong)uVar4;
puVar6 = (int1 *)strnmov(puVar6,__string,lVar8);
if (uVar4 != 0) {
puVar6 = (int1 *)strfill(puVar6,uVar12,0x2e);
goto LAB_0017b697;
}
}
else {
uVar9 = lVar8 + (ulong)local_34;
local_78[0] = 0;
local_78[1] = 0;
local_78[2] = 0;
if (uVar9 < uVar12) {
puVar6 = local_40 + 1;
*local_40 = 0x60;
if ((long)uVar9 < 1) {
iVar11 = 0;
}
else {
pcVar10 = __string + uVar9;
uVar12 = 0;
do {
if (local_34 != 0) {
local_78[uVar12] = (long)puVar6;
uVar12 = (ulong)((int)uVar12 + (((int)uVar12 + 1U) / 3) * -3 + 1);
}
iVar11 = (int)uVar12;
cVar1 = *__string;
uVar4 = (**(code **)(*(long *)(local_78[3] + 0xb8) + 0xc0))(local_78[3],__string,pcVar10);
if (((int)uVar4 < 2) && (uVar4 = 1, cVar1 == '`')) {
if (local_58 <= puVar6 + 1) goto LAB_0017b680;
*puVar6 = 0x60;
puVar6 = puVar6 + 1;
}
uVar9 = (ulong)uVar4;
if (local_58 <= puVar6 + uVar9) goto LAB_0017b680;
puVar6 = (int1 *)strnmov(puVar6,__string,uVar9);
__string = __string + uVar9;
} while (__string < pcVar10);
}
if (local_58 <= puVar6 + 1) goto LAB_0017b680;
if (local_34 != 0) {
uVar4 = iVar11 - 1;
if (iVar11 == 0) {
uVar4 = 2;
}
uVar12 = (ulong)uVar4;
if ((void *)local_78[uVar12] == (void *)0x0) goto LAB_0017b680;
uVar4 = 1;
__s = (void *)local_78[uVar12];
do {
uVar3 = (int)uVar12 - 1;
if ((int)uVar12 == 0) {
uVar3 = 2;
}
uVar12 = (ulong)uVar3;
pvVar2 = (void *)local_78[uVar12];
} while ((pvVar2 != (void *)0x0) && (uVar4 = uVar4 + 1, __s = pvVar2, uVar4 != 3));
memset(__s,0x2e,(ulong)uVar4);
puVar6 = (int1 *)((long)__s + (ulong)uVar4);
}
*puVar6 = 0x60;
puVar6 = puVar6 + 1;
}
else {
LAB_0017b680:
*local_40 = 0;
puVar6 = local_40;
}
lVar8 = (long)puVar6 - (long)local_40;
uVar9 = local_48;
}
uVar12 = 0;
LAB_0017b697:
if (((long)uVar9 < 0) &&
(lVar7 = local_50 - (lVar8 + uVar12), lVar8 + uVar12 <= local_50 && lVar7 != 0)) {
puVar6 = (int1 *)strfill(puVar6,lVar7,0x20);
}
return puVar6;
}
|
|
66,477 |
get_charset_by_name
|
eloqsql/mysys/charset.c
|
CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags)
{
MY_CHARSET_LOADER loader;
my_charset_loader_init_mysys(&loader);
return my_collation_get_by_name(&loader, cs_name, flags);
}
|
O3
|
c
|
get_charset_by_name:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
leaq -0xb8(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0x10d0(%rip), %rax # 0x91ace
movq %rax, 0x80(%rdi)
leaq -0x10cf(%rip), %rax # 0x91add
movq %rax, 0x88(%rdi)
leaq -0x10c2(%rip), %rax # 0x91af8
movq %rax, 0x90(%rdi)
leaq 0xcf66(%rip), %rax # 0x9fb2e
movq %rax, 0x98(%rdi)
leaq 0x2f2b1a(%rip), %rax # 0x3856f0
movq (%rax), %rax
movq %rax, 0xa0(%rdi)
leaq -0x10d1(%rip), %rax # 0x91b16
movq %rax, 0xa8(%rdi)
callq 0x92a48
movq %fs:0x28, %rcx
cmpq -0x8(%rbp), %rcx
jne 0x92c0b
addq $0xc0, %rsp
popq %rbp
retq
callq 0x29270
|
get_charset_by_name:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rdx, rsi
mov rsi, rdi
mov rax, fs:28h
mov [rbp+var_8], rax
lea rdi, [rbp+var_B8]
mov byte ptr [rdi], 0
lea rax, my_once_alloc_c
mov [rdi+80h], rax
lea rax, my_malloc_c
mov [rdi+88h], rax
lea rax, my_realloc_c
mov [rdi+90h], rax
lea rax, my_free
mov [rdi+98h], rax
lea rax, my_charset_error_reporter
mov rax, [rax]
mov [rdi+0A0h], rax
lea rax, add_collation
mov [rdi+0A8h], rax
call my_collation_get_by_name
mov rcx, fs:28h
cmp rcx, [rbp+var_8]
jnz short loc_92C0B
add rsp, 0C0h
pop rbp
retn
loc_92C0B:
call ___stack_chk_fail
|
long long get_charset_by_name(long long a1, long long a2)
{
_BYTE v3[128]; // [rsp+8h] [rbp-B8h] BYREF
long long ( *v4)(long long); // [rsp+88h] [rbp-38h]
long long ( *v5)(long long); // [rsp+90h] [rbp-30h]
long long ( *v6)(long long, long long, long long, long long, long long, long long); // [rsp+98h] [rbp-28h]
long long ( *v7)(_QWORD); // [rsp+A0h] [rbp-20h]
long long ( *v8)(); // [rsp+A8h] [rbp-18h]
long long ( *v9)(unsigned int *); // [rsp+B0h] [rbp-10h]
unsigned long long v10; // [rsp+B8h] [rbp-8h]
v10 = __readfsqword(0x28u);
v3[0] = 0;
v4 = my_once_alloc_c;
v5 = my_malloc_c;
v6 = my_realloc_c;
v7 = my_free;
v8 = my_charset_error_reporter;
v9 = add_collation;
return my_collation_get_by_name((long long)v3, a1, a2);
}
|
get_charset_by_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV RDX,RSI
MOV RSI,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[RBP + -0xb8]
MOV byte ptr [RDI],0x0
LEA RAX,[0x191ace]
MOV qword ptr [RDI + 0x80],RAX
LEA RAX,[0x191add]
MOV qword ptr [RDI + 0x88],RAX
LEA RAX,[0x191af8]
MOV qword ptr [RDI + 0x90],RAX
LEA RAX,[0x19fb2e]
MOV qword ptr [RDI + 0x98],RAX
LEA RAX,[0x4856f0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0xa0],RAX
LEA RAX,[0x191b16]
MOV qword ptr [RDI + 0xa8],RAX
CALL 0x00192a48
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x8]
JNZ 0x00192c0b
ADD RSP,0xc0
POP RBP
RET
LAB_00192c0b:
CALL 0x00129270
|
void get_charset_by_name(int8 param_1,int8 param_2)
{
long in_FS_OFFSET;
int1 local_c0 [128];
code *local_40;
code *local_38;
code *local_30;
code *local_28;
int *local_20;
code *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_c0[0] = 0;
local_40 = my_once_alloc_c;
local_38 = my_malloc_c;
local_30 = my_realloc_c;
local_28 = my_free;
local_20 = my_charset_error_reporter;
local_18 = add_collation;
my_collation_get_by_name(local_c0,param_1,param_2);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
66,478 |
dirname_length
|
eloqsql/mysys/mf_dirname.c
|
size_t dirname_length(const char *name)
{
register char *pos, *gpos;
#ifdef BASKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
#ifdef FN_DEVCHAR
if ((pos=(char*)strrchr(name,FN_DEVCHAR)) == 0)
#endif
pos=(char*) name-1;
gpos= pos++;
for ( ; *pos ; pos++) /* Find last FN_LIBCHAR */
{
#ifdef BASKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, pos, pos + 3)))
{
pos+= l - 1;
continue;
}
#endif
if (*pos == FN_LIBCHAR || *pos == '/')
gpos=pos;
}
return (size_t) (gpos+1-(char*) name);
}
|
O0
|
c
|
dirname_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2cfe0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x2cfc8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x2cfd0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x2cfd2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2cfa7
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
dirname_length:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov [rbp+var_18], rax
loc_2CFA7:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_2CFE0
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jz short loc_2CFC8
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_2CFD0
loc_2CFC8:
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
loc_2CFD0:
jmp short $+2
loc_2CFD2:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_2CFA7
loc_2CFE0:
mov rax, [rbp+var_18]
add rax, 1
mov rcx, [rbp+var_8]
sub rax, rcx
pop rbp
retn
|
long long dirname_length(_BYTE *a1)
{
_BYTE *v2; // [rsp+0h] [rbp-18h]
_BYTE *v3; // [rsp+8h] [rbp-10h]
v3 = a1;
v2 = a1 - 1;
while ( *v3 )
{
if ( *v3 == 47 )
v2 = v3;
++v3;
}
return v2 + 1 - a1;
}
|
dirname_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV qword ptr [RBP + -0x18],RAX
LAB_0012cfa7:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x0012cfe0
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JZ 0x0012cfc8
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x0012cfd0
LAB_0012cfc8:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
LAB_0012cfd0:
JMP 0x0012cfd2
LAB_0012cfd2:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0012cfa7
LAB_0012cfe0:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV RCX,qword ptr [RBP + -0x8]
SUB RAX,RCX
POP RBP
RET
|
char * dirname_length(char *param_1)
{
char *local_20;
char *local_18;
local_20 = param_1 + -1;
for (local_18 = param_1; *local_18 != '\0'; local_18 = local_18 + 1) {
if ((*local_18 == '/') || (*local_18 == '/')) {
local_20 = local_18;
}
}
return local_20 + (1 - (long)param_1);
}
|
|
66,479 |
dirname_length
|
eloqsql/mysys/mf_dirname.c
|
size_t dirname_length(const char *name)
{
register char *pos, *gpos;
#ifdef BASKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
#ifdef FN_DEVCHAR
if ((pos=(char*)strrchr(name,FN_DEVCHAR)) == 0)
#endif
pos=(char*) name-1;
gpos= pos++;
for ( ; *pos ; pos++) /* Find last FN_LIBCHAR */
{
#ifdef BASKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, pos, pos + 3)))
{
pos+= l - 1;
continue;
}
#endif
if (*pos == FN_LIBCHAR || *pos == '/')
gpos=pos;
}
return (size_t) (gpos+1-(char*) name);
}
|
O3
|
c
|
dirname_length:
pushq %rbp
movq %rsp, %rbp
leaq -0x1(%rdi), %rax
movq %rdi, %rcx
movzbl (%rcx), %edx
cmpl $0x2f, %edx
je 0x29ddd
testl %edx, %edx
jne 0x29de0
jmp 0x29de5
movq %rcx, %rax
incq %rcx
jmp 0x29dcf
subq %rdi, %rax
incq %rax
popq %rbp
retq
|
dirname_length:
push rbp
mov rbp, rsp
lea rax, [rdi-1]
mov rcx, rdi
loc_29DCF:
movzx edx, byte ptr [rcx]
cmp edx, 2Fh ; '/'
jz short loc_29DDD
test edx, edx
jnz short loc_29DE0
jmp short loc_29DE5
loc_29DDD:
mov rax, rcx
loc_29DE0:
inc rcx
jmp short loc_29DCF
loc_29DE5:
sub rax, rdi
inc rax
pop rbp
retn
|
long long dirname_length(_BYTE *a1)
{
_BYTE *v1; // rax
_BYTE *i; // rcx
v1 = a1 - 1;
for ( i = a1; *i == 47; ++i )
{
v1 = i;
LABEL_6:
;
}
if ( *i )
goto LABEL_6;
return v1 - a1 + 1;
}
|
dirname_length:
PUSH RBP
MOV RBP,RSP
LEA RAX,[RDI + -0x1]
MOV RCX,RDI
LAB_00129dcf:
MOVZX EDX,byte ptr [RCX]
CMP EDX,0x2f
JZ 0x00129ddd
TEST EDX,EDX
JNZ 0x00129de0
JMP 0x00129de5
LAB_00129ddd:
MOV RAX,RCX
LAB_00129de0:
INC RCX
JMP 0x00129dcf
LAB_00129de5:
SUB RAX,RDI
INC RAX
POP RBP
RET
|
char * dirname_length(char *param_1)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
pcVar1 = param_1 + -1;
for (pcVar3 = param_1; (pcVar2 = pcVar3, *pcVar3 == '/' || (pcVar2 = pcVar1, *pcVar3 != '\0'));
pcVar3 = pcVar3 + 1) {
pcVar1 = pcVar2;
}
return pcVar1 + (1 - (long)param_1);
}
|
|
66,480 |
uf_varchar1
|
eloqsql/storage/maria/ma_packrec.c
|
static void uf_varchar1(MARIA_COLUMNDEF *rec, MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end __attribute__((unused)))
{
if (get_bit(bit_buff))
to[0]= 0; /* Zero lengths */
else
{
ulong length=get_bits(bit_buff,rec->space_length_bits);
*to= (char) length;
decode_bytes(rec,bit_buff,to+1,to+1+length);
}
}
|
O0
|
c
|
uf_varchar1:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x35c97
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x35cbb
jmp 0x35cc7
movq -0x10(%rbp), %rdi
callq 0x34750
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0x35cc7
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
jmp 0x35d53
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jb 0x35d0a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, %edx
leaq 0x28644e(%rip), %rcx # 0x2bc150
andl (%rcx,%rdx,4), %eax
movl %eax, -0x2c(%rbp)
jmp 0x35d1d
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x33f00
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
addq -0x28(%rbp), %rcx
callq 0x34a90
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
uf_varchar1:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_35C97
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_35CBB
jmp short loc_35CC7
loc_35C97:
mov rdi, [rbp+var_10]
call fill_buffer
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz short loc_35CC7
loc_35CBB:
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
jmp loc_35D53
loc_35CC7:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+24h]
jb short loc_35D0A
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+24h]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+24h]
mov edx, ecx
lea rcx, mask
and eax, [rcx+rdx*4]
mov [rbp+var_2C], eax
jmp short loc_35D1D
loc_35D0A:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+24h]
call fill_and_get_bits
mov [rbp+var_2C], eax
loc_35D1D:
mov eax, [rbp+var_2C]
mov eax, eax
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov cl, al
mov rax, [rbp+var_18]
mov [rax], cl
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
add rdx, 1
mov rcx, [rbp+var_18]
add rcx, 1
add rcx, [rbp+var_28]
call decode_bytes
loc_35D53:
add rsp, 30h
pop rbp
retn
|
long long uf_varchar1(long long a1, int *a2, _BYTE *a3)
{
int v3; // eax
int v4; // ecx
long long result; // rax
unsigned int v6; // eax
int v7; // ecx
int bits; // [rsp+4h] [rbp-2Ch]
if ( a2[1] )
{
v3 = *a2;
v4 = a2[1] - 1;
a2[1] = v4;
if ( ((1 << v4) & v3) == 0 )
goto LABEL_6;
LABEL_5:
result = (long long)a3;
*a3 = 0;
return result;
}
fill_buffer((long long)a2);
a2[1] = 31;
if ( *a2 < 0 )
goto LABEL_5;
LABEL_6:
if ( (unsigned int)a2[1] < *(_DWORD *)(a1 + 36) )
{
bits = fill_and_get_bits(a2, *(_DWORD *)(a1 + 36));
}
else
{
v6 = *a2;
v7 = a2[1] - *(_DWORD *)(a1 + 36);
a2[1] = v7;
bits = mask[*(unsigned int *)(a1 + 36)] & (v6 >> v7);
}
*a3 = bits;
return decode_bytes(a1, (long long)a2, a3 + 1, &a3[bits + 1]);
}
|
uf_varchar1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x00135c97
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x00135cbb
JMP 0x00135cc7
LAB_00135c97:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00134750
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x00135cc7
LAB_00135cbb:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
JMP 0x00135d53
LAB_00135cc7:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x24]
JC 0x00135d0a
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x24]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x24]
MOV EDX,ECX
LEA RCX,[0x3bc150]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x00135d1d
LAB_00135d0a:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x24]
CALL 0x00133f00
MOV dword ptr [RBP + -0x2c],EAX
LAB_00135d1d:
MOV EAX,dword ptr [RBP + -0x2c]
MOV EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],CL
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,0x1
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x1
ADD RCX,qword ptr [RBP + -0x28]
CALL 0x00134a90
LAB_00135d53:
ADD RSP,0x30
POP RBP
RET
|
void uf_varchar1(long param_1,uint *param_2,int1 *param_3)
{
uint uVar1;
uint local_34;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
if (param_2[1] < *(uint *)(param_1 + 0x24)) {
local_34 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x24));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x24);
param_2[1] = uVar1;
local_34 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x24) * 4);
}
*param_3 = (char)local_34;
decode_bytes(param_1,param_2,param_3 + 1,param_3 + (ulong)local_34 + 1);
}
else {
*param_3 = 0;
}
return;
}
|
|
66,481 |
uf_varchar1
|
eloqsql/storage/maria/ma_packrec.c
|
static void uf_varchar1(MARIA_COLUMNDEF *rec, MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end __attribute__((unused)))
{
if (get_bit(bit_buff))
to[0]= 0; /* Zero lengths */
else
{
ulong length=get_bits(bit_buff,rec->space_length_bits);
*to= (char) length;
decode_bytes(rec,bit_buff,to+1,to+1+length);
}
}
|
O3
|
c
|
uf_varchar1:
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, %r15
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x3779d
movl (%r14), %r13d
decl %eax
movl %eax, 0x4(%r14)
btl %eax, %r13d
jae 0x377ba
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x36858
movl $0x1f, 0x4(%r14)
movl (%r14), %r13d
movl $0x1f, %eax
testl %r13d, %r13d
js 0x3778b
movl 0x24(%r15), %r12d
movl %eax, %ecx
subl %r12d, %ecx
jae 0x377ff
subl %eax, %r12d
movl %eax, %eax
leaq 0xa84af(%rip), %rcx # 0xdfc80
andl (%rcx,%rax,4), %r13d
movl %r12d, %ecx
shll %cl, %r13d
movq %r14, %rdi
callq 0x36858
movl $0x20, %eax
subl %r12d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r12d
movl %r12d, %ecx
shrl %cl, %eax
addl %eax, %r13d
jmp 0x37815
movl %ecx, 0x4(%r14)
shrl %cl, %r13d
movl 0x24(%r15), %eax
leaq 0xa846f(%rip), %rcx # 0xdfc80
andl (%rcx,%rax,4), %r13d
movl %r13d, %eax
movb %r13b, (%rbx)
leaq (%rbx,%rax), %rcx
incq %rcx
incq %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36a15
|
uf_varchar1:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_3779D
mov r13d, [r14]
dec eax
mov [r14+4], eax
bt r13d, eax
jnb short loc_377BA
loc_3778B:
mov byte ptr [rbx], 0
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3779D:
mov rdi, r14
call fill_buffer
mov dword ptr [r14+4], 1Fh
mov r13d, [r14]
mov eax, 1Fh
test r13d, r13d
js short loc_3778B
loc_377BA:
mov r12d, [r15+24h]
mov ecx, eax
sub ecx, r12d
jnb short loc_377FF
sub r12d, eax
mov eax, eax
lea rcx, mask
and r13d, [rcx+rax*4]
mov ecx, r12d
shl r13d, cl
mov rdi, r14
call fill_buffer
mov eax, 20h ; ' '
sub eax, r12d
mov [r14+4], eax
mov eax, [r14]
neg r12d
mov ecx, r12d
shr eax, cl
add r13d, eax
jmp short loc_37815
loc_377FF:
mov [r14+4], ecx
shr r13d, cl
mov eax, [r15+24h]
lea rcx, mask
and r13d, [rcx+rax*4]
loc_37815:
mov eax, r13d
mov [rbx], r13b
lea rcx, [rbx+rax]
inc rcx
inc rbx
mov rdi, r15
mov rsi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes
|
long long uf_varchar1(long long a1, unsigned int *a2, _BYTE *a3)
{
unsigned int v4; // eax
unsigned int v5; // r13d
long long result; // rax
unsigned int v7; // r12d
unsigned int v8; // ecx
int v9; // r12d
int v10; // r13d
unsigned int v11; // r13d
v4 = a2[1];
if ( v4 )
{
v5 = *a2;
result = v4 - 1;
a2[1] = result;
if ( _bittest((const int *)&v5, result) )
{
LABEL_3:
*a3 = 0;
return result;
}
}
else
{
fill_buffer((long long)a2);
a2[1] = 31;
v5 = *a2;
result = 31LL;
if ( (*a2 & 0x80000000) != 0 )
goto LABEL_3;
}
v7 = *(_DWORD *)(a1 + 36);
v8 = result - v7;
if ( (unsigned int)result >= v7 )
{
a2[1] = v8;
v11 = mask[*(unsigned int *)(a1 + 36)] & (v5 >> v8);
}
else
{
v9 = v7 - result;
v10 = (mask[(unsigned int)result] & v5) << v9;
fill_buffer((long long)a2);
a2[1] = 32 - v9;
v11 = (*a2 >> -(char)v9) + v10;
}
*a3 = v11;
return (long long)decode_bytes(a1, (long long)a2, a3 + 1, &a3[v11 + 1]);
}
|
uf_varchar1:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x0013779d
MOV R13D,dword ptr [R14]
DEC EAX
MOV dword ptr [R14 + 0x4],EAX
BT R13D,EAX
JNC 0x001377ba
LAB_0013778b:
MOV byte ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013779d:
MOV RDI,R14
CALL 0x00136858
MOV dword ptr [R14 + 0x4],0x1f
MOV R13D,dword ptr [R14]
MOV EAX,0x1f
TEST R13D,R13D
JS 0x0013778b
LAB_001377ba:
MOV R12D,dword ptr [R15 + 0x24]
MOV ECX,EAX
SUB ECX,R12D
JNC 0x001377ff
SUB R12D,EAX
MOV EAX,EAX
LEA RCX,[0x1dfc80]
AND R13D,dword ptr [RCX + RAX*0x4]
MOV ECX,R12D
SHL R13D,CL
MOV RDI,R14
CALL 0x00136858
MOV EAX,0x20
SUB EAX,R12D
MOV dword ptr [R14 + 0x4],EAX
MOV EAX,dword ptr [R14]
NEG R12D
MOV ECX,R12D
SHR EAX,CL
ADD R13D,EAX
JMP 0x00137815
LAB_001377ff:
MOV dword ptr [R14 + 0x4],ECX
SHR R13D,CL
MOV EAX,dword ptr [R15 + 0x24]
LEA RCX,[0x1dfc80]
AND R13D,dword ptr [RCX + RAX*0x4]
LAB_00137815:
MOV EAX,R13D
MOV byte ptr [RBX],R13B
LEA RCX,[RBX + RAX*0x1]
INC RCX
INC RBX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00136a15
|
void uf_varchar1(long param_1,uint *param_2,int1 *param_3)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
uint uVar5;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
uVar3 = 0x1f;
if (-1 < (int)uVar5) goto LAB_001377ba;
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) == 0) {
LAB_001377ba:
uVar1 = *(uint *)(param_1 + 0x24);
if (uVar3 < uVar1) {
uVar2 = (&mask)[uVar3];
bVar4 = (byte)(uVar1 - uVar3);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar3);
uVar5 = ((uVar5 & uVar2) << (bVar4 & 0x1f)) + (*param_2 >> (-bVar4 & 0x1f));
}
else {
param_2[1] = uVar3 - uVar1;
uVar5 = uVar5 >> ((byte)(uVar3 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x24)];
}
*param_3 = (char)uVar5;
decode_bytes(param_1,param_2,param_3 + 1,param_3 + (ulong)uVar5 + 1);
return;
}
}
*param_3 = 0;
return;
}
|
|
66,482 |
my_thread_global_reinit
|
eloqsql/mysys/my_thr_init.c
|
void my_thread_global_reinit(void)
{
struct st_my_thread_var *tmp;
DBUG_ASSERT(my_thread_global_init_done);
#ifdef HAVE_PSI_INTERFACE
my_init_mysys_psi_keys();
#endif
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
tmp= my_thread_var;
DBUG_ASSERT(tmp);
my_thread_destory_thr_mutex(tmp);
my_thread_init_thr_mutex(tmp);
}
|
O0
|
c
|
my_thread_global_reinit:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xf5eea
callq 0xf2cb0
callq 0xf5d90
callq 0xf5f30
callq 0xf5e40
callq 0xf6000
callq 0xf6060
movq %rax, -0x8(%rbp)
jmp 0xf5f0e
movq -0x8(%rbp), %rdi
callq 0xf6080
movq -0x8(%rbp), %rdi
callq 0xf60b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_thread_global_reinit:
push rbp
mov rbp, rsp
sub rsp, 10h
jmp short $+2
loc_F5EEA:
call my_init_mysys_psi_keys
call my_thread_destroy_common_mutex
call my_thread_init_common_mutex
call my_thread_destroy_internal_mutex
call my_thread_init_internal_mutex
call _my_thread_var
mov [rbp+var_8], rax
jmp short $+2
loc_F5F0E:
mov rdi, [rbp+var_8]
call my_thread_destory_thr_mutex
mov rdi, [rbp+var_8]
call my_thread_init_thr_mutex
add rsp, 10h
pop rbp
retn
|
long long my_thread_global_reinit(long long a1, const char *a2)
{
long long v3; // [rsp+8h] [rbp-8h]
my_init_mysys_psi_keys();
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
v3 = my_thread_var(a1, a2);
my_thread_destory_thr_mutex(v3);
return my_thread_init_thr_mutex(v3);
}
|
my_thread_global_reinit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
JMP 0x001f5eea
LAB_001f5eea:
CALL 0x001f2cb0
CALL 0x001f5d90
CALL 0x001f5f30
CALL 0x001f5e40
CALL 0x001f6000
CALL 0x001f6060
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001f5f0e
LAB_001f5f0e:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001f6080
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001f60b0
ADD RSP,0x10
POP RBP
RET
|
void my_thread_global_reinit(void)
{
int8 uVar1;
my_init_mysys_psi_keys();
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
uVar1 = _my_thread_var();
my_thread_destory_thr_mutex(uVar1);
my_thread_init_thr_mutex(uVar1);
return;
}
|
|
66,483 |
create_tmpdir
|
eloqsql/storage/maria/unittest/ma_pagecache_consist.c
|
static char *create_tmpdir(const char *progname)
{
static char test_dirname[FN_REFLEN];
char tmp_name[FN_REFLEN];
size_t length;
/* Create a temporary directory of name TMP-'executable', but without the -t extension */
fn_format(tmp_name, progname, "", "", MY_REPLACE_DIR | MY_REPLACE_EXT);
length= strlen(tmp_name);
if (length > 2 && tmp_name[length-2] == '-' && tmp_name[length-1] == 't')
tmp_name[length-2]= 0;
strxmov(test_dirname, "TMP-", tmp_name, NullS);
/*
Don't give an error if we can't create dir, as it may already exist from a previously aborted
run
*/
(void) my_mkdir(test_dirname, 0777, MYF(0));
return test_dirname;
}
|
O0
|
c
|
create_tmpdir:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x218(%rbp), %rsi
leaq 0x12c590(%rip), %rcx # 0x157ca4
movl $0x3, %r8d
movq %rcx, %rdx
callq 0xdf790
leaq -0x210(%rbp), %rdi
callq 0x2a350
movq %rax, -0x220(%rbp)
cmpq $0x2, -0x220(%rbp)
jbe 0x2b782
movq -0x220(%rbp), %rax
subq $0x2, %rax
movsbl -0x210(%rbp,%rax), %eax
cmpl $0x2d, %eax
jne 0x2b782
movq -0x220(%rbp), %rax
subq $0x1, %rax
movsbl -0x210(%rbp,%rax), %eax
cmpl $0x74, %eax
jne 0x2b782
movq -0x220(%rbp), %rax
subq $0x2, %rax
movb $0x0, -0x210(%rbp,%rax)
leaq 0x44bcf7(%rip), %rdi # 0x477480
movq %rdi, -0x230(%rbp)
leaq 0x125b6e(%rip), %rsi # 0x151305
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, -0x228(%rbp)
leaq -0x210(%rbp), %rdx
callq 0x14df10
movq -0x230(%rbp), %rdi
movq -0x228(%rbp), %rdx
movl $0x1ff, %esi # imm = 0x1FF
callq 0xf3e70
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2b7e8
leaq 0x44bca1(%rip), %rax # 0x477480
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
callq 0x2a270
nopl (%rax)
|
create_tmpdir:
push rbp
mov rbp, rsp
sub rsp, 230h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_218]
lea rcx, asc_157CA0+4; ""
mov r8d, 3
mov rdx, rcx
call fn_format
lea rdi, [rbp+var_210]
call _strlen
mov [rbp+var_220], rax
cmp [rbp+var_220], 2
jbe short loc_2B782
mov rax, [rbp+var_220]
sub rax, 2
movsx eax, [rbp+rax+var_210]
cmp eax, 2Dh ; '-'
jnz short loc_2B782
mov rax, [rbp+var_220]
sub rax, 1
movsx eax, [rbp+rax+var_210]
cmp eax, 74h ; 't'
jnz short loc_2B782
mov rax, [rbp+var_220]
sub rax, 2
mov [rbp+rax+var_210], 0
loc_2B782:
lea rdi, create_tmpdir_test_dirname
mov [rbp+var_230], rdi
lea rsi, aTmp; "TMP-"
xor eax, eax
mov ecx, eax
mov [rbp+var_228], rcx
lea rdx, [rbp+var_210]
call strxmov
mov rdi, [rbp+var_230]
mov rdx, [rbp+var_228]
mov esi, 1FFh
call my_mkdir
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_2B7E8
lea rax, create_tmpdir_test_dirname
add rsp, 230h
pop rbp
retn
loc_2B7E8:
call ___stack_chk_fail
|
void * create_tmpdir(long long a1)
{
int v1; // r8d
int v2; // r9d
long long v4; // [rsp+0h] [rbp-230h]
long long v5; // [rsp+8h] [rbp-228h]
unsigned long long v6; // [rsp+10h] [rbp-220h]
long long v7; // [rsp+18h] [rbp-218h]
_BYTE v8[520]; // [rsp+20h] [rbp-210h] BYREF
unsigned long long v9; // [rsp+228h] [rbp-8h]
v9 = __readfsqword(0x28u);
HIWORD(v7) = HIWORD(a1);
fn_format(v8, a1, "", "", 3LL);
v6 = strlen(v8);
if ( v6 > 2 && v8[v6 - 2] == 45 && v8[v6 - 1] == 116 )
v8[v6 - 2] = 0;
strxmov(
(unsigned int)&create_tmpdir_test_dirname,
(unsigned int)"TMP-",
(unsigned int)v8,
0,
v1,
v2,
&create_tmpdir_test_dirname,
0LL);
my_mkdir(v4, 511LL, v5);
return &create_tmpdir_test_dirname;
}
|
create_tmpdir:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x230
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x218]
LEA RCX,[0x257ca4]
MOV R8D,0x3
MOV RDX,RCX
CALL 0x001df790
LEA RDI,[RBP + -0x210]
CALL 0x0012a350
MOV qword ptr [RBP + -0x220],RAX
CMP qword ptr [RBP + -0x220],0x2
JBE 0x0012b782
MOV RAX,qword ptr [RBP + -0x220]
SUB RAX,0x2
MOVSX EAX,byte ptr [RBP + RAX*0x1 + -0x210]
CMP EAX,0x2d
JNZ 0x0012b782
MOV RAX,qword ptr [RBP + -0x220]
SUB RAX,0x1
MOVSX EAX,byte ptr [RBP + RAX*0x1 + -0x210]
CMP EAX,0x74
JNZ 0x0012b782
MOV RAX,qword ptr [RBP + -0x220]
SUB RAX,0x2
MOV byte ptr [RBP + RAX*0x1 + -0x210],0x0
LAB_0012b782:
LEA RDI,[0x577480]
MOV qword ptr [RBP + -0x230],RDI
LEA RSI,[0x251305]
XOR EAX,EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x228],RCX
LEA RDX,[RBP + -0x210]
CALL 0x0024df10
MOV RDI,qword ptr [RBP + -0x230]
MOV RDX,qword ptr [RBP + -0x228]
MOV ESI,0x1ff
CALL 0x001f3e70
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0012b7e8
LEA RAX,[0x577480]
ADD RSP,0x230
POP RBP
RET
LAB_0012b7e8:
CALL 0x0012a270
|
int1 * create_tmpdir(int8 param_1)
{
size_t sVar1;
long in_FS_OFFSET;
int8 local_220;
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_220 = param_1;
fn_format(local_218,param_1,&DAT_00257ca4,&DAT_00257ca4,3);
sVar1 = strlen(local_218);
if (((2 < sVar1) && (local_218[sVar1 - 2] == '-')) && (local_218[sVar1 - 1] == 't')) {
local_218[sVar1 - 2] = '\0';
}
strxmov(create_tmpdir_test_dirname,&DAT_00251305,local_218);
my_mkdir(create_tmpdir_test_dirname,0x1ff,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return create_tmpdir_test_dirname;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
66,484 |
ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_section.hpp
|
void
load( std::istream& stream,
std::streampos header_offset )
{
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ), '\0' );
stream.seekg ( 0, stream.end );
set_stream_size ( stream.tellg() );
stream.seekg( header_offset );
stream.read( reinterpret_cast<char*>( &header ), sizeof( header ) );
Elf_Xword size = get_size();
if ( 0 == data && SHT_NULL != get_type() && SHT_NOBITS != get_type() && size < get_stream_size()) {
try {
data = new char[size + 1];
} catch (const std::bad_alloc&) {
data = 0;
data_size = 0;
}
if ( 0 != size ) {
stream.seekg( (*convertor)( header.sh_offset ) );
stream.read( data, size );
data[size] = 0; //ensure data is ended with 0 to avoid oob read
data_size = size;
}
}
}
|
O0
|
cpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>):
subq $0x98, %rsp
movq %rdx, 0x88(%rsp)
movq %rcx, 0x90(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x10, %rdi
movb $0x0, 0x77(%rsp)
movl $0x28, %esi
leaq 0x77(%rsp), %rdx
callq 0x17920
movq 0x78(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x152c0
movq 0x78(%rsp), %rdi
callq 0x15390
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x19e10
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x19df0
movq 0x78(%rsp), %rdi
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x15290
movq 0x18(%rsp), %rsi
movq 0x78(%rsp), %rdi
addq $0x10, %rsi
movl $0x28, %edx
callq 0x15280
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x98(%rax)
movq 0x18(%rsp), %rcx
movq %rax, 0x48(%rsp)
xorl %eax, %eax
cmpq 0x60(%rcx), %rax
jne 0x1aa3d
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1aa3d
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
movl $0x8, %eax
cmpl %ecx, %eax
je 0x1aa3d
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x19e20
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x1aa3d
movq 0x48(%rsp), %rdi
incq %rdi
callq 0x15030
movq %rax, 0x8(%rsp)
jmp 0x1a96b
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x60(%rax)
jmp 0x1a9c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1aa45
movq 0x40(%rsp), %rdi
callq 0x150b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq $0x0, 0x60(%rax)
movl $0x0, 0x68(%rax)
callq 0x15370
xorl %eax, %eax
cmpq 0x48(%rsp), %rax
je 0x1aa3b
movq 0x18(%rsp), %rax
movq 0x78(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x70(%rax), %rdi
movl 0x20(%rax), %esi
callq 0x17980
movl %eax, %eax
movl %eax, %esi
leaq 0x20(%rsp), %rdi
callq 0x18200
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x15290
movq 0x18(%rsp), %rax
movq 0x78(%rsp), %rdi
movq 0x60(%rax), %rsi
movq 0x48(%rsp), %rdx
callq 0x15280
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rcx
movq 0x48(%rsp), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x48(%rsp), %rcx
movl %ecx, 0x68(%rax)
jmp 0x1aa3d
addq $0x98, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x153a0
nop
|
_ZN5ELFIO12section_implINS_10Elf32_ShdrEE4loadERSiSt4fposI11__mbstate_tE:
sub rsp, 98h
mov [rsp+98h+var_10], rdx
mov [rsp+98h+var_8], rcx
mov [rsp+98h+var_18], rdi
mov [rsp+98h+var_20], rsi
mov rdi, [rsp+98h+var_18]
mov [rsp+98h+var_80], rdi
add rdi, 10h
mov [rsp+98h+var_21], 0
mov esi, 28h ; '('
lea rdx, [rsp+98h+var_21]
call _ZSt6fill_nIPcmcET_S1_T0_RKT1_; std::fill_n<char *,ulong,char>(char *,ulong,char const&)
mov rdi, [rsp+98h+var_20]
xor eax, eax
mov esi, eax
mov edx, 2
call __ZNSi5seekgElSt12_Ios_Seekdir; std::istream::seekg(long,std::_Ios_Seekdir)
mov rdi, [rsp+98h+var_20]; this
call __ZNSi5tellgEv; std::istream::tellg(void)
mov [rsp+98h+var_38], rax
mov [rsp+98h+var_30], rdx
lea rdi, [rsp+98h+var_38]
call _ZNKSt4fposI11__mbstate_tEcvlEv; std::fpos<__mbstate_t>::operator long(void)
mov rdi, [rsp+98h+var_80]; this
mov rsi, rax; unsigned __int64
call _ZN5ELFIO7section15set_stream_sizeEm; ELFIO::section::set_stream_size(ulong)
mov rdi, [rsp+98h+var_20]
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_48], rax
mov rax, [rsp+98h+var_8]
mov [rsp+98h+var_40], rax
mov rsi, [rsp+98h+var_48]
mov rdx, [rsp+98h+var_40]
call __ZNSi5seekgESt4fposI11__mbstate_tE; std::istream::seekg(std::fpos<__mbstate_t>)
mov rsi, [rsp+98h+var_80]
mov rdi, [rsp+98h+var_20]; this
add rsi, 10h; char *
mov edx, 28h ; '('; __int64
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov rdi, [rsp+98h+var_80]
mov rax, [rdi]
call qword ptr [rax+98h]
mov rcx, [rsp+98h+var_80]
mov [rsp+98h+var_50], rax
xor eax, eax
cmp rax, [rcx+60h]
jnz loc_1AA3D
mov rdi, [rsp+98h+var_80]
mov rax, [rdi]
call qword ptr [rax+28h]
mov ecx, eax
xor eax, eax
cmp eax, ecx
jz loc_1AA3D
mov rdi, [rsp+98h+var_80]
mov rax, [rdi]
call qword ptr [rax+28h]
mov ecx, eax
mov eax, 8
cmp eax, ecx
jz loc_1AA3D
mov rdi, [rsp+98h+var_80]; this
mov rax, [rsp+98h+var_50]
mov [rsp+98h+var_88], rax
call _ZNK5ELFIO7section15get_stream_sizeEv; ELFIO::section::get_stream_size(void)
mov rcx, rax
mov rax, [rsp+98h+var_88]
cmp rax, rcx
jnb loc_1AA3D
mov rdi, [rsp+98h+var_50]
inc rdi; unsigned __int64
call __Znam; operator new[](ulong)
mov [rsp+98h+var_90], rax
jmp short $+2
loc_1A96B:
mov rax, [rsp+98h+var_80]
mov rcx, [rsp+98h+var_90]
mov [rax+60h], rcx
jmp short loc_1A9C5
mov rcx, rax
mov eax, edx
mov [rsp+98h+var_58], rcx
mov [rsp+98h+var_5C], eax
mov eax, [rsp+98h+var_5C]
mov ecx, 1
cmp eax, ecx
jnz loc_1AA45
mov rdi, [rsp+98h+var_58]; void *
call ___cxa_begin_catch
mov rcx, rax
mov rax, [rsp+98h+var_80]
mov [rsp+98h+var_68], rcx
mov qword ptr [rax+60h], 0
mov dword ptr [rax+68h], 0
call ___cxa_end_catch
loc_1A9C5:
xor eax, eax
cmp rax, [rsp+98h+var_50]
jz short loc_1AA3B
mov rax, [rsp+98h+var_80]
mov rcx, [rsp+98h+var_20]
mov [rsp+98h+var_98], rcx
mov rdi, [rax+70h]
mov esi, [rax+20h]
call _ZNK5ELFIO19endianess_convertorclEj; ELFIO::endianess_convertor::operator()(uint)
mov eax, eax
mov esi, eax
lea rdi, [rsp+98h+var_78]
call _ZNSt4fposI11__mbstate_tEC2El; std::fpos<__mbstate_t>::fpos(long)
mov rdi, [rsp+98h+var_98]
mov rsi, [rsp+98h+var_78]
mov rdx, [rsp+98h+var_70]
call __ZNSi5seekgESt4fposI11__mbstate_tE; std::istream::seekg(std::fpos<__mbstate_t>)
mov rax, [rsp+98h+var_80]
mov rdi, [rsp+98h+var_20]; this
mov rsi, [rax+60h]; char *
mov rdx, [rsp+98h+var_50]; __int64
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov rax, [rsp+98h+var_80]
mov rcx, [rax+60h]
mov rdx, [rsp+98h+var_50]
mov byte ptr [rcx+rdx], 0
mov rcx, [rsp+98h+var_50]
mov [rax+68h], ecx
loc_1AA3B:
jmp short $+2
loc_1AA3D:
add rsp, 98h
retn
loc_1AA45:
mov rdi, [rsp+98h+var_58]
call __Unwind_Resume
|
long long ELFIO::section_impl<ELFIO::Elf32_Shdr>::load(long long a1, std::istream *a2, long long a3, long long a4)
{
long long v4; // rdx
long long v5; // rax
long long result; // rax
int v7; // ecx
int v8; // ecx
unsigned long long stream_size; // rcx
unsigned int v10; // eax
std::istream *v11; // [rsp+0h] [rbp-98h]
void *v12[2]; // [rsp+20h] [rbp-78h] BYREF
long long v13; // [rsp+48h] [rbp-50h]
long long v14; // [rsp+50h] [rbp-48h]
long long v15; // [rsp+58h] [rbp-40h]
_QWORD v16[2]; // [rsp+60h] [rbp-38h] BYREF
char v17; // [rsp+77h] [rbp-21h] BYREF
std::istream *v18; // [rsp+78h] [rbp-20h]
long long v19; // [rsp+80h] [rbp-18h]
long long v20; // [rsp+88h] [rbp-10h]
long long v21; // [rsp+90h] [rbp-8h]
v20 = a3;
v21 = a4;
v19 = a1;
v18 = a2;
v17 = 0;
std::fill_n<char *,unsigned long,char>(a1 + 16, 0x28uLL, (long long)&v17);
std::istream::seekg(v18, 0LL, 2LL);
v16[0] = std::istream::tellg(v18);
v16[1] = v4;
v5 = std::fpos<__mbstate_t>::operator long((long long)v16);
ELFIO::section::set_stream_size((ELFIO::section *)a1, v5);
v14 = v20;
v15 = v21;
std::istream::seekg(v18, v20, v21);
std::istream::read(v18, (char *)(a1 + 16), 40LL);
v13 = (*(long long ( **)(long long))(*(_QWORD *)a1 + 152LL))(a1);
result = 0LL;
if ( !*(_QWORD *)(a1 + 96) )
{
v7 = (*(long long ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1);
result = 0LL;
if ( v7 )
{
v8 = (*(long long ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1);
result = 8LL;
if ( v8 != 8 )
{
stream_size = ELFIO::section::get_stream_size((ELFIO::section *)a1);
result = v13;
if ( v13 < stream_size )
{
*(_QWORD *)(a1 + 96) = operator new[](v13 + 1);
result = 0LL;
if ( v13 )
{
v11 = v18;
v10 = ELFIO::endianess_convertor::operator()(*(_BYTE **)(a1 + 112), *(_DWORD *)(a1 + 32));
std::fpos<__mbstate_t>::fpos(v12, v10);
std::istream::seekg(v11, v12[0], v12[1]);
std::istream::read(v18, *(char **)(a1 + 96), v13);
result = a1;
*(_BYTE *)(*(_QWORD *)(a1 + 96) + v13) = 0;
*(_DWORD *)(a1 + 104) = v13;
}
}
}
}
}
return result;
}
|
load:
SUB RSP,0x98
MOV qword ptr [RSP + 0x88],RDX
MOV qword ptr [RSP + 0x90],RCX
MOV qword ptr [RSP + 0x80],RDI
MOV qword ptr [RSP + 0x78],RSI
MOV RDI,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x18],RDI
ADD RDI,0x10
MOV byte ptr [RSP + 0x77],0x0
MOV ESI,0x28
LEA RDX,[RSP + 0x77]
CALL 0x00117920
MOV RDI,qword ptr [RSP + 0x78]
XOR EAX,EAX
MOV ESI,EAX
MOV EDX,0x2
CALL 0x001152c0
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x00115390
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
LEA RDI,[RSP + 0x60]
CALL 0x00119e10
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,RAX
CALL 0x00119df0
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x58],RAX
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
CALL 0x00115290
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RSP + 0x78]
ADD RSI,0x10
MOV EDX,0x28
CALL 0x00115280
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x98]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
CMP RAX,qword ptr [RCX + 0x60]
JNZ 0x0011aa3d
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x28]
MOV ECX,EAX
XOR EAX,EAX
CMP EAX,ECX
JZ 0x0011aa3d
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x28]
MOV ECX,EAX
MOV EAX,0x8
CMP EAX,ECX
JZ 0x0011aa3d
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00119e20
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,RCX
JNC 0x0011aa3d
MOV RDI,qword ptr [RSP + 0x48]
INC RDI
LAB_0011a95f:
CALL 0x00115030
LAB_0011a964:
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0011a96b
LAB_0011a96b:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x60],RCX
JMP 0x0011a9c5
LAB_0011a9c5:
XOR EAX,EAX
CMP RAX,qword ptr [RSP + 0x48]
JZ 0x0011aa3b
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP],RCX
MOV RDI,qword ptr [RAX + 0x70]
MOV ESI,dword ptr [RAX + 0x20]
CALL 0x00117980
MOV EAX,EAX
MOV ESI,EAX
LEA RDI,[RSP + 0x20]
CALL 0x00118200
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x00115290
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RAX + 0x60]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00115280
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RAX + 0x60]
MOV RDX,qword ptr [RSP + 0x48]
MOV byte ptr [RCX + RDX*0x1],0x0
MOV RCX,qword ptr [RSP + 0x48]
MOV dword ptr [RAX + 0x68],ECX
LAB_0011aa3b:
JMP 0x0011aa3d
LAB_0011aa3d:
ADD RSP,0x98
RET
|
/* ELFIO::section_impl<ELFIO::Elf32_Shdr>::load(std::istream&, std::fpos<__mbstate_t>) */
void ELFIO::section_impl<ELFIO::Elf32_Shdr>::load
(section *param_1,char *param_2,int8 param_3,int8 param_4)
{
char *pcVar1;
int iVar2;
uint uVar3;
ulong uVar4;
ulong uVar5;
void *pvVar6;
int8 local_78;
int8 local_70;
ulong local_50;
int8 local_48;
int8 local_40;
fpos local_38 [23];
char local_21;
char *local_20;
section *local_18;
int8 local_10;
int8 local_8;
local_21 = '\0';
local_20 = param_2;
local_18 = param_1;
local_10 = param_3;
local_8 = param_4;
std::fill_n<char*,unsigned_long,char>((char *)(param_1 + 0x10),0x28,&local_21);
std::istream::seekg(local_20,0,2);
local_38._0_16_ = std::istream::tellg();
uVar4 = std::fpos::operator_cast_to_long(local_38);
section::set_stream_size(param_1,uVar4);
local_48 = local_10;
local_40 = local_8;
std::istream::seekg(local_20,local_10,local_8);
std::istream::read(local_20,(long)(param_1 + 0x10));
local_50 = (**(code **)(*(long *)param_1 + 0x98))();
if (*(long *)(param_1 + 0x60) == 0) {
iVar2 = (**(code **)(*(long *)param_1 + 0x28))();
if (iVar2 != 0) {
iVar2 = (**(code **)(*(long *)param_1 + 0x28))();
uVar4 = local_50;
if (iVar2 != 8) {
uVar5 = section::get_stream_size(param_1);
if (uVar4 < uVar5) {
/* try { // try from 0011a95f to 0011a963 has its CatchHandler @ 0011a97b */
pvVar6 = operator_new__(local_50 + 1);
pcVar1 = local_20;
*(void **)(param_1 + 0x60) = pvVar6;
if (local_50 != 0) {
uVar3 = endianess_convertor::operator()
(*(endianess_convertor **)(param_1 + 0x70),*(uint *)(param_1 + 0x20));
std::fpos<__mbstate_t>::fpos((fpos<__mbstate_t> *)&local_78,(ulong)uVar3);
std::istream::seekg(pcVar1,local_78,local_70);
std::istream::read(local_20,*(long *)(param_1 + 0x60));
*(int1 *)(*(long *)(param_1 + 0x60) + local_50) = 0;
*(int *)(param_1 + 0x68) = (int)local_50;
}
}
}
}
}
return;
}
|
|
66,485 |
ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_section.hpp
|
void
load( std::istream& stream,
std::streampos header_offset )
{
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ), '\0' );
stream.seekg ( 0, stream.end );
set_stream_size ( stream.tellg() );
stream.seekg( header_offset );
stream.read( reinterpret_cast<char*>( &header ), sizeof( header ) );
Elf_Xword size = get_size();
if ( 0 == data && SHT_NULL != get_type() && SHT_NOBITS != get_type() && size < get_stream_size()) {
try {
data = new char[size + 1];
} catch (const std::bad_alloc&) {
data = 0;
data_size = 0;
}
if ( 0 != size ) {
stream.seekg( (*convertor)( header.sh_offset ) );
stream.read( data, size );
data[size] = 0; //ensure data is ended with 0 to avoid oob read
data_size = size;
}
}
}
|
O1
|
cpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xb2a0
movq %r14, %rdi
callq 0xb350
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xb270
movl $0x40, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xb260
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
cmpq $0x0, 0x78(%rbx)
je 0xd12c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testl %eax, %eax
je 0xd122
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x8, %eax
je 0xd122
cmpq 0x8(%rbx), %r15
jae 0xd122
leaq 0x1(%r15), %rdi
callq 0xb030
movq %rax, 0x78(%rbx)
testq %r15, %r15
je 0xd122
movq 0x28(%rbx), %rax
movq 0x88(%rbx), %rcx
movq %rax, %rsi
bswapq %rsi
cmpb $0x0, (%rcx)
cmoveq %rax, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xb270
movq 0x78(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb260
movq 0x78(%rbx), %rax
movb $0x0, (%rax,%r15)
movl %r15d, 0x80(%rbx)
jmp 0xd122
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xd1ce
callq 0xb0d0
movq $0x0, 0x78(%rbx)
movl $0x0, 0x80(%rbx)
callq 0xb340
jmp 0xd15d
callq 0xb360
nop
|
_ZN5ELFIO12section_implINS_10Elf64_ShdrEE4loadERSiSt4fposI11__mbstate_tE:
push r15
push r14
push r13
push r12
push rbx
mov r12, rcx
mov r13, rdx
mov r14, rsi
mov rbx, rdi
lea r15, [rdi+10h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
mov rdi, rsi
xor esi, esi
mov edx, 2
call __ZNSi5seekgElSt12_Ios_Seekdir; std::istream::seekg(long,std::_Ios_Seekdir)
mov rdi, r14; this
call __ZNSi5tellgEv; std::istream::tellg(void)
mov [rbx+8], rax
mov rdi, r14
mov rsi, r13
mov rdx, r12
call __ZNSi5seekgESt4fposI11__mbstate_tE; std::istream::seekg(std::fpos<__mbstate_t>)
mov edx, 40h ; '@'; __int64
mov rdi, r14; this
mov rsi, r15; char *
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+98h]
cmp qword ptr [rbx+78h], 0
jz short loc_D12C
loc_D122:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_D12C:
mov r15, rax
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+28h]
test eax, eax
jz short loc_D122
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+28h]
cmp eax, 8
jz short loc_D122
cmp r15, [rbx+8]
jnb short loc_D122
lea rdi, [r15+1]; unsigned __int64
call __Znam; operator new[](ulong)
mov [rbx+78h], rax
loc_D15D:
test r15, r15
jz short loc_D122
mov rax, [rbx+28h]
mov rcx, [rbx+88h]
mov rsi, rax
bswap rsi
cmp byte ptr [rcx], 0
cmovz rsi, rax
mov rdi, r14
xor edx, edx
call __ZNSi5seekgESt4fposI11__mbstate_tE; std::istream::seekg(std::fpos<__mbstate_t>)
mov rsi, [rbx+78h]; char *
mov rdi, r14; this
mov rdx, r15; __int64
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov rax, [rbx+78h]
mov byte ptr [rax+r15], 0
mov [rbx+80h], r15d
jmp loc_D122
mov rdi, rax; void *
cmp edx, 1
jnz short loc_D1CE
call ___cxa_begin_catch
mov qword ptr [rbx+78h], 0
mov dword ptr [rbx+80h], 0
call ___cxa_end_catch
jmp short loc_D15D
loc_D1CE:
call __Unwind_Resume
|
long long ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(long long a1, std::istream *a2, long long a3, long long a4)
{
long long result; // rax
unsigned long long v8; // r15
unsigned long long v9; // rsi
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
std::istream::seekg(a2, 0LL, 2LL);
*(_QWORD *)(a1 + 8) = std::istream::tellg(a2);
std::istream::seekg(a2, a3, a4);
std::istream::read(a2, (char *)(a1 + 16), 64LL);
result = (*(long long ( **)(long long))(*(_QWORD *)a1 + 152LL))(a1);
if ( !*(_QWORD *)(a1 + 120) )
{
v8 = result;
result = (*(long long ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1);
if ( (_DWORD)result )
{
result = (*(long long ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1);
if ( (_DWORD)result != 8 && v8 < *(_QWORD *)(a1 + 8) )
{
result = operator new[](v8 + 1);
*(_QWORD *)(a1 + 120) = result;
if ( v8 )
{
v9 = _byteswap_uint64(*(_QWORD *)(a1 + 40));
if ( !**(_BYTE **)(a1 + 136) )
v9 = *(_QWORD *)(a1 + 40);
std::istream::seekg(a2, v9, 0LL);
std::istream::read(a2, *(char **)(a1 + 120), v8);
result = *(_QWORD *)(a1 + 120);
*(_BYTE *)(result + v8) = 0;
*(_DWORD *)(a1 + 128) = v8;
}
}
}
}
return result;
}
|
load:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R12,RCX
MOV R13,RDX
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RDI + 0x10]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOV RDI,RSI
XOR ESI,ESI
MOV EDX,0x2
CALL 0x0010b2a0
MOV RDI,R14
CALL 0x0010b350
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0010b270
MOV EDX,0x40
MOV RDI,R14
MOV RSI,R15
CALL 0x0010b260
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x98]
CMP qword ptr [RBX + 0x78],0x0
JZ 0x0010d12c
LAB_0010d122:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010d12c:
MOV R15,RAX
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
JZ 0x0010d122
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x28]
CMP EAX,0x8
JZ 0x0010d122
CMP R15,qword ptr [RBX + 0x8]
JNC 0x0010d122
LEA RDI,[R15 + 0x1]
LAB_0010d154:
CALL 0x0010b030
LAB_0010d159:
MOV qword ptr [RBX + 0x78],RAX
LAB_0010d15d:
TEST R15,R15
JZ 0x0010d122
MOV RAX,qword ptr [RBX + 0x28]
MOV RCX,qword ptr [RBX + 0x88]
MOV RSI,RAX
BSWAP RSI
CMP byte ptr [RCX],0x0
CMOVZ RSI,RAX
MOV RDI,R14
XOR EDX,EDX
CALL 0x0010b270
MOV RSI,qword ptr [RBX + 0x78]
MOV RDI,R14
MOV RDX,R15
CALL 0x0010b260
MOV RAX,qword ptr [RBX + 0x78]
MOV byte ptr [RAX + R15*0x1],0x0
MOV dword ptr [RBX + 0x80],R15D
JMP 0x0010d122
|
/* ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>) */
void ELFIO::section_impl<ELFIO::Elf64_Shdr>::load
(long *param_1,char *param_2,int8 param_3,int8 param_4)
{
ulong uVar1;
int iVar2;
long lVar3;
ulong uVar4;
void *pvVar5;
ulong uVar6;
param_1[8] = 0;
param_1[9] = 0;
param_1[6] = 0;
param_1[7] = 0;
param_1[4] = 0;
param_1[5] = 0;
param_1[2] = 0;
param_1[3] = 0;
std::istream::seekg(param_2,0,2);
lVar3 = std::istream::tellg();
param_1[1] = lVar3;
std::istream::seekg(param_2,param_3,param_4);
std::istream::read(param_2,(long)(param_1 + 2));
uVar4 = (**(code **)(*param_1 + 0x98))(param_1);
if (param_1[0xf] == 0) {
iVar2 = (**(code **)(*param_1 + 0x28))(param_1);
if (iVar2 != 0) {
iVar2 = (**(code **)(*param_1 + 0x28))(param_1);
if ((iVar2 != 8) && (uVar4 < (ulong)param_1[1])) {
/* try { // try from 0010d154 to 0010d158 has its CatchHandler @ 0010d1a8 */
pvVar5 = operator_new__(uVar4 + 1);
param_1[0xf] = (long)pvVar5;
if (uVar4 != 0) {
uVar1 = param_1[5];
uVar6 = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 |
(uVar1 & 0xff0000000000) >> 0x18 | (uVar1 & 0xff00000000) >> 8 |
(uVar1 & 0xff000000) << 8 | (uVar1 & 0xff0000) << 0x18 | (uVar1 & 0xff00) << 0x28
| uVar1 << 0x38;
if (*(char *)param_1[0x11] == '\0') {
uVar6 = uVar1;
}
std::istream::seekg(param_2,uVar6,0);
std::istream::read(param_2,param_1[0xf]);
*(int1 *)(param_1[0xf] + uVar4) = 0;
*(int *)(param_1 + 0x10) = (int)uVar4;
}
}
}
}
return;
}
|
|
66,486 |
ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_section.hpp
|
void
load( std::istream& stream,
std::streampos header_offset )
{
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ), '\0' );
stream.seekg ( 0, stream.end );
set_stream_size ( stream.tellg() );
stream.seekg( header_offset );
stream.read( reinterpret_cast<char*>( &header ), sizeof( header ) );
Elf_Xword size = get_size();
if ( 0 == data && SHT_NULL != get_type() && SHT_NOBITS != get_type() && size < get_stream_size()) {
try {
data = new char[size + 1];
} catch (const std::bad_alloc&) {
data = 0;
data_size = 0;
}
if ( 0 != size ) {
stream.seekg( (*convertor)( header.sh_offset ) );
stream.read( data, size );
data[size] = 0; //ensure data is ended with 0 to avoid oob read
data_size = size;
}
}
}
|
O2
|
cpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
pushq $0x2
popq %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0xc280
movq %r14, %rdi
callq 0xc330
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xc240
pushq $0x40
popq %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0xc230
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
cmpq $0x0, 0x78(%rbx)
je 0xde50
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testl %eax, %eax
je 0xde46
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x8, %eax
je 0xde46
cmpq 0x8(%rbx), %r15
jae 0xde46
leaq 0x1(%r15), %rdi
callq 0xc030
movq %rax, 0x78(%rbx)
testq %r15, %r15
je 0xde46
movq 0x28(%rbx), %rax
movq 0x88(%rbx), %rcx
movq %rax, %rsi
bswapq %rsi
cmpb $0x0, (%rcx)
cmoveq %rax, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc240
movq 0x78(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xc230
movq 0x78(%rbx), %rax
movb $0x0, (%rax,%r15)
movl %r15d, 0x80(%rbx)
jmp 0xde46
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xdeec
callq 0xc0b0
andq $0x0, 0x78(%rbx)
andl $0x0, 0x80(%rbx)
callq 0xc320
jmp 0xde81
callq 0xc340
nop
|
_ZN5ELFIO12section_implINS_10Elf64_ShdrEE4loadERSiSt4fposI11__mbstate_tE:
push r15
push r14
push r13
push r12
push rbx
mov r15, rcx
mov r12, rdx
mov r14, rsi
mov rbx, rdi
lea r13, [rdi+10h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
push 2
pop rdx
mov rdi, rsi
xor esi, esi
call __ZNSi5seekgElSt12_Ios_Seekdir; std::istream::seekg(long,std::_Ios_Seekdir)
mov rdi, r14; this
call __ZNSi5tellgEv; std::istream::tellg(void)
mov [rbx+8], rax
mov rdi, r14
mov rsi, r12
mov rdx, r15
call __ZNSi5seekgESt4fposI11__mbstate_tE; std::istream::seekg(std::fpos<__mbstate_t>)
push 40h ; '@'
pop rdx; __int64
mov rdi, r14; this
mov rsi, r13; char *
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+98h]
cmp qword ptr [rbx+78h], 0
jz short loc_DE50
loc_DE46:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_DE50:
mov r15, rax
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+28h]
test eax, eax
jz short loc_DE46
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+28h]
cmp eax, 8
jz short loc_DE46
cmp r15, [rbx+8]
jnb short loc_DE46
lea rdi, [r15+1]; unsigned __int64
call __Znam; operator new[](ulong)
mov [rbx+78h], rax
loc_DE81:
test r15, r15
jz short loc_DE46
mov rax, [rbx+28h]
mov rcx, [rbx+88h]
mov rsi, rax
bswap rsi
cmp byte ptr [rcx], 0
cmovz rsi, rax
mov rdi, r14
xor edx, edx
call __ZNSi5seekgESt4fposI11__mbstate_tE; std::istream::seekg(std::fpos<__mbstate_t>)
mov rsi, [rbx+78h]; char *
mov rdi, r14; this
mov rdx, r15; __int64
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov rax, [rbx+78h]
mov byte ptr [rax+r15], 0
mov [rbx+80h], r15d
jmp loc_DE46
mov rdi, rax; void *
cmp edx, 1
jnz short loc_DEEC
call ___cxa_begin_catch
and qword ptr [rbx+78h], 0
and dword ptr [rbx+80h], 0
call ___cxa_end_catch
jmp short loc_DE81
loc_DEEC:
call __Unwind_Resume
|
long long ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(long long a1, std::istream *a2, long long a3, long long a4)
{
long long result; // rax
unsigned long long v8; // r15
unsigned long long v9; // rsi
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
std::istream::seekg(a2, 0LL, 2LL);
*(_QWORD *)(a1 + 8) = std::istream::tellg(a2);
std::istream::seekg(a2, a3, a4);
std::istream::read(a2, (char *)(a1 + 16), 64LL);
result = (*(long long ( **)(long long))(*(_QWORD *)a1 + 152LL))(a1);
if ( !*(_QWORD *)(a1 + 120) )
{
v8 = result;
result = (*(long long ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1);
if ( (_DWORD)result )
{
result = (*(long long ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1);
if ( (_DWORD)result != 8 && v8 < *(_QWORD *)(a1 + 8) )
{
result = operator new[](v8 + 1);
*(_QWORD *)(a1 + 120) = result;
if ( v8 )
{
v9 = _byteswap_uint64(*(_QWORD *)(a1 + 40));
if ( !**(_BYTE **)(a1 + 136) )
v9 = *(_QWORD *)(a1 + 40);
std::istream::seekg(a2, v9, 0LL);
std::istream::read(a2, *(char **)(a1 + 120), v8);
result = *(_QWORD *)(a1 + 120);
*(_BYTE *)(result + v8) = 0;
*(_DWORD *)(a1 + 128) = v8;
}
}
}
}
return result;
}
|
load:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RCX
MOV R12,RDX
MOV R14,RSI
MOV RBX,RDI
LEA R13,[RDI + 0x10]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
PUSH 0x2
POP RDX
MOV RDI,RSI
XOR ESI,ESI
CALL 0x0010c280
MOV RDI,R14
CALL 0x0010c330
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x0010c240
PUSH 0x40
POP RDX
MOV RDI,R14
MOV RSI,R13
CALL 0x0010c230
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x98]
CMP qword ptr [RBX + 0x78],0x0
JZ 0x0010de50
LAB_0010de46:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010de50:
MOV R15,RAX
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
JZ 0x0010de46
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x28]
CMP EAX,0x8
JZ 0x0010de46
CMP R15,qword ptr [RBX + 0x8]
JNC 0x0010de46
LEA RDI,[R15 + 0x1]
LAB_0010de78:
CALL 0x0010c030
LAB_0010de7d:
MOV qword ptr [RBX + 0x78],RAX
LAB_0010de81:
TEST R15,R15
JZ 0x0010de46
MOV RAX,qword ptr [RBX + 0x28]
MOV RCX,qword ptr [RBX + 0x88]
MOV RSI,RAX
BSWAP RSI
CMP byte ptr [RCX],0x0
CMOVZ RSI,RAX
MOV RDI,R14
XOR EDX,EDX
CALL 0x0010c240
MOV RSI,qword ptr [RBX + 0x78]
MOV RDI,R14
MOV RDX,R15
CALL 0x0010c230
MOV RAX,qword ptr [RBX + 0x78]
MOV byte ptr [RAX + R15*0x1],0x0
MOV dword ptr [RBX + 0x80],R15D
JMP 0x0010de46
|
/* ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>) */
void ELFIO::section_impl<ELFIO::Elf64_Shdr>::load
(long *param_1,char *param_2,int8 param_3,int8 param_4)
{
ulong uVar1;
int iVar2;
long lVar3;
ulong uVar4;
void *pvVar5;
ulong uVar6;
param_1[8] = 0;
param_1[9] = 0;
param_1[6] = 0;
param_1[7] = 0;
param_1[4] = 0;
param_1[5] = 0;
param_1[2] = 0;
param_1[3] = 0;
std::istream::seekg(param_2,0,2);
lVar3 = std::istream::tellg();
param_1[1] = lVar3;
std::istream::seekg(param_2,param_3,param_4);
std::istream::read(param_2,(long)(param_1 + 2));
uVar4 = (**(code **)(*param_1 + 0x98))(param_1);
if (param_1[0xf] == 0) {
iVar2 = (**(code **)(*param_1 + 0x28))(param_1);
if (iVar2 != 0) {
iVar2 = (**(code **)(*param_1 + 0x28))(param_1);
if ((iVar2 != 8) && (uVar4 < (ulong)param_1[1])) {
/* try { // try from 0010de78 to 0010de7c has its CatchHandler @ 0010decc */
pvVar5 = operator_new__(uVar4 + 1);
param_1[0xf] = (long)pvVar5;
if (uVar4 != 0) {
uVar1 = param_1[5];
uVar6 = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 |
(uVar1 & 0xff0000000000) >> 0x18 | (uVar1 & 0xff00000000) >> 8 |
(uVar1 & 0xff000000) << 8 | (uVar1 & 0xff0000) << 0x18 | (uVar1 & 0xff00) << 0x28
| uVar1 << 0x38;
if (*(char *)param_1[0x11] == '\0') {
uVar6 = uVar1;
}
std::istream::seekg(param_2,uVar6,0);
std::istream::read(param_2,param_1[0xf]);
*(int1 *)(param_1[0xf] + uVar4) = 0;
*(int *)(param_1 + 0x10) = (int)uVar4;
}
}
}
}
return;
}
|
|
66,487 |
ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_section.hpp
|
void
load( std::istream& stream,
std::streampos header_offset )
{
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ), '\0' );
stream.seekg ( 0, stream.end );
set_stream_size ( stream.tellg() );
stream.seekg( header_offset );
stream.read( reinterpret_cast<char*>( &header ), sizeof( header ) );
Elf_Xword size = get_size();
if ( 0 == data && SHT_NULL != get_type() && SHT_NOBITS != get_type() && size < get_stream_size()) {
try {
data = new char[size + 1];
} catch (const std::bad_alloc&) {
data = 0;
data_size = 0;
}
if ( 0 != size ) {
stream.seekg( (*convertor)( header.sh_offset ) );
stream.read( data, size );
data[size] = 0; //ensure data is ended with 0 to avoid oob read
data_size = size;
}
}
}
|
O3
|
cpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x30(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xb2a0
movq %r14, %rdi
callq 0xb350
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xb270
movl $0x28, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0xb260
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
cmpq $0x0, 0x60(%rbx)
je 0xd79e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testl %eax, %eax
je 0xd794
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x8, %eax
je 0xd794
cmpq 0x8(%rbx), %r15
jae 0xd794
leaq 0x1(%r15), %rdi
callq 0xb030
movq %rax, 0x60(%rbx)
testq %r15, %r15
je 0xd794
movq 0x70(%rbx), %rax
movl 0x20(%rbx), %ecx
movl %ecx, %esi
bswapl %esi
cmpb $0x0, (%rax)
cmovel %ecx, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0xb270
movq 0x60(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb260
movq 0x60(%rbx), %rax
movb $0x0, (%rax,%r15)
movl %r15d, 0x68(%rbx)
jmp 0xd794
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xd830
callq 0xb0d0
movq $0x0, 0x60(%rbx)
movl $0x0, 0x68(%rbx)
callq 0xb340
jmp 0xd7cf
callq 0xb360
nop
|
_ZN5ELFIO12section_implINS_10Elf32_ShdrEE4loadERSiSt4fposI11__mbstate_tE:
push r15
push r14
push r13
push r12
push rbx
mov r15, rcx
mov r12, rdx
mov r14, rsi
mov rbx, rdi
lea r13, [rdi+10h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
mov qword ptr [rdi+30h], 0
mov rdi, rsi
xor esi, esi
mov edx, 2
call __ZNSi5seekgElSt12_Ios_Seekdir; std::istream::seekg(long,std::_Ios_Seekdir)
mov rdi, r14; this
call __ZNSi5tellgEv; std::istream::tellg(void)
mov [rbx+8], rax
mov rdi, r14
mov rsi, r12
mov rdx, r15
call __ZNSi5seekgESt4fposI11__mbstate_tE; std::istream::seekg(std::fpos<__mbstate_t>)
mov edx, 28h ; '('; __int64
mov rdi, r14; this
mov rsi, r13; char *
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+98h]
cmp qword ptr [rbx+60h], 0
jz short loc_D79E
loc_D794:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_D79E:
mov r15, rax
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+28h]
test eax, eax
jz short loc_D794
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+28h]
cmp eax, 8
jz short loc_D794
cmp r15, [rbx+8]
jnb short loc_D794
lea rdi, [r15+1]; unsigned __int64
call __Znam; operator new[](ulong)
mov [rbx+60h], rax
loc_D7CF:
test r15, r15
jz short loc_D794
mov rax, [rbx+70h]
mov ecx, [rbx+20h]
mov esi, ecx
bswap esi
cmp byte ptr [rax], 0
cmovz esi, ecx
mov rdi, r14
xor edx, edx
call __ZNSi5seekgESt4fposI11__mbstate_tE; std::istream::seekg(std::fpos<__mbstate_t>)
mov rsi, [rbx+60h]; char *
mov rdi, r14; this
mov rdx, r15; __int64
call __ZNSi4readEPcl; std::istream::read(char *,long)
mov rax, [rbx+60h]
mov byte ptr [rax+r15], 0
mov [rbx+68h], r15d
jmp short loc_D794
mov rdi, rax; void *
cmp edx, 1
jnz short loc_D830
call ___cxa_begin_catch
mov qword ptr [rbx+60h], 0
mov dword ptr [rbx+68h], 0
call ___cxa_end_catch
jmp short loc_D7CF
loc_D830:
call __Unwind_Resume
|
long long ELFIO::section_impl<ELFIO::Elf32_Shdr>::load(long long a1, std::istream *a2, long long a3, long long a4)
{
long long result; // rax
unsigned long long v8; // r15
long long v9; // rsi
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 48) = 0LL;
std::istream::seekg(a2, 0LL, 2LL);
*(_QWORD *)(a1 + 8) = std::istream::tellg(a2);
std::istream::seekg(a2, a3, a4);
std::istream::read(a2, (char *)(a1 + 16), 40LL);
result = (*(long long ( **)(long long))(*(_QWORD *)a1 + 152LL))(a1);
if ( !*(_QWORD *)(a1 + 96) )
{
v8 = result;
result = (*(long long ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1);
if ( (_DWORD)result )
{
result = (*(long long ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1);
if ( (_DWORD)result != 8 && v8 < *(_QWORD *)(a1 + 8) )
{
result = operator new[](v8 + 1);
*(_QWORD *)(a1 + 96) = result;
if ( v8 )
{
v9 = _byteswap_ulong(*(_DWORD *)(a1 + 32));
if ( !**(_BYTE **)(a1 + 112) )
v9 = *(unsigned int *)(a1 + 32);
std::istream::seekg(a2, v9, 0LL);
std::istream::read(a2, *(char **)(a1 + 96), v8);
result = *(_QWORD *)(a1 + 96);
*(_BYTE *)(result + v8) = 0;
*(_DWORD *)(a1 + 104) = v8;
}
}
}
}
return result;
}
|
load:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RCX
MOV R12,RDX
MOV R14,RSI
MOV RBX,RDI
LEA R13,[RDI + 0x10]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOV qword ptr [RDI + 0x30],0x0
MOV RDI,RSI
XOR ESI,ESI
MOV EDX,0x2
CALL 0x0010b2a0
MOV RDI,R14
CALL 0x0010b350
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x0010b270
MOV EDX,0x28
MOV RDI,R14
MOV RSI,R13
CALL 0x0010b260
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x98]
CMP qword ptr [RBX + 0x60],0x0
JZ 0x0010d79e
LAB_0010d794:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010d79e:
MOV R15,RAX
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
JZ 0x0010d794
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x28]
CMP EAX,0x8
JZ 0x0010d794
CMP R15,qword ptr [RBX + 0x8]
JNC 0x0010d794
LEA RDI,[R15 + 0x1]
LAB_0010d7c6:
CALL 0x0010b030
LAB_0010d7cb:
MOV qword ptr [RBX + 0x60],RAX
LAB_0010d7cf:
TEST R15,R15
JZ 0x0010d794
MOV RAX,qword ptr [RBX + 0x70]
MOV ECX,dword ptr [RBX + 0x20]
MOV ESI,ECX
BSWAP ESI
CMP byte ptr [RAX],0x0
CMOVZ ESI,ECX
MOV RDI,R14
XOR EDX,EDX
CALL 0x0010b270
MOV RSI,qword ptr [RBX + 0x60]
MOV RDI,R14
MOV RDX,R15
CALL 0x0010b260
MOV RAX,qword ptr [RBX + 0x60]
MOV byte ptr [RAX + R15*0x1],0x0
MOV dword ptr [RBX + 0x68],R15D
JMP 0x0010d794
|
/* ELFIO::section_impl<ELFIO::Elf32_Shdr>::load(std::istream&, std::fpos<__mbstate_t>) */
void ELFIO::section_impl<ELFIO::Elf32_Shdr>::load
(long *param_1,char *param_2,int8 param_3,int8 param_4)
{
uint uVar1;
uint uVar2;
int iVar3;
long lVar4;
ulong uVar5;
void *pvVar6;
param_1[4] = 0;
param_1[5] = 0;
param_1[2] = 0;
param_1[3] = 0;
param_1[6] = 0;
std::istream::seekg(param_2,0,2);
lVar4 = std::istream::tellg();
param_1[1] = lVar4;
std::istream::seekg(param_2,param_3,param_4);
std::istream::read(param_2,(long)(param_1 + 2));
uVar5 = (**(code **)(*param_1 + 0x98))(param_1);
if (param_1[0xc] == 0) {
iVar3 = (**(code **)(*param_1 + 0x28))(param_1);
if (iVar3 != 0) {
iVar3 = (**(code **)(*param_1 + 0x28))(param_1);
if ((iVar3 != 8) && (uVar5 < (ulong)param_1[1])) {
/* try { // try from 0010d7c6 to 0010d7ca has its CatchHandler @ 0010d80d */
pvVar6 = operator_new__(uVar5 + 1);
param_1[0xc] = (long)pvVar6;
if (uVar5 != 0) {
uVar1 = *(uint *)(param_1 + 4);
uVar2 = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
if (*(char *)param_1[0xe] == '\0') {
uVar2 = uVar1;
}
std::istream::seekg(param_2,uVar2,0);
std::istream::read(param_2,param_1[0xc]);
*(int1 *)(param_1[0xc] + uVar5) = 0;
*(int *)(param_1 + 0xd) = (int)uVar5;
}
}
}
}
return;
}
|
|
66,488 |
Trie::CopyTrie(Trie::TrieNode const*)
|
MikePodsytnik[P]TCRtrie/src/Trie.cpp
|
Trie::TrieNode* Trie::CopyTrie(const TrieNode* node) {
if (!node) return nullptr;
TrieNode* newNode = new TrieNode();
newNode->patternsIndices = node->patternsIndices;
for (size_t i = 0; i < node->children.size(); ++i) {
if (node->children[i]) {
newNode->children[i] = CopyTrie(node->children[i]);
}
}
return newNode;
}
|
O3
|
cpp
|
Trie::CopyTrie(Trie::TrieNode const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2ec22
movq %rsi, %rbx
movq %rdi, %r14
movl $0x108, %edi # imm = 0x108
callq 0x7420
movq %rax, %r15
movl $0xf0, %r12d
leaq (%rbx,%r12), %r13
addq %rax, %r12
xorl %ebp, %ebp
movl $0x108, %edx # imm = 0x108
movq %rax, %rdi
xorl %esi, %esi
callq 0x7220
movq %r12, %rdi
movq %r13, %rsi
callq 0x314dc
movq (%rbx,%rbp,8), %rsi
testq %rsi, %rsi
je 0x2ec17
movq %r14, %rdi
callq 0x2ebb6
movq %rax, (%r15,%rbp,8)
incq %rbp
cmpq $0x1e, %rbp
jne 0x2ec02
jmp 0x2ec25
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN4Trie8CopyTrieEPKNS_8TrieNodeE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
test rsi, rsi
jz short loc_2EC22
mov rbx, rsi
mov r14, rdi
mov edi, 108h; unsigned __int64
call __Znwm; operator new(ulong)
mov r15, rax
mov r12d, 0F0h
lea r13, [rbx+r12]
add r12, rax
xor ebp, ebp
mov edx, 108h
mov rdi, rax
xor esi, esi
call _memset
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorIiSaIiEEaSERKS1_; std::vector<int>::operator=(std::vector<int> const&)
loc_2EC02:
mov rsi, [rbx+rbp*8]
test rsi, rsi
jz short loc_2EC17
mov rdi, r14
call _ZN4Trie8CopyTrieEPKNS_8TrieNodeE; Trie::CopyTrie(Trie::TrieNode const*)
mov [r15+rbp*8], rax
loc_2EC17:
inc rbp
cmp rbp, 1Eh
jnz short loc_2EC02
jmp short loc_2EC25
loc_2EC22:
xor r15d, r15d
loc_2EC25:
mov rax, r15
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long Trie::CopyTrie(long long a1, long long a2)
{
long long v3; // r15
long long v4; // rbp
long long v5; // rsi
if ( !a2 )
return 0LL;
v3 = operator new(0x108uLL);
v4 = 0LL;
memset(v3, 0LL, 264LL);
std::vector<int>::operator=(v3 + 240, a2 + 240);
do
{
v5 = *(_QWORD *)(a2 + 8 * v4);
if ( v5 )
*(_QWORD *)(v3 + 8 * v4) = Trie::CopyTrie(a1, v5);
++v4;
}
while ( v4 != 30 );
return v3;
}
|
CopyTrie:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
TEST RSI,RSI
JZ 0x0012ec22
MOV RBX,RSI
MOV R14,RDI
MOV EDI,0x108
CALL 0x00107420
MOV R15,RAX
MOV R12D,0xf0
LEA R13,[RBX + R12*0x1]
ADD R12,RAX
XOR EBP,EBP
MOV EDX,0x108
MOV RDI,RAX
XOR ESI,ESI
CALL 0x00107220
MOV RDI,R12
MOV RSI,R13
CALL 0x001314dc
LAB_0012ec02:
MOV RSI,qword ptr [RBX + RBP*0x8]
TEST RSI,RSI
JZ 0x0012ec17
MOV RDI,R14
CALL 0x0012ebb6
MOV qword ptr [R15 + RBP*0x8],RAX
LAB_0012ec17:
INC RBP
CMP RBP,0x1e
JNZ 0x0012ec02
JMP 0x0012ec25
LAB_0012ec22:
XOR R15D,R15D
LAB_0012ec25:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Trie::CopyTrie(Trie::TrieNode const*) */
void * __thiscall Trie::CopyTrie(Trie *this,TrieNode *param_1)
{
void *__s;
int8 uVar1;
long lVar2;
if (param_1 == (TrieNode *)0x0) {
__s = (void *)0x0;
}
else {
__s = operator_new(0x108);
lVar2 = 0;
memset(__s,0,0x108);
std::vector<int,std::allocator<int>>::operator=
((vector<int,std::allocator<int>> *)((long)__s + 0xf0),(vector *)(param_1 + 0xf0));
do {
if (*(TrieNode **)(param_1 + lVar2 * 8) != (TrieNode *)0x0) {
uVar1 = CopyTrie(this,*(TrieNode **)(param_1 + lVar2 * 8));
*(int8 *)((long)__s + lVar2 * 8) = uVar1;
}
lVar2 = lVar2 + 1;
} while (lVar2 != 0x1e);
}
return __s;
}
|
|
66,489 |
Destroy(Context&, Object&)
|
csit-sgu[P]mit-game-2025-team-tyler/internal.cpp
|
void Destroy(Context &ctx, Object &obj) {
ctx.to_destroy.push_back(obj.id);
}
|
O3
|
cpp
|
Destroy(Context&, Object&):
movq %rsi, %rdx
addq $0x8, %rdx
movq 0x70(%rdi), %rsi
cmpq 0x78(%rdi), %rsi
je 0xeacd
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x70(%rdi)
retq
addq $0x68, %rdi
jmp 0x103e8
|
_Z7DestroyR7ContextR6Object:
mov rdx, rsi
add rdx, 8
mov rsi, [rdi+70h]
cmp rsi, [rdi+78h]
jz short loc_EACD
mov rax, [rdx]
mov [rsi], rax
add rsi, 8
mov [rdi+70h], rsi
retn
loc_EACD:
add rdi, 68h ; 'h'
jmp _ZNSt6vectorImSaImEE17_M_realloc_insertIJRKmEEEvN9__gnu_cxx17__normal_iteratorIPmS1_EEDpOT_; std::vector<ulong>::_M_realloc_insert<ulong const&>(__gnu_cxx::__normal_iterator<ulong *,std::vector<ulong>>,ulong const&)
|
long long Destroy(Context *a1, Object *a2)
{
long long *v2; // rdx
long long *v3; // rsi
long long result; // rax
v2 = (long long *)((char *)a2 + 8);
v3 = (long long *)*((_QWORD *)a1 + 14);
if ( v3 == *((long long **)a1 + 15) )
return std::vector<unsigned long>::_M_realloc_insert<unsigned long const&>((char *)a1 + 104, v3, v2);
result = *v2;
*v3 = *v2;
*((_QWORD *)a1 + 14) = v3 + 1;
return result;
}
|
Destroy:
MOV RDX,RSI
ADD RDX,0x8
MOV RSI,qword ptr [RDI + 0x70]
CMP RSI,qword ptr [RDI + 0x78]
JZ 0x0010eacd
MOV RAX,qword ptr [RDX]
MOV qword ptr [RSI],RAX
ADD RSI,0x8
MOV qword ptr [RDI + 0x70],RSI
RET
LAB_0010eacd:
ADD RDI,0x68
JMP 0x001103e8
|
/* Destroy(Context&, Object&) */
void Destroy(Context *param_1,Object *param_2)
{
int8 *puVar1;
puVar1 = *(int8 **)(param_1 + 0x70);
if (puVar1 != *(int8 **)(param_1 + 0x78)) {
*puVar1 = *(int8 *)(param_2 + 8);
*(int8 **)(param_1 + 0x70) = puVar1 + 1;
return;
}
std::vector<unsigned_long,std::allocator<unsigned_long>>::_M_realloc_insert<unsigned_long_const&>
((vector<unsigned_long,std::allocator<unsigned_long>> *)(param_1 + 0x68));
return;
}
|
|
66,490 |
eth_ssz_type_for_denep
|
corpus-core[P]colibri-stateless/src/chains/eth/ssz/beacon_denep.c
|
const ssz_def_t* eth_ssz_type_for_denep(eth_ssz_type_t type) {
switch (type) {
#ifdef PROOFER
case ETH_SSZ_SIGNED_BEACON_BLOCK_CONTAINER:
return &SIGNED_BEACON_BLOCK_CONTAINER;
case ETH_SSZ_BEACON_BLOCK_BODY_CONTAINER:
return &BEACON_BLOCK_BODY_CONTAINER;
case ETH_SSZ_BEACON_BLOCK_HEADER:
return &BEACON_BLOCKHEADER_CONTAINER;
#endif
default:
return eth_ssz_verification_type(type);
}
}
|
O3
|
c
|
eth_ssz_type_for_denep:
leal -0x1(%rdi), %eax
cmpl $0x3, %eax
jae 0x23bd1
movl %eax, %eax
leaq 0x5c1fb(%rip), %rcx # 0x7fdc4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
jmp 0x23998
nop
|
eth_ssz_type_for_denep:
lea eax, [rdi-1]
cmp eax, 3
jnb short loc_23BD1
mov eax, eax
lea rcx, unk_7FDC4
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_23BD1:
jmp eth_ssz_verification_type
|
char ** eth_ssz_type_for_denep(int a1)
{
if ( (unsigned int)(a1 - 1) >= 3 )
return eth_ssz_verification_type(a1);
else
return (char **)((char *)dword_7FDC4 + dword_7FDC4[a1 - 1]);
}
|
eth_ssz_type_for_denep:
LEA EAX,[RDI + -0x1]
CMP EAX,0x3
JNC 0x00123bd1
MOV EAX,EAX
LEA RCX,[0x17fdc4]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_00123bd1:
JMP 0x00123998
|
int * eth_ssz_type_for_denep(int param_1)
{
int *puVar1;
if (param_1 - 1U < 3) {
return &DAT_0017fdc4 + *(int *)(&DAT_0017fdc4 + (ulong)(param_1 - 1U) * 4);
}
puVar1 = (int *)eth_ssz_verification_type();
return puVar1;
}
|
|
66,491 |
LefDefParser::lefwMacroPinResistance(double)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwMacroPinResistance(double resistance)
{
lefwObsoleteNum = LEFW_MACRO_RESISTANCE;
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroPin)
return LEFW_BAD_ORDER;
if (versionNum >= 5.4)
return LEFW_OBSOLETE;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " RESISTANCE %.11g ;\n", resistance);
else
fprintf(lefwFile, " RESISTANCE %.11g ;\n", resistance);
lefwLines++;
lefwState = LEFW_MACRO;
return LEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::lefwMacroPinResistance(double):
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movl $0x31, 0x11654(%rip) # 0x32d48
leaq 0x11705(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x2170e
movl $0x1, 0x14(%rsp)
jmp 0x217d1
leaq 0x1193f(%rip), %rax # 0x33054
cmpl $0x0, (%rax)
jne 0x21727
movl $0x2, 0x14(%rsp)
jmp 0x217d1
leaq 0x11972(%rip), %rax # 0x330a0
cmpl $0x0, (%rax)
jne 0x21740
movl $0x2, 0x14(%rsp)
jmp 0x217d1
movsd 0x115f8(%rip), %xmm0 # 0x32d40
movsd 0x7ab0(%rip), %xmm1 # 0x29200
ucomisd %xmm1, %xmm0
jb 0x21760
movl $0x7, 0x14(%rsp)
jmp 0x217d1
cmpl $0x0, 0x11985(%rip) # 0x330ec
je 0x21789
leaq 0x11690(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x9952(%rip), %rsi # 0x2b0d2
movb $0x1, %al
callq 0x289b0
jmp 0x217a7
leaq 0x11670(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x9932(%rip), %rsi # 0x2b0d2
movb $0x1, %al
callq 0x1100
leaq 0x1189e(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x11892(%rip), %rax # 0x3304c
movl %ecx, (%rax)
leaq 0x1188d(%rip), %rax # 0x33050
movl $0x21, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
|
_ZN12LefDefParser22lefwMacroPinResistanceEd:
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
mov cs:_ZN12LefDefParserL15lefwObsoleteNumE, 31h ; '1'; LefDefParser::lefwObsoleteNum
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_2170E
mov [rsp+18h+var_4], 1
jmp loc_217D1
loc_2170E:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_21727
mov [rsp+18h+var_4], 2
jmp loc_217D1
loc_21727:
lea rax, _ZN12LefDefParser14lefwIsMacroPinE; LefDefParser::lefwIsMacroPin
cmp dword ptr [rax], 0
jnz short loc_21740
mov [rsp+18h+var_4], 2
jmp loc_217D1
loc_21740:
movsd xmm0, cs:_ZN12LefDefParserL10versionNumE; LefDefParser::versionNum
movsd xmm1, cs:dbl_29200
ucomisd xmm0, xmm1
jb short loc_21760
mov [rsp+18h+var_4], 7
jmp short loc_217D1
loc_21760:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_21789
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aResistance11g; " RESISTANCE %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_217A7
loc_21789:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aResistance11g; " RESISTANCE %.11g ;\n"
mov al, 1
call _fprintf
loc_217A7:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 21h ; '!'
mov [rsp+18h+var_4], 0
loc_217D1:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
|
long long LefDefParser::lefwMacroPinResistance(
LefDefParser *this,
double a2,
long long a3,
int a4,
int a5,
int a6,
int a7)
{
LefDefParser::lefwObsoleteNum = 49;
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwIsMacroPin )
{
if ( *(double *)&LefDefParser::versionNum < 5.4 )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" RESISTANCE %.11g ;\n", a4, a5, a6, a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " RESISTANCE %.11g ;\n", a2);
++LefDefParser::lefwLines;
LefDefParser::lefwState = 33;
return 0;
}
else
{
return 7;
}
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
lefwMacroPinResistance:
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
MOV dword ptr [0x00132d48],0x31
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x0012170e
MOV dword ptr [RSP + 0x14],0x1
JMP 0x001217d1
LAB_0012170e:
LEA RAX,[0x133054]
CMP dword ptr [RAX],0x0
JNZ 0x00121727
MOV dword ptr [RSP + 0x14],0x2
JMP 0x001217d1
LAB_00121727:
LEA RAX,[0x1330a0]
CMP dword ptr [RAX],0x0
JNZ 0x00121740
MOV dword ptr [RSP + 0x14],0x2
JMP 0x001217d1
LAB_00121740:
MOVSD XMM0,qword ptr [0x00132d40]
MOVSD XMM1,qword ptr [0x00129200]
UCOMISD XMM0,XMM1
JC 0x00121760
MOV dword ptr [RSP + 0x14],0x7
JMP 0x001217d1
LAB_00121760:
CMP dword ptr [0x001330ec],0x0
JZ 0x00121789
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12b0d2]
MOV AL,0x1
CALL 0x001289b0
JMP 0x001217a7
LAB_00121789:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12b0d2]
MOV AL,0x1
CALL 0x00101100
LAB_001217a7:
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x133050]
MOV dword ptr [RAX],0x21
MOV dword ptr [RSP + 0x14],0x0
LAB_001217d1:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwMacroPinResistance(double) */
int4 LefDefParser::lefwMacroPinResistance(double param_1)
{
int4 local_4;
lefwObsoleteNum = 0x31;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if (lefwIsMacroPin == 0) {
local_4 = 2;
}
else if (versionNum < DAT_00129200) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," RESISTANCE %.11g ;\n",param_1);
}
else {
encPrint(lefwFile," RESISTANCE %.11g ;\n",param_1);
}
lefwLines = lefwLines + 1;
lefwState = 0x21;
local_4 = 0;
}
else {
local_4 = 7;
}
return local_4;
}
|
|
66,492 |
wait_for_readers
|
eloqsql/mysys/mf_keycache.c
|
static void wait_for_readers(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block)
{
struct st_my_thread_var *thread= my_thread_var;
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
DBUG_ASSERT(!(block->status & (BLOCK_IN_FLUSH | BLOCK_CHANGED)));
DBUG_ASSERT(block->hash_link);
DBUG_ASSERT(block->hash_link->block == block);
/* Linked in file_blocks or changed_blocks hash. */
DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
/* Not linked in LRU ring. */
DBUG_ASSERT(!block->next_used);
DBUG_ASSERT(!block->prev_used);
while (block->hash_link->requests)
{
KEYCACHE_DBUG_PRINT("wait_for_readers: wait",
("suspend thread %ld block %u",
(ulong) thread->id, BLOCK_NUMBER(block)));
/* There must be no other waiter. We have no queue here. */
DBUG_ASSERT(!block->condvar);
block->condvar= &thread->suspend;
keycache_pthread_cond_wait(&thread->suspend, &keycache->cache_lock);
block->condvar= NULL;
}
}
|
O0
|
c
|
wait_for_readers:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xf55f0
movq %rax, -0x18(%rbp)
jmp 0xe4abb
jmp 0xe4abd
jmp 0xe4abf
jmp 0xe4ac1
jmp 0xe4ac3
jmp 0xe4ac5
jmp 0xe4ac7
jmp 0xe4ac9
jmp 0xe4acb
jmp 0xe4acd
jmp 0xe4acf
jmp 0xe4ad1
jmp 0xe4ad3
jmp 0xe4ad5
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x28(%rax)
je 0xe4b2d
jmp 0xe4ae5
jmp 0xe4ae7
jmp 0xe4ae9
jmp 0xe4aeb
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0xc0, %rsi
leaq 0x6e566(%rip), %rdx # 0x15307b
movl $0x68f, %ecx # imm = 0x68F
callq 0xe4430
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
jmp 0xe4ad5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
wait_for_readers_0:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
call _my_thread_var
mov [rbp+var_18], rax
jmp short $+2
loc_E4ABB:
jmp short $+2
loc_E4ABD:
jmp short $+2
loc_E4ABF:
jmp short $+2
loc_E4AC1:
jmp short $+2
loc_E4AC3:
jmp short $+2
loc_E4AC5:
jmp short $+2
loc_E4AC7:
jmp short $+2
loc_E4AC9:
jmp short $+2
loc_E4ACB:
jmp short $+2
loc_E4ACD:
jmp short $+2
loc_E4ACF:
jmp short $+2
loc_E4AD1:
jmp short $+2
loc_E4AD3:
jmp short $+2
loc_E4AD5:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
cmp dword ptr [rax+28h], 0
jz short loc_E4B2D
jmp short $+2
loc_E4AE5:
jmp short $+2
loc_E4AE7:
jmp short $+2
loc_E4AE9:
jmp short $+2
loc_E4AEB:
mov rcx, [rbp+var_18]
add rcx, 8
mov rax, [rbp+var_10]
mov [rax+68h], rcx
mov rdi, [rbp+var_18]
add rdi, 8
mov rsi, [rbp+var_8]
add rsi, 0C0h
lea rdx, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 68Fh
call inline_mysql_cond_wait_4
mov rax, [rbp+var_10]
mov qword ptr [rax+68h], 0
jmp short loc_E4AD5
loc_E4B2D:
add rsp, 20h
pop rbp
retn
|
long long wait_for_readers_0(long long a1, long long a2, double a3)
{
long long result; // rax
long long v4; // [rsp+8h] [rbp-18h]
v4 = my_thread_var(a3);
while ( 1 )
{
result = *(_QWORD *)(a2 + 32);
if ( !*(_DWORD *)(result + 40) )
break;
*(_QWORD *)(a2 + 104) = v4 + 8;
inline_mysql_cond_wait_4(
v4 + 8,
a1 + 192,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0x68Fu);
*(_QWORD *)(a2 + 104) = 0LL;
}
return result;
}
|
wait_for_readers:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
CALL 0x001f55f0
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001e4abb
LAB_001e4abb:
JMP 0x001e4abd
LAB_001e4abd:
JMP 0x001e4abf
LAB_001e4abf:
JMP 0x001e4ac1
LAB_001e4ac1:
JMP 0x001e4ac3
LAB_001e4ac3:
JMP 0x001e4ac5
LAB_001e4ac5:
JMP 0x001e4ac7
LAB_001e4ac7:
JMP 0x001e4ac9
LAB_001e4ac9:
JMP 0x001e4acb
LAB_001e4acb:
JMP 0x001e4acd
LAB_001e4acd:
JMP 0x001e4acf
LAB_001e4acf:
JMP 0x001e4ad1
LAB_001e4ad1:
JMP 0x001e4ad3
LAB_001e4ad3:
JMP 0x001e4ad5
LAB_001e4ad5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
CMP dword ptr [RAX + 0x28],0x0
JZ 0x001e4b2d
JMP 0x001e4ae5
LAB_001e4ae5:
JMP 0x001e4ae7
LAB_001e4ae7:
JMP 0x001e4ae9
LAB_001e4ae9:
JMP 0x001e4aeb
LAB_001e4aeb:
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x68],RCX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xc0
LEA RDX,[0x25307b]
MOV ECX,0x68f
CALL 0x001e4430
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x68],0x0
JMP 0x001e4ad5
LAB_001e4b2d:
ADD RSP,0x20
POP RBP
RET
|
void wait_for_readers(long param_1,long param_2)
{
long lVar1;
lVar1 = _my_thread_var();
while (*(int *)(*(long *)(param_2 + 0x20) + 0x28) != 0) {
*(long *)(param_2 + 0x68) = lVar1 + 8;
inline_mysql_cond_wait
(lVar1 + 8,param_1 + 0xc0,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0x68f);
*(int8 *)(param_2 + 0x68) = 0;
}
return;
}
|
|
66,493 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t)
|
llama.cpp/common/json.hpp
|
void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x8d4f4
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %cl, %sil
jne 0x8d4f4
movq %rdi, %rbx
leal -0x1(%r14), %ecx
cmpb $0x1, %cl
ja 0x8d46f
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
cmpb $0x2, %r14b
jne 0x8d315
movq %rsp, %rdi
callq 0x8d538
movq (%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
subq %r15, %r13
sarq $0x4, %r13
testq %r13, %r13
jle 0x8d356
incq %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8c504
addq $0x10, %r15
decq %r13
cmpq $0x1, %r13
ja 0x8d2fb
jmp 0x8d356
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x8d538
movq (%rbx), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x8d356
movq %rsp, %r15
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x8c504
addq $0x30, %r12
cmpq %r13, %r12
jne 0x8d340
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
je 0x8d467
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq -0x10(%r13), %rdi
movups -0x10(%r13), %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x886ee
movb $0x0, -0x10(%r13)
movq $0x0, -0x8(%r13)
movq %r15, %rdi
movl $0x1, %esi
callq 0x886ee
movq 0x8(%rsp), %r13
addq $-0x10, %r13
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x886ee
movq %r13, %rdi
callq 0x8ce08
movzbl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x8d410
cmpl $0x2, %eax
jne 0x8d446
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
subq %r13, %rbp
sarq $0x4, %rbp
testq %rbp, %rbp
jle 0x8d406
incq %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x8c504
addq $0x10, %r13
decq %rbp
cmpq $0x1, %rbp
jg 0x8d3e6
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x8d68c
jmp 0x8d446
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
cmpq %rbp, %r13
je 0x8d43e
leaq 0x20(%r13), %rsi
movq %r12, %rdi
callq 0x8c504
addq $0x30, %r13
cmpq %rbp, %r13
jne 0x8d421
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x8d6d2
movq %r15, %rdi
xorl %esi, %esi
callq 0x886ee
movq %r15, %rdi
callq 0x8ce08
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
jne 0x8d36d
movq %rsp, %rdi
callq 0x8d63a
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x8d4f4
leaq 0x890df(%rip), %rcx # 0x116560
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x8d78c
jmp 0x8d4b1
movq (%rbx), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x8d4b4
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x211a0
movq (%rbx), %rdi
movl $0x20, %esi
jmp 0x8d4ef
movq (%rbx), %rdi
callq 0x8d63a
movq (%rbx), %rdi
movl $0x18, %esi
jmp 0x8d4ef
movq (%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x8d4ea
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x211a0
movq (%rbx), %rdi
movl $0x28, %esi
callq 0x211a0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8d507
jmp 0x8d507
movq %rax, %rbx
jmp 0x8d528
jmp 0x8d50e
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x886ee
movq %r14, %rdi
callq 0x8ce08
movq %rsp, %rdi
callq 0x8d63a
movq %rbx, %rdi
callq 0x21c10
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
cmp esi, 1
setz cl
mov rax, [rdi]
test rax, rax
setz dl
test cl, dl
jnz def_8D488; jumptable 000000000008D488 default case, cases 4-7
mov r14d, esi
test rax, rax
setz cl
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, cl
jnz def_8D488; jumptable 000000000008D488 default case, cases 4-7
mov rbx, rdi
lea ecx, [r14-1]
cmp cl, 1
ja loc_8D46F
xorps xmm0, xmm0
movaps [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 0
mov rsi, [rax+8]
sub rsi, [rax]
sar rsi, 4
cmp r14b, 2
jnz short loc_8D315
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r15, [rax]
mov r13, [rax+8]
sub r13, r15
sar r13, 4
test r13, r13
jle short loc_8D356
inc r13
mov r12, rsp
loc_8D2FB:
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
add r15, 10h
dec r13
cmp r13, 1
ja short loc_8D2FB
jmp short loc_8D356
loc_8D315:
mov rax, 0AAAAAAAAAAAAAAABh
imul rax, rsi
mov rdi, rsp
mov rsi, rax
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r12, [rax]
mov r13, [rax+8]
cmp r12, r13
jz short loc_8D356
mov r15, rsp
loc_8D340:
lea rsi, [r12+20h]
mov rdi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
add r12, 30h ; '0'
cmp r12, r13
jnz short loc_8D340
loc_8D356:
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jz loc_8D467
lea r15, [rsp+68h+var_48]
mov r12, rsp
loc_8D36D:
lea rdi, [r13-10h]
movups xmm0, xmmword ptr [r13-10h]
movaps [rsp+68h+var_48], xmm0
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r13-10h], 0
mov qword ptr [r13-8], 0
mov rdi, r15
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 r13, qword ptr [rsp+68h+var_68+8]
add r13, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+68h+var_68+8], r13
mov rdi, r13
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
movzx eax, byte ptr [rsp+68h+var_48]
cmp eax, 1
jz short loc_8D410
cmp eax, 2
jnz short loc_8D446
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
sub rbp, r13
sar rbp, 4
test rbp, rbp
jle short loc_8D406
inc rbp
loc_8D3E6:
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
add r13, 10h
dec rbp
cmp rbp, 1
jg short loc_8D3E6
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_8D406:
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE15_M_erase_at_endEPSD_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::_M_erase_at_end(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>*)
jmp short loc_8D446
loc_8D410:
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
cmp r13, rbp
jz short loc_8D43E
loc_8D421:
lea rsi, [r13+20h]
mov rdi, r12
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
add r13, 30h ; '0'
cmp r13, rbp
jnz short loc_8D421
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_8D43E:
mov rsi, r13
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE15_M_erase_at_endEPSG_; 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>>>::_M_erase_at_end(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>>*)
loc_8D446:
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jnz loc_8D36D
loc_8D467:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_8D46F:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja short def_8D488; jumptable 000000000008D488 default case, cases 4-7
lea rcx, jpt_8D488
movsxd rax, ds:(jpt_8D488 - 116560h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_8D48A:
mov rdi, [rbx]; jumptable 000000000008D488 case 1
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EED2Ev; 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>>>::~vector()
jmp short loc_8D4B1
loc_8D494:
mov rdi, [rbx]; jumptable 000000000008D488 case 3
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_8D4B4
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_8D4B1:
mov rdi, [rbx]
loc_8D4B4:
mov esi, 20h ; ' '
jmp short loc_8D4EF
loc_8D4BB:
mov rdi, [rbx]; jumptable 000000000008D488 case 2
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, [rbx]
mov esi, 18h
jmp short loc_8D4EF
loc_8D4CD:
mov rdi, [rbx]; jumptable 000000000008D488 case 8
mov rax, [rdi]
test rax, rax
jz short loc_8D4EA
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [rbx]; void *
loc_8D4EA:
mov esi, 28h ; '('; unsigned __int64
loc_8D4EF:
call __ZdlPvm; operator delete(void *,ulong)
def_8D488:
add rsp, 38h; jumptable 000000000008D488 default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_8D507
jmp short $+2
loc_8D507:
mov rbx, rax
jmp short loc_8D528
jmp short $+2
loc_8D50E:
mov rbx, rax
lea r14, [rsp+arg_18]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_8D528:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, rbx
call __Unwind_Resume
|
void nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
long long **a1,
int a2)
{
long long *v2; // rax
char v3; // r14
long long v5; // rsi
long long v6; // r15
long long v7; // r13
long long v8; // r13
bool v9; // cf
long long v10; // r12
long long i; // r13
long long j; // r13
char *v13; // r13
long long v14; // rdi
long long v15; // r13
long long v16; // rbp
long long v17; // rbp
long long v18; // rdi
long long v19; // r13
long long v20; // rbp
void **v21; // rdi
_QWORD *v22; // rcx
unsigned long long v23; // rsi
long long v24; // rax
__int128 v25; // [rsp+0h] [rbp-68h] BYREF
long long v26; // [rsp+10h] [rbp-58h]
_OWORD v27[4]; // [rsp+20h] [rbp-48h] BYREF
v2 = *a1;
if ( *a1 != 0LL || a2 != 1 )
{
v3 = a2;
if ( v2 != 0LL || (a2 & 0xFE) != 2 && (_BYTE)a2 != 8 )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v25 = 0LL;
v26 = 0LL;
v5 = (v2[1] - *v2) >> 4;
if ( v3 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
v5);
v6 = **a1;
v7 = ((*a1)[1] - v6) >> 4;
if ( v7 > 0 )
{
v8 = v7 + 1;
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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)&v25,
v6);
v6 += 16LL;
v9 = v8-- == 1;
}
while ( !v9 && v8 != 1 );
}
}
else
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
0xAAAAAAAAAAAAAAABLL * v5);
v10 = **a1;
for ( i = (*a1)[1]; v10 != i; v10 += 48LL )
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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)&v25,
v10 + 32);
}
for ( j = *((_QWORD *)&v25 + 1); (_QWORD)v25 != *((_QWORD *)&v25 + 1); j = *((_QWORD *)&v25 + 1) )
{
v27[0] = *(_OWORD *)(j - 16);
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 *)(j - 16));
*(_BYTE *)(j - 16) = 0;
*(_QWORD *)(j - 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 *)v27);
v13 = (char *)(*((_QWORD *)&v25 + 1) - 16LL);
*((_QWORD *)&v25 + 1) = v13;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
if ( LOBYTE(v27[0]) == 1 )
{
v18 = *((_QWORD *)&v27[0] + 1);
v19 = **((_QWORD **)&v27[0] + 1);
v20 = *(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL);
if ( **((_QWORD **)&v27[0] + 1) != v20 )
{
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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)&v25,
v19 + 32);
v19 += 48LL;
}
while ( v19 != v20 );
v18 = *((_QWORD *)&v27[0] + 1);
v19 = **((_QWORD **)&v27[0] + 1);
}
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>>>::_M_erase_at_end(
v18,
v19);
}
else if ( LOBYTE(v27[0]) == 2 )
{
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
v16 = (long long)(*(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL) - **((_QWORD **)&v27[0] + 1)) >> 4;
if ( v16 > 0 )
{
v17 = v16 + 1;
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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)&v25,
v15);
v15 += 16LL;
--v17;
}
while ( v17 > 1 );
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::_M_erase_at_end(
v14,
v15);
}
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 *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v25);
}
switch ( v3 )
{
case 1:
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>>>::~vector(*a1);
goto LABEL_29;
case 2:
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(*a1);
v21 = (void **)*a1;
v23 = 24LL;
goto LABEL_35;
case 3:
v21 = (void **)*a1;
v22 = *a1 + 2;
if ( (_QWORD *)**a1 != v22 )
{
operator delete((void *)**a1, *v22 + 1LL);
LABEL_29:
v21 = (void **)*a1;
}
v23 = 32LL;
goto LABEL_35;
case 8:
v21 = (void **)*a1;
v24 = **a1;
if ( v24 )
{
operator delete((void *)**a1, (unsigned long long)v21[2] - v24);
v21 = (void **)*a1;
}
v23 = 40LL;
LABEL_35:
operator delete(v21, v23);
break;
default:
return;
}
}
}
}
|
destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
CMP ESI,0x1
SETZ CL
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
SETZ DL
TEST CL,DL
JNZ 0x0018d4f4
MOV R14D,ESI
TEST RAX,RAX
SETZ CL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,CL
JNZ 0x0018d4f4
MOV RBX,RDI
LEA ECX,[R14 + -0x1]
CMP CL,0x1
JA 0x0018d46f
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
SAR RSI,0x4
CMP R14B,0x2
JNZ 0x0018d315
LAB_0018d2d7:
MOV RDI,RSP
CALL 0x0018d538
MOV RAX,qword ptr [RBX]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
SUB R13,R15
SAR R13,0x4
TEST R13,R13
JLE 0x0018d356
INC R13
MOV R12,RSP
LAB_0018d2fb:
MOV RDI,R12
MOV RSI,R15
CALL 0x0018c504
ADD R15,0x10
DEC R13
CMP R13,0x1
JA 0x0018d2fb
JMP 0x0018d356
LAB_0018d315:
MOV RAX,-0x5555555555555555
IMUL RAX,RSI
LAB_0018d323:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x0018d538
MOV RAX,qword ptr [RBX]
MOV R12,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
CMP R12,R13
JZ 0x0018d356
MOV R15,RSP
LAB_0018d340:
LEA RSI,[R12 + 0x20]
LAB_0018d345:
MOV RDI,R15
CALL 0x0018c504
ADD R12,0x30
CMP R12,R13
JNZ 0x0018d340
LAB_0018d356:
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JZ 0x0018d467
LEA R15,[RSP + 0x20]
MOV R12,RSP
LAB_0018d36d:
LEA RDI,[R13 + -0x10]
MOVUPS XMM0,xmmword ptr [R13 + -0x10]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
XOR ESI,ESI
CALL 0x001886ee
MOV byte ptr [R13 + -0x10],0x0
MOV qword ptr [R13 + -0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001886ee
MOV R13,qword ptr [RSP + 0x8]
ADD R13,-0x10
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R13
XOR ESI,ESI
CALL 0x001886ee
MOV RDI,R13
CALL 0x0018ce08
MOVZX EAX,byte ptr [RSP + 0x20]
CMP EAX,0x1
JZ 0x0018d410
CMP EAX,0x2
JNZ 0x0018d446
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
SUB RBP,R13
SAR RBP,0x4
TEST RBP,RBP
JLE 0x0018d406
INC RBP
LAB_0018d3e6:
MOV RDI,R12
MOV RSI,R13
CALL 0x0018c504
ADD R13,0x10
DEC RBP
CMP RBP,0x1
JG 0x0018d3e6
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_0018d406:
MOV RSI,R13
CALL 0x0018d68c
JMP 0x0018d446
LAB_0018d410:
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
CMP R13,RBP
JZ 0x0018d43e
LAB_0018d421:
LEA RSI,[R13 + 0x20]
LAB_0018d425:
MOV RDI,R12
CALL 0x0018c504
LAB_0018d42d:
ADD R13,0x30
CMP R13,RBP
JNZ 0x0018d421
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_0018d43e:
MOV RSI,R13
CALL 0x0018d6d2
LAB_0018d446:
MOV RDI,R15
XOR ESI,ESI
CALL 0x001886ee
MOV RDI,R15
CALL 0x0018ce08
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JNZ 0x0018d36d
LAB_0018d467:
MOV RDI,RSP
CALL 0x0018d63a
LAB_0018d46f:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x0018d4f4
LEA RCX,[0x216560]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x0018d78c
JMP 0x0018d4b1
caseD_3:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x0018d4b4
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x001211a0
LAB_0018d4b1:
MOV RDI,qword ptr [RBX]
LAB_0018d4b4:
MOV ESI,0x20
JMP 0x0018d4ef
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x0018d63a
MOV RDI,qword ptr [RBX]
MOV ESI,0x18
JMP 0x0018d4ef
caseD_8:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0018d4ea
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x001211a0
MOV RDI,qword ptr [RBX]
LAB_0018d4ea:
MOV ESI,0x28
LAB_0018d4ef:
CALL 0x001211a0
caseD_4:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy(json_value *this,uint param_2)
{
long *plVar1;
long lVar2;
pair *ppVar3;
void *pvVar4;
byte bVar5;
ulong uVar6;
bool bVar7;
int8 *puVar8;
long lVar9;
data *pdVar10;
pair *ppVar11;
basic_json *pbVar12;
data *local_68;
data *pdStack_60;
int8 local_58;
int8 local_48;
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*pvStack_40;
plVar1 = *(long **)this;
if (param_2 == 1 && plVar1 == (long *)0x0) {
return;
}
bVar5 = (byte)param_2;
if ((bVar5 == 8 || (bVar5 & 0xfe) == 2) && plVar1 == (long *)0x0) {
return;
}
if ((byte)(bVar5 - 1) < 2) {
local_68 = (data *)0x0;
pdStack_60 = (data *)0x0;
local_58 = 0;
uVar6 = plVar1[1] - *plVar1 >> 4;
if (bVar5 == 2) {
/* try { // try from 0018d2d7 to 0018d2de has its CatchHandler @ 0018d503 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,uVar6);
pbVar12 = (basic_json *)**(long **)this;
lVar9 = (*(long **)this)[1] - (long)pbVar12 >> 4;
if (0 < lVar9) {
uVar6 = lVar9 + 1;
do {
/* try { // try from 0018d2fb to 0018d305 has its CatchHandler @ 0018d507 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar12);
pbVar12 = pbVar12 + 0x10;
uVar6 = uVar6 - 1;
} while (1 < uVar6);
}
}
else {
/* try { // try from 0018d323 to 0018d32d has its CatchHandler @ 0018d503 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,uVar6 * -0x5555555555555555);
lVar2 = (*(long **)this)[1];
for (lVar9 = **(long **)this; lVar9 != lVar2; lVar9 = lVar9 + 0x30) {
/* try { // try from 0018d345 to 0018d34c has its CatchHandler @ 0018d505 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(lVar9 + 0x20));
}
}
if (local_68 != pdStack_60) {
do {
pdVar10 = pdStack_60;
local_48 = *(int8 *)(pdStack_60 + -0x10);
pvStack_40 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pdStack_60 + -8);
assert_invariant((bool)((char)pdStack_60 + -0x10));
pdVar10[-0x10] = (data)0x0;
*(int8 *)(pdVar10 + -8) = 0;
bVar7 = SUB81((data *)&local_48,0);
assert_invariant(bVar7);
pdVar10 = pdStack_60 + -0x10;
pdStack_60 = pdVar10;
assert_invariant(SUB81(pdVar10,0));
data::~data(pdVar10);
if (local_48._0_1_ == (data)0x1) {
ppVar11 = *(pair **)pvStack_40;
ppVar3 = *(pair **)(pvStack_40 + 8);
if (ppVar11 != ppVar3) {
do {
/* try { // try from 0018d425 to 0018d42c has its CatchHandler @ 0018d50e */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(ppVar11 + 0x20));
ppVar11 = ppVar11 + 0x30;
} while (ppVar11 != ppVar3);
ppVar11 = *(pair **)pvStack_40;
}
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>>>>
::_M_erase_at_end((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>>>>
*)pvStack_40,ppVar11);
}
else if (local_48._0_1_ == (data)0x2) {
pbVar12 = *(basic_json **)pvStack_40;
lVar9 = *(long *)(pvStack_40 + 8) - (long)pbVar12 >> 4;
if (0 < lVar9) {
lVar9 = lVar9 + 1;
do {
/* try { // try from 0018d3e6 to 0018d3f0 has its CatchHandler @ 0018d50c */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar12);
pbVar12 = pbVar12 + 0x10;
lVar9 = lVar9 + -1;
} while (1 < lVar9);
pbVar12 = *(basic_json **)pvStack_40;
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::_M_erase_at_end(pvStack_40,pbVar12);
}
assert_invariant(bVar7);
data::~data((data *)&local_48);
} while (local_68 != pdStack_60);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68);
}
switch(param_2 & 0xff) {
case 1:
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>>>>
::~vector(*(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>>>>
**)this);
LAB_0018d4b1:
puVar8 = *(int8 **)this;
goto LAB_0018d4b4;
case 2:
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)this);
puVar8 = *(int8 **)this;
uVar6 = 0x18;
break;
case 3:
puVar8 = *(int8 **)this;
if ((long *)*puVar8 != puVar8 + 2) {
operator_delete((long *)*puVar8,puVar8[2] + 1);
goto LAB_0018d4b1;
}
LAB_0018d4b4:
uVar6 = 0x20;
break;
default:
goto switchD_0018d488_caseD_4;
case 8:
puVar8 = *(int8 **)this;
pvVar4 = (void *)*puVar8;
if (pvVar4 != (void *)0x0) {
operator_delete(pvVar4,puVar8[2] - (long)pvVar4);
puVar8 = *(int8 **)this;
}
uVar6 = 0x28;
}
operator_delete(puVar8,uVar6);
switchD_0018d488_caseD_4:
return;
}
|
|
66,494 |
wt_thd_release
|
eloqsql/mysys/waiting_threads.c
|
void wt_thd_release(WT_THD *thd, const WT_RESOURCE_ID *resid)
{
uint i;
DBUG_ENTER("wt_thd_release");
for (i= 0; i < thd->my_resources.elements; i++)
{
WT_RESOURCE *rc= *dynamic_element(&thd->my_resources, i, WT_RESOURCE**);
if (!resid || (resid->type->compare(&rc->id, resid) == 0))
{
uint j;
rc_wrlock(rc);
/*
nobody's trying to free the resource now,
as its owners[] array is not empty (at least thd must be there)
*/
DBUG_ASSERT(rc->state == ACTIVE);
for (j= 0; j < rc->owners.elements; j++)
if (*dynamic_element(&rc->owners, j, WT_THD**) == thd)
break;
DBUG_ASSERT(j < rc->owners.elements);
delete_dynamic_element(&rc->owners, j);
if (rc->owners.elements == 0)
{
mysql_cond_broadcast(&rc->cond);
#ifndef DBUG_OFF
if (rc->cond_mutex)
mysql_mutex_assert_owner(rc->cond_mutex);
#endif
}
unlock_lock_and_free_resource(thd, rc);
if (resid)
{
delete_dynamic_element(&thd->my_resources, i);
DBUG_VOID_RETURN;
}
}
}
if (!resid)
reset_dynamic(&thd->my_resources);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
wt_thd_release:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0xa71c5
xorl %r15d, %r15d
leaq 0x2deef6(%rip), %r13 # 0x386010
movq (%rbx), %rax
movq (%rax,%r15,8), %r12
testq %r14, %r14
je 0xa7136
movq 0x8(%r14), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *(%rax)
testb %al, %al
jne 0xa71a8
leaq 0x18(%r12), %rdi
callq 0xa43e5
leaq 0xe0(%r12), %rdi
movl 0xe8(%r12), %eax
testq %rax, %rax
je 0xa716c
movq (%rdi), %rcx
xorl %esi, %esi
cmpq %rbx, (%rcx,%rsi,8)
je 0xa716e
incq %rsi
cmpq %rsi, %rax
jne 0xa715a
movl %eax, %esi
jmp 0xa716e
xorl %esi, %esi
callq 0x91c45
cmpl $0x0, 0xe8(%r12)
jne 0xa7198
movq 0xd8(%r12), %rdi
testq %rdi, %rdi
jne 0xa71b9
leaq 0xa8(%r12), %rdi
callq 0x296d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa71f9
testq %r14, %r14
jne 0xa71e0
incq %r15
movl 0x8(%rbx), %eax
cmpq %rax, %r15
jb 0xa711a
jmp 0xa71c5
movq (%r13), %rax
callq *0x178(%rax)
jmp 0xa718b
testq %r14, %r14
jne 0xa71d1
movl $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x91c45
|
wt_thd_release:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
cmp dword ptr [rdi+8], 0
jz loc_A71C5
xor r15d, r15d
lea r13, PSI_server
loc_A711A:
mov rax, [rbx]
mov r12, [rax+r15*8]
test r14, r14
jz short loc_A7136
mov rax, [r14+8]
mov rdi, r12
mov rsi, r14
call qword ptr [rax]
test al, al
jnz short loc_A71A8
loc_A7136:
lea rdi, [r12+18h]
call my_rw_wrlock
lea rdi, [r12+0E0h]
mov eax, [r12+0E8h]
test rax, rax
jz short loc_A716C
mov rcx, [rdi]
xor esi, esi
loc_A715A:
cmp [rcx+rsi*8], rbx
jz short loc_A716E
inc rsi
cmp rax, rsi
jnz short loc_A715A
mov esi, eax
jmp short loc_A716E
loc_A716C:
xor esi, esi
loc_A716E:
call delete_dynamic_element
cmp dword ptr [r12+0E8h], 0
jnz short loc_A7198
mov rdi, [r12+0D8h]
test rdi, rdi
jnz short loc_A71B9
loc_A718B:
lea rdi, [r12+0A8h]
call _pthread_cond_broadcast
loc_A7198:
mov rdi, rbx
mov rsi, r12
call unlock_lock_and_free_resource
test r14, r14
jnz short loc_A71E0
loc_A71A8:
inc r15
mov eax, [rbx+8]
cmp r15, rax
jb loc_A711A
jmp short loc_A71C5
loc_A71B9:
mov rax, [r13+0]
call qword ptr [rax+178h]
jmp short loc_A718B
loc_A71C5:
test r14, r14
jnz short loc_A71D1
mov dword ptr [rbx+8], 0
loc_A71D1:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A71E0:
mov rdi, rbx
mov esi, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp delete_dynamic_element
|
unsigned long long wt_thd_release(long long a1, long long a2)
{
unsigned long long v4; // r15
long long v5; // r12
_QWORD *v6; // rdi
long long v7; // rsi
long long v8; // rdi
unsigned long long result; // rax
if ( *(_DWORD *)(a1 + 8) )
{
v4 = 0LL;
while ( 1 )
{
v5 = *(_QWORD *)(*(_QWORD *)a1 + 8 * v4);
if ( !a2
|| !(**(unsigned __int8 ( ***)(_QWORD, long long))(a2 + 8))(*(_QWORD *)(*(_QWORD *)a1 + 8 * v4), a2) )
{
my_rw_wrlock(v5 + 24);
v6 = (_QWORD *)(v5 + 224);
if ( *(_DWORD *)(v5 + 232) )
{
v7 = 0LL;
while ( *(_QWORD *)(*v6 + 8 * v7) != a1 )
{
if ( *(_DWORD *)(v5 + 232) == ++v7 )
{
LODWORD(v7) = *(_DWORD *)(v5 + 232);
break;
}
}
}
else
{
LODWORD(v7) = 0;
}
delete_dynamic_element((long long)v6, v7);
if ( !*(_DWORD *)(v5 + 232) )
{
v8 = *(_QWORD *)(v5 + 216);
if ( v8 )
((void ( *)(long long))PSI_server[47])(v8);
pthread_cond_broadcast(v5 + 168);
}
unlock_lock_and_free_resource(a1);
if ( a2 )
return delete_dynamic_element(a1, v4);
}
++v4;
result = *(unsigned int *)(a1 + 8);
if ( v4 >= result )
goto LABEL_17;
}
}
else
{
LABEL_17:
if ( !a2 )
*(_DWORD *)(a1 + 8) = 0;
}
return result;
}
|
wt_thd_release:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CMP dword ptr [RDI + 0x8],0x0
JZ 0x001a71c5
XOR R15D,R15D
LEA R13,[0x486010]
LAB_001a711a:
MOV RAX,qword ptr [RBX]
MOV R12,qword ptr [RAX + R15*0x8]
TEST R14,R14
JZ 0x001a7136
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,R12
MOV RSI,R14
CALL qword ptr [RAX]
TEST AL,AL
JNZ 0x001a71a8
LAB_001a7136:
LEA RDI,[R12 + 0x18]
CALL 0x001a43e5
LEA RDI,[R12 + 0xe0]
MOV EAX,dword ptr [R12 + 0xe8]
TEST RAX,RAX
JZ 0x001a716c
MOV RCX,qword ptr [RDI]
XOR ESI,ESI
LAB_001a715a:
CMP qword ptr [RCX + RSI*0x8],RBX
JZ 0x001a716e
INC RSI
CMP RAX,RSI
JNZ 0x001a715a
MOV ESI,EAX
JMP 0x001a716e
LAB_001a716c:
XOR ESI,ESI
LAB_001a716e:
CALL 0x00191c45
CMP dword ptr [R12 + 0xe8],0x0
JNZ 0x001a7198
MOV RDI,qword ptr [R12 + 0xd8]
TEST RDI,RDI
JNZ 0x001a71b9
LAB_001a718b:
LEA RDI,[R12 + 0xa8]
CALL 0x001296d0
LAB_001a7198:
MOV RDI,RBX
MOV RSI,R12
CALL 0x001a71f9
TEST R14,R14
JNZ 0x001a71e0
LAB_001a71a8:
INC R15
MOV EAX,dword ptr [RBX + 0x8]
CMP R15,RAX
JC 0x001a711a
JMP 0x001a71c5
LAB_001a71b9:
MOV RAX,qword ptr [R13]
CALL qword ptr [RAX + 0x178]
JMP 0x001a718b
LAB_001a71c5:
TEST R14,R14
JNZ 0x001a71d1
MOV dword ptr [RBX + 0x8],0x0
LAB_001a71d1:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a71e0:
MOV RDI,RBX
MOV ESI,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00191c45
|
void wt_thd_release(long *param_1,long param_2)
{
uint uVar1;
long lVar2;
char cVar3;
ulong uVar4;
ulong uVar5;
if ((int)param_1[1] != 0) {
uVar5 = 0;
do {
lVar2 = *(long *)(*param_1 + uVar5 * 8);
if ((param_2 == 0) ||
(cVar3 = (*(code *)**(int8 **)(param_2 + 8))(lVar2), cVar3 == '\0')) {
my_rw_wrlock(lVar2 + 0x18);
uVar1 = *(uint *)(lVar2 + 0xe8);
if ((ulong)uVar1 == 0) {
uVar4 = 0;
}
else {
uVar4 = 0;
do {
if (*(long **)(*(long *)(lVar2 + 0xe0) + uVar4 * 8) == param_1) goto LAB_001a716e;
uVar4 = uVar4 + 1;
} while (uVar1 != uVar4);
uVar4 = (ulong)uVar1;
}
LAB_001a716e:
delete_dynamic_element((long *)(lVar2 + 0xe0),uVar4);
if (*(int *)(lVar2 + 0xe8) == 0) {
if (*(long *)(lVar2 + 0xd8) != 0) {
(**(code **)(PSI_server + 0x178))();
}
pthread_cond_broadcast((pthread_cond_t *)(lVar2 + 0xa8));
}
unlock_lock_and_free_resource(param_1);
if (param_2 != 0) {
delete_dynamic_element(param_1,uVar5 & 0xffffffff);
return;
}
}
uVar5 = uVar5 + 1;
} while (uVar5 < *(uint *)(param_1 + 1));
}
if (param_2 == 0) {
*(int4 *)(param_1 + 1) = 0;
}
return;
}
|
|
66,495 |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::skip_bom()
|
monkey531[P]llama/common/json.hpp
|
bool skip_bom()
{
if (get() == 0xEF)
{
// check if we completely parse the BOM
return get() == 0xBB && get() == 0xBF;
}
// the first character is not the beginning of the BOM; unget it to
// process is later
unget();
return true;
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::skip_bom():
pushq %rbx
movq %rdi, %rbx
callq 0x3f6da
cmpl $0xef, %eax
jne 0x3ee1f
movq %rbx, %rdi
callq 0x3f6da
cmpl $0xbb, %eax
jne 0x3ee2b
movq %rbx, %rdi
callq 0x3f6da
cmpl $0xbf, %eax
sete %al
jmp 0x3ee2d
movq %rbx, %rdi
callq 0x3f750
movb $0x1, %al
jmp 0x3ee2d
xorl %eax, %eax
popq %rbx
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE8skip_bomEv:
push rbx
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 0EFh
jnz short loc_3EE1F
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 0BBh
jnz short loc_3EE2B
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 0BFh
setz al
jmp short loc_3EE2D
loc_3EE1F:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(void)
mov al, 1
jmp short loc_3EE2D
loc_3EE2B:
xor eax, eax
loc_3EE2D:
pop rbx
retn
|
bool nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::skip_bom(
long long a1)
{
if ( (unsigned int)((long long (*)(void))nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get)() == 239 )
return (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 187
&& (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 191;
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(a1);
return 1;
}
|
skip_bom:
PUSH RBX
MOV RBX,RDI
CALL 0x0013f6da
CMP EAX,0xef
JNZ 0x0013ee1f
MOV RDI,RBX
CALL 0x0013f6da
CMP EAX,0xbb
JNZ 0x0013ee2b
MOV RDI,RBX
CALL 0x0013f6da
CMP EAX,0xbf
SETZ AL
JMP 0x0013ee2d
LAB_0013ee1f:
MOV RDI,RBX
CALL 0x0013f750
MOV AL,0x1
JMP 0x0013ee2d
LAB_0013ee2b:
XOR EAX,EAX
LAB_0013ee2d:
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::skip_bom() */
bool __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::skip_bom(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int iVar1;
bool bVar2;
iVar1 = get(this);
if (iVar1 == 0xef) {
iVar1 = get(this);
if (iVar1 == 0xbb) {
iVar1 = get(this);
bVar2 = iVar1 == 0xbf;
}
else {
bVar2 = false;
}
}
else {
unget(this);
bVar2 = true;
}
return bVar2;
}
|
|
66,496 |
is_startline
|
eloqsql/build_O3/extra/pcre2/src/pcre2/src/pcre2_compile.c
|
static BOOL
is_startline(PCRE2_SPTR code, unsigned int bracket_map, compile_block *cb,
int atomcount, BOOL inassert)
{
do {
PCRE2_SPTR scode = first_significant_code(
code + PRIV(OP_lengths)[*code], FALSE);
int op = *scode;
/* If we are at the start of a conditional assertion group, *both* the
conditional assertion *and* what follows the condition must satisfy the test
for start of line. Other kinds of condition fail. Note that there may be an
auto-callout at the start of a condition. */
if (op == OP_COND)
{
scode += 1 + LINK_SIZE;
if (*scode == OP_CALLOUT) scode += PRIV(OP_lengths)[OP_CALLOUT];
else if (*scode == OP_CALLOUT_STR) scode += GET(scode, 1 + 2*LINK_SIZE);
switch (*scode)
{
case OP_CREF:
case OP_DNCREF:
case OP_RREF:
case OP_DNRREF:
case OP_FAIL:
case OP_FALSE:
case OP_TRUE:
return FALSE;
default: /* Assertion */
if (!is_startline(scode, bracket_map, cb, atomcount, TRUE)) return FALSE;
do scode += GET(scode, 1); while (*scode == OP_ALT);
scode += 1 + LINK_SIZE;
break;
}
scode = first_significant_code(scode, FALSE);
op = *scode;
}
/* Non-capturing brackets */
if (op == OP_BRA || op == OP_BRAPOS ||
op == OP_SBRA || op == OP_SBRAPOS)
{
if (!is_startline(scode, bracket_map, cb, atomcount, inassert))
return FALSE;
}
/* Capturing brackets */
else if (op == OP_CBRA || op == OP_CBRAPOS ||
op == OP_SCBRA || op == OP_SCBRAPOS)
{
int n = GET2(scode, 1+LINK_SIZE);
int new_map = bracket_map | ((n < 32)? (1u << n) : 1);
if (!is_startline(scode, new_map, cb, atomcount, inassert)) return FALSE;
}
/* Positive forward assertions */
else if (op == OP_ASSERT || op == OP_ASSERT_NA)
{
if (!is_startline(scode, bracket_map, cb, atomcount, TRUE))
return FALSE;
}
/* Atomic brackets */
else if (op == OP_ONCE)
{
if (!is_startline(scode, bracket_map, cb, atomcount + 1, inassert))
return FALSE;
}
/* .* means "start at start or after \n" if it isn't in atomic brackets or
brackets that may be referenced or an assertion, and as long as the pattern
does not contain *PRUNE or *SKIP, because these break the feature. Consider,
for example, /.*?a(*PRUNE)b/ with the subject "aab", which matches "ab",
i.e. not at the start of a line. There is also an option that disables this
optimization. */
else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)
{
if (scode[1] != OP_ANY || (bracket_map & cb->backref_map) != 0 ||
atomcount > 0 || cb->had_pruneorskip || inassert ||
(cb->external_options & PCRE2_NO_DOTSTAR_ANCHOR) != 0)
return FALSE;
}
/* Check for explicit circumflex; anything else gives a FALSE result. Note
in particular that this includes atomic brackets OP_ONCE because the number
of characters matched by .* cannot be adjusted inside them. */
else if (op != OP_CIRC && op != OP_CIRCM) return FALSE;
/* Move on to the next alternative */
code += GET(code, 1);
}
while (*code == OP_ALT); /* Loop for each alternative */
return TRUE;
}
|
O3
|
c
|
is_startline:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, -0x30(%rbp)
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, -0x2c(%rbp)
movq %rdi, %r13
leal 0x1(%r14), %eax
movl %eax, -0x34(%rbp)
movzbl (%rdi), %eax
leaq 0x6e1f5(%rip), %rcx # 0x118c50
movzbl (%rcx,%rax), %edi
addq %r13, %rdi
xorl %esi, %esi
callq 0xac336
movb (%rax), %cl
cmpb $-0x76, %cl
jne 0xaab0c
movq %rax, %r12
addq $0x3, %r12
movzbl 0x3(%rax), %ecx
cmpl $0x77, %ecx
je 0xaaa96
cmpl $0x76, %ecx
jne 0xaaaa8
leaq 0x6e1c0(%rip), %rax # 0x118c50
movzbl 0x76(%rax), %eax
jmp 0xaaaa1
movzwl 0x8(%rax), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movb (%r12,%rax), %cl
addq %rax, %r12
movzbl %cl, %eax
xorl %ebx, %ebx
addl $0xffffff70, %eax # imm = 0xFFFFFF70
cmpl $0x12, %eax
ja 0xaaac5
movl $0x4003f, %ecx # imm = 0x4003F
btl %eax, %ecx
jb 0xaac0c
movq %r12, %rdi
movl -0x2c(%rbp), %esi
movq %r15, %rdx
movl %r14d, %ecx
movl $0x1, %r8d
callq 0xaaa29
testl %eax, %eax
je 0xaac0c
movzwl 0x1(%r12), %eax
rolw $0x8, %ax
movzwl %ax, %eax
cmpb $0x78, (%r12,%rax)
leaq (%r12,%rax), %r12
je 0xaaae4
addq $0x3, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0xac336
movb (%rax), %cl
movzbl %cl, %edx
leal -0x7e(%rdx), %esi
cmpl $0x10, %esi
ja 0xaab8f
leaq 0x6c98e(%rip), %rdi # 0x1174ac
movslq (%rdi,%rsi,4), %rdx
addq %rdi, %rdx
jmpq *%rdx
movq %rax, %rdi
movl -0x2c(%rbp), %esi
jmp 0xaab54
movzbl 0x3(%rax), %edx
shll $0x8, %edx
movzbl 0x4(%rax), %ecx
orl %ecx, %edx
movl $0x1, %esi
shll %cl, %esi
cmpl $0x20, %edx
movl $0x1, %ecx
cmovael %ecx, %esi
orl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %r15, %rdx
movl %r14d, %ecx
movl -0x30(%rbp), %r8d
callq 0xaaa29
testl %eax, %eax
je 0xaac0a
movzwl 0x1(%r13), %eax
rolw $0x8, %ax
movzwl %ax, %eax
cmpb $0x78, (%r13,%rax)
leaq (%r13,%rax), %r13
movl $0x78, %eax
je 0xaaa54
jmp 0xaac03
leal -0x55(%rdx), %esi
cmpl $0x2, %esi
jb 0xaab9c
cmpl $0x5e, %edx
jne 0xaabe4
xorl %ebx, %ebx
cmpb $0xc, 0x1(%rax)
jne 0xaac0c
testl %r14d, %r14d
jg 0xaac0c
movl 0xfc(%r15), %eax
andl -0x2c(%rbp), %eax
jne 0xaac0c
movl 0x120(%r15), %eax
orl -0x30(%rbp), %eax
jne 0xaac0c
testb $-0x80, 0xcd(%r15)
je 0xaab6b
jmp 0xaac0c
movq %rax, %rdi
movl -0x2c(%rbp), %esi
movq %r15, %rdx
movl %r14d, %ecx
movl $0x1, %r8d
jmp 0xaab5e
addb $-0x1d, %cl
cmpb $-0x2, %cl
jae 0xaab6b
jmp 0xaac0a
movq %rax, %rdi
movl -0x2c(%rbp), %esi
movq %r15, %rdx
movl -0x34(%rbp), %ecx
jmp 0xaab5a
movl $0x1, %ebx
jmp 0xaac0c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
is_startline:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_30], r8d
mov r14d, ecx
mov r15, rdx
mov [rbp+var_2C], esi
mov r13, rdi
lea eax, [r14+1]
mov [rbp+var_34], eax
movzx eax, byte ptr [rdi]
loc_AAA54:
lea rcx, _pcre2_OP_lengths_8
movzx edi, byte ptr [rcx+rax]
add rdi, r13
xor esi, esi
call first_significant_code
mov cl, [rax]
cmp cl, 8Ah
jnz loc_AAB0C
mov r12, rax
add r12, 3
movzx ecx, byte ptr [rax+3]
cmp ecx, 77h ; 'w'
jz short loc_AAA96
cmp ecx, 76h ; 'v'
jnz short loc_AAAA8
lea rax, _pcre2_OP_lengths_8
movzx eax, byte ptr [rax+76h]
jmp short loc_AAAA1
loc_AAA96:
movzx eax, word ptr [rax+8]
rol ax, 8
movzx eax, ax
loc_AAAA1:
mov cl, [r12+rax]
add r12, rax
loc_AAAA8:
movzx eax, cl
xor ebx, ebx
add eax, 0FFFFFF70h
cmp eax, 12h
ja short loc_AAAC5
mov ecx, 4003Fh
bt ecx, eax
jb loc_AAC0C
loc_AAAC5:
mov rdi, r12
mov esi, [rbp+var_2C]
mov rdx, r15
mov ecx, r14d
mov r8d, 1
call is_startline
test eax, eax
jz loc_AAC0C
loc_AAAE4:
movzx eax, word ptr [r12+1]
rol ax, 8
movzx eax, ax
cmp byte ptr [r12+rax], 78h ; 'x'
lea r12, [r12+rax]
jz short loc_AAAE4
add r12, 3
mov rdi, r12
xor esi, esi
call first_significant_code
mov cl, [rax]
loc_AAB0C:
movzx edx, cl
lea esi, [rdx-7Eh]; switch 17 cases
cmp esi, 10h
ja short def_AAB25; jumptable 00000000000AAB25 default case
lea rdi, jpt_AAB25
movsxd rdx, ds:(jpt_AAB25 - 1174ACh)[rdi+rsi*4]
add rdx, rdi
jmp rdx; switch jump
loc_AAB27:
mov rdi, rax; jumptable 00000000000AAB25 cases 134,135,139,140
mov esi, [rbp+var_2C]
jmp short loc_AAB54
loc_AAB2F:
movzx edx, byte ptr [rax+3]; jumptable 00000000000AAB25 cases 136,137,141,142
shl edx, 8
movzx ecx, byte ptr [rax+4]
or edx, ecx
mov esi, 1
shl esi, cl
cmp edx, 20h ; ' '
mov ecx, 1
cmovnb esi, ecx
or esi, [rbp+var_2C]
mov rdi, rax
loc_AAB54:
mov rdx, r15
mov ecx, r14d
loc_AAB5A:
mov r8d, [rbp+var_30]
loc_AAB5E:
call is_startline
test eax, eax
jz loc_AAC0A
loc_AAB6B:
movzx eax, word ptr [r13+1]
rol ax, 8
movzx eax, ax
cmp byte ptr [r13+rax+0], 78h ; 'x'
lea r13, [r13+rax+0]
mov eax, 78h ; 'x'
jz loc_AAA54
jmp short loc_AAC03
def_AAB25:
lea esi, [rdx-55h]; jumptable 00000000000AAB25 default case
cmp esi, 2
jb short loc_AAB9C
cmp edx, 5Eh ; '^'
jnz short loc_AABE4; jumptable 00000000000AAB25 cases 127-129,131,133,138
loc_AAB9C:
xor ebx, ebx
cmp byte ptr [rax+1], 0Ch
jnz short loc_AAC0C
test r14d, r14d
jg short loc_AAC0C
mov eax, [r15+0FCh]
and eax, [rbp+var_2C]
jnz short loc_AAC0C
mov eax, [r15+120h]
or eax, [rbp+var_30]
jnz short loc_AAC0C
test byte ptr [r15+0CDh], 80h
jz short loc_AAB6B
jmp short loc_AAC0C
loc_AABCD:
mov rdi, rax; jumptable 00000000000AAB25 cases 126,130
mov esi, [rbp+var_2C]
mov rdx, r15
mov ecx, r14d
mov r8d, 1
jmp loc_AAB5E
loc_AABE4:
add cl, 0E3h; jumptable 00000000000AAB25 cases 127-129,131,133,138
cmp cl, 0FEh
jnb loc_AAB6B
jmp short loc_AAC0A
loc_AABF2:
mov rdi, rax; jumptable 00000000000AAB25 case 132
mov esi, [rbp+var_2C]
mov rdx, r15
mov ecx, [rbp+var_34]
jmp loc_AAB5A
loc_AAC03:
mov ebx, 1
jmp short loc_AAC0C
loc_AAC0A:
xor ebx, ebx
loc_AAC0C:
mov eax, ebx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long is_startline(unsigned __int8 *a1, unsigned int a2, long long a3, unsigned int a4, unsigned int a5)
{
unsigned __int8 *v7; // r13
long long v8; // rax
long long significant_code; // rax
unsigned __int8 v10; // cl
long long v11; // r12
int v12; // ecx
long long v13; // rax
unsigned int v14; // ebx
unsigned int v15; // eax
int v16; // ecx
unsigned __int16 v17; // ax
bool v18; // zf
long long v19; // rdi
long long v20; // rsi
int v21; // ecx
int v22; // esi
long long v23; // rdx
long long v24; // rcx
long long v25; // r8
unsigned __int16 v26; // ax
unsigned int v28; // [rsp+Ch] [rbp-34h]
v7 = a1;
v28 = a4 + 1;
v8 = *a1;
while ( 2 )
{
significant_code = first_significant_code(&v7[pcre2_OP_lengths_8[v8]], 0LL);
v10 = *(_BYTE *)significant_code;
if ( *(_BYTE *)significant_code != 0x8A )
goto LABEL_13;
v11 = significant_code + 3;
v12 = *(unsigned __int8 *)(significant_code + 3);
if ( v12 == 119 )
{
v13 = (unsigned __int16)__ROL2__(*(_WORD *)(significant_code + 8), 8);
goto LABEL_7;
}
if ( v12 == 118 )
{
v13 = pcre2_OP_lengths_8[118];
LABEL_7:
LOBYTE(v12) = *(_BYTE *)(v11 + v13);
v11 += v13;
}
v14 = 0;
v15 = (unsigned __int8)v12 - 144;
if ( v15 <= 0x12 )
{
v16 = 262207;
if ( _bittest(&v16, v15) )
return v14;
}
if ( !(unsigned int)is_startline(v11, a2, a3, a4, 1LL) )
return v14;
do
{
v17 = __ROL2__(*(_WORD *)(v11 + 1), 8);
v18 = *(_BYTE *)(v11 + v17) == 120;
v11 += v17;
}
while ( v18 );
significant_code = first_significant_code(v11 + 3, 0LL);
v10 = *(_BYTE *)significant_code;
LABEL_13:
switch ( v10 )
{
case 0x7Eu:
case 0x82u:
v19 = significant_code;
v20 = a2;
v23 = a3;
v24 = a4;
v25 = 1LL;
goto LABEL_20;
case 0x7Fu:
case 0x80u:
case 0x81u:
case 0x83u:
case 0x85u:
case 0x8Au:
goto LABEL_32;
case 0x84u:
v19 = significant_code;
v20 = a2;
v23 = a3;
v24 = v28;
goto LABEL_19;
case 0x86u:
case 0x87u:
case 0x8Bu:
case 0x8Cu:
v19 = significant_code;
v20 = a2;
goto LABEL_18;
case 0x88u:
case 0x89u:
case 0x8Du:
case 0x8Eu:
v21 = *(unsigned __int8 *)(significant_code + 4);
v22 = 1 << v21;
if ( (v21 | (*(unsigned __int8 *)(significant_code + 3) << 8)) >= 0x20u )
v22 = 1;
v20 = a2 | v22;
v19 = significant_code;
LABEL_18:
v23 = a3;
v24 = a4;
LABEL_19:
v25 = a5;
LABEL_20:
if ( (unsigned int)is_startline(v19, v20, v23, v24, v25) )
goto LABEL_21;
return 0;
default:
if ( (unsigned int)v10 - 85 < 2 || v10 == 94 )
{
v14 = 0;
if ( *(_BYTE *)(significant_code + 1) != 12
|| (int)a4 > 0
|| (a2 & *(_DWORD *)(a3 + 252)) != 0
|| a5 | *(_DWORD *)(a3 + 288)
|| *(char *)(a3 + 205) < 0 )
{
return v14;
}
}
else
{
LABEL_32:
if ( (unsigned __int8)(v10 - 29) < 0xFEu )
return 0;
}
LABEL_21:
v26 = __ROL2__(*(_WORD *)(v7 + 1), 8);
v18 = v7[v26] == 120;
v7 += v26;
v8 = 120LL;
if ( v18 )
continue;
return 1;
}
}
}
|
is_startline:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x30],R8D
MOV R14D,ECX
MOV R15,RDX
MOV dword ptr [RBP + -0x2c],ESI
MOV R13,RDI
LEA EAX,[R14 + 0x1]
MOV dword ptr [RBP + -0x34],EAX
MOVZX EAX,byte ptr [RDI]
LAB_001aaa54:
LEA RCX,[0x218c50]
MOVZX EDI,byte ptr [RCX + RAX*0x1]
ADD RDI,R13
XOR ESI,ESI
CALL 0x001ac336
MOV CL,byte ptr [RAX]
CMP CL,0x8a
JNZ 0x001aab0c
MOV R12,RAX
ADD R12,0x3
MOVZX ECX,byte ptr [RAX + 0x3]
CMP ECX,0x77
JZ 0x001aaa96
CMP ECX,0x76
JNZ 0x001aaaa8
LEA RAX,[0x218c50]
MOVZX EAX,byte ptr [RAX + 0x76]
JMP 0x001aaaa1
LAB_001aaa96:
MOVZX EAX,word ptr [RAX + 0x8]
ROL AX,0x8
MOVZX EAX,AX
LAB_001aaaa1:
MOV CL,byte ptr [R12 + RAX*0x1]
ADD R12,RAX
LAB_001aaaa8:
MOVZX EAX,CL
XOR EBX,EBX
ADD EAX,0xffffff70
CMP EAX,0x12
JA 0x001aaac5
MOV ECX,0x4003f
BT ECX,EAX
JC 0x001aac0c
LAB_001aaac5:
MOV RDI,R12
MOV ESI,dword ptr [RBP + -0x2c]
MOV RDX,R15
MOV ECX,R14D
MOV R8D,0x1
CALL 0x001aaa29
TEST EAX,EAX
JZ 0x001aac0c
LAB_001aaae4:
MOVZX EAX,word ptr [R12 + 0x1]
ROL AX,0x8
MOVZX EAX,AX
CMP byte ptr [R12 + RAX*0x1],0x78
LEA R12,[R12 + RAX*0x1]
JZ 0x001aaae4
ADD R12,0x3
MOV RDI,R12
XOR ESI,ESI
CALL 0x001ac336
MOV CL,byte ptr [RAX]
LAB_001aab0c:
MOVZX EDX,CL
LEA ESI,[RDX + -0x7e]
CMP ESI,0x10
JA 0x001aab8f
LEA RDI,[0x2174ac]
MOVSXD RDX,dword ptr [RDI + RSI*0x4]
ADD RDX,RDI
switchD:
JMP RDX
caseD_86:
MOV RDI,RAX
MOV ESI,dword ptr [RBP + -0x2c]
JMP 0x001aab54
caseD_88:
MOVZX EDX,byte ptr [RAX + 0x3]
SHL EDX,0x8
MOVZX ECX,byte ptr [RAX + 0x4]
OR EDX,ECX
MOV ESI,0x1
SHL ESI,CL
CMP EDX,0x20
MOV ECX,0x1
CMOVNC ESI,ECX
OR ESI,dword ptr [RBP + -0x2c]
MOV RDI,RAX
LAB_001aab54:
MOV RDX,R15
MOV ECX,R14D
LAB_001aab5a:
MOV R8D,dword ptr [RBP + -0x30]
LAB_001aab5e:
CALL 0x001aaa29
TEST EAX,EAX
JZ 0x001aac0a
LAB_001aab6b:
MOVZX EAX,word ptr [R13 + 0x1]
ROL AX,0x8
MOVZX EAX,AX
CMP byte ptr [R13 + RAX*0x1],0x78
LEA R13,[R13 + RAX*0x1]
MOV EAX,0x78
JZ 0x001aaa54
JMP 0x001aac03
default:
LEA ESI,[RDX + -0x55]
CMP ESI,0x2
JC 0x001aab9c
CMP EDX,0x5e
JNZ 0x001aabe4
LAB_001aab9c:
XOR EBX,EBX
CMP byte ptr [RAX + 0x1],0xc
JNZ 0x001aac0c
TEST R14D,R14D
JG 0x001aac0c
MOV EAX,dword ptr [R15 + 0xfc]
AND EAX,dword ptr [RBP + -0x2c]
JNZ 0x001aac0c
MOV EAX,dword ptr [R15 + 0x120]
OR EAX,dword ptr [RBP + -0x30]
JNZ 0x001aac0c
TEST byte ptr [R15 + 0xcd],0x80
JZ 0x001aab6b
JMP 0x001aac0c
caseD_7e:
MOV RDI,RAX
MOV ESI,dword ptr [RBP + -0x2c]
MOV RDX,R15
MOV ECX,R14D
MOV R8D,0x1
JMP 0x001aab5e
caseD_7f:
ADD CL,0xe3
CMP CL,0xfe
JNC 0x001aab6b
JMP 0x001aac0a
caseD_84:
MOV RDI,RAX
MOV ESI,dword ptr [RBP + -0x2c]
MOV RDX,R15
MOV ECX,dword ptr [RBP + -0x34]
JMP 0x001aab5a
LAB_001aac03:
MOV EBX,0x1
JMP 0x001aac0c
LAB_001aac0a:
XOR EBX,EBX
LAB_001aac0c:
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 is_startline(byte *param_1,uint param_2,long param_3,int param_4,int param_5)
{
ushort uVar1;
int iVar2;
byte *pbVar3;
ulong uVar4;
byte bVar5;
uint uVar6;
int iVar7;
byte *pbVar8;
uVar4 = (ulong)*param_1;
do {
pbVar3 = (byte *)first_significant_code(param_1 + (byte)_pcre2_OP_lengths_8[uVar4],0);
bVar5 = *pbVar3;
if (bVar5 == 0x8a) {
pbVar8 = pbVar3 + 3;
bVar5 = pbVar3[3];
if (bVar5 == 0x77) {
uVar4 = (ulong)(ushort)(*(ushort *)(pbVar3 + 8) << 8 | *(ushort *)(pbVar3 + 8) >> 8);
LAB_001aaaa1:
bVar5 = pbVar8[uVar4];
pbVar8 = pbVar8 + uVar4;
}
else if (bVar5 == 0x76) {
uVar4 = (ulong)_pcre2_OP_lengths_8[0x76];
goto LAB_001aaaa1;
}
if ((bVar5 - 0x90 < 0x13) && ((0x4003fU >> (bVar5 - 0x90 & 0x1f) & 1) != 0)) {
return 0;
}
iVar2 = is_startline(pbVar8,param_2,param_3,param_4,1);
if (iVar2 == 0) {
return 0;
}
do {
uVar1 = *(ushort *)(pbVar8 + 1) << 8 | *(ushort *)(pbVar8 + 1) >> 8;
pbVar3 = pbVar8 + uVar1;
pbVar8 = pbVar8 + uVar1;
} while (*pbVar3 == 0x78);
pbVar3 = (byte *)first_significant_code(pbVar8 + 3,0);
bVar5 = *pbVar3;
}
uVar6 = param_2;
iVar2 = param_4;
iVar7 = param_5;
switch(bVar5) {
case 0x7e:
case 0x82:
iVar7 = 1;
break;
case 0x7f:
case 0x80:
case 0x81:
case 0x83:
case 0x85:
case 0x8a:
switchD_001aab25_caseD_7f:
if ((byte)(bVar5 - 0x1d) < 0xfe) {
return 0;
}
goto LAB_001aab6b;
case 0x84:
iVar2 = param_4 + 1;
break;
case 0x86:
case 0x87:
case 0x8b:
case 0x8c:
break;
case 0x88:
case 0x89:
case 0x8d:
case 0x8e:
uVar6 = 1 << (pbVar3[4] & 0x1f);
if (0x1f < CONCAT11(pbVar3[3],pbVar3[4])) {
uVar6 = 1;
}
uVar6 = uVar6 | param_2;
break;
default:
if ((1 < bVar5 - 0x55) && (bVar5 != 0x5e)) goto switchD_001aab25_caseD_7f;
if (pbVar3[1] != 0xc) {
return 0;
}
if (0 < param_4) {
return 0;
}
if ((*(uint *)(param_3 + 0xfc) & param_2) != 0) {
return 0;
}
if (*(int *)(param_3 + 0x120) != 0 || param_5 != 0) {
return 0;
}
if ((*(byte *)(param_3 + 0xcd) & 0x80) != 0) {
return 0;
}
goto LAB_001aab6b;
}
iVar2 = is_startline(pbVar3,uVar6,param_3,iVar2,iVar7);
if (iVar2 == 0) {
return 0;
}
LAB_001aab6b:
uVar1 = *(ushort *)(param_1 + 1) << 8 | *(ushort *)(param_1 + 1) >> 8;
pbVar3 = param_1 + uVar1;
param_1 = param_1 + uVar1;
uVar4 = 0x78;
if (*pbVar3 != 0x78) {
return 1;
}
} while( true );
}
|
|
66,497 |
tprint
|
eloqsql/storage/maria/ma_recovery_util.c
|
void tprint(FILE *trace_file __attribute__ ((unused)),
const char *format __attribute__ ((unused)), ...)
{
va_list args;
#ifndef DBUG_OFF
{
char buff[1024];
size_t length;
va_start(args, format);
length= my_vsnprintf(buff, sizeof(buff)-1, format, args);
if (length && buff[length-1] == '\n')
buff[length-1]= 0; /* Don't print end \n */
DBUG_PRINT("info", ("%s", buff));
va_end(args);
}
#endif
va_start(args, format);
if (trace_file != NULL)
vfprintf(trace_file, format, args);
va_end(args);
}
|
O3
|
c
|
tprint:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, %r10
leaq -0xd0(%rbp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x501cf
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 %rsi, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, -0x20(%rbp)
testq %rdi, %rdi
je 0x501ff
leaq -0x20(%rbp), %rcx
movl $0x1, %esi
movq %r10, %rdx
callq 0x29750
addq $0xd0, %rsp
popq %rbp
retq
|
tprint:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov r10, rsi
lea rsi, [rbp+var_D0]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_501CF
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_501CF:
mov [rbp+var_10], rsi
lea rax, [rbp+arg_0]
mov [rbp+var_18], rax
mov rax, 3000000010h
mov [rbp+var_20], rax
test rdi, rdi
jz short loc_501FF
lea rcx, [rbp+var_20]
mov esi, 1
mov rdx, r10
call ___vfprintf_chk
loc_501FF:
add rsp, 0D0h
pop rbp
retn
|
long long tprint(
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)
{
long long result; // rax
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;
result = 0x3000000010LL;
v29[0] = 0x3000000010LL;
if ( a1 )
return __vfprintf_chk(a1, 1LL, a2, v29);
return result;
}
|
tprint:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV R10,RSI
LEA RSI,[RBP + -0xd0]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x001501cf
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_001501cf:
MOV qword ptr [RBP + -0x10],RSI
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,0x3000000010
MOV qword ptr [RBP + -0x20],RAX
TEST RDI,RDI
JZ 0x001501ff
LEA RCX,[RBP + -0x20]
MOV ESI,0x1
MOV RDX,R10
CALL 0x00129750
LAB_001501ff:
ADD RSP,0xd0
POP RBP
RET
|
void tprint(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,long param_9,
int8 param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
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 (param_9 != 0) {
local_c8 = param_11;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
__vfprintf_chk(param_9,1,param_10,&local_28);
}
return;
}
|
|
66,498 |
testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const*, char const*, int, char const*)
|
giladroyz[P]FindPeaks/build_O2/_deps/googletest-src/googletest/src/gtest-typed-test.cc
|
const char* TypedTestSuitePState::VerifyRegisteredTestNames(
const char* test_suite_name, const char* file, int line,
const char* registered_tests) {
RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line));
typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
registered_ = true;
std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
Message errors;
std::set<std::string> tests;
for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
name_it != name_vec.end(); ++name_it) {
const std::string& name = *name_it;
if (tests.count(name) != 0) {
errors << "Test " << name << " is listed more than once.\n";
continue;
}
if (registered_tests_.count(name) != 0) {
tests.insert(name);
} else {
errors << "No test named " << name
<< " can be found in this test suite.\n";
}
}
for (RegisteredTestIter it = registered_tests_.begin();
it != registered_tests_.end(); ++it) {
if (tests.count(it->first) == 0) {
errors << "You forgot to list test " << it->first << ".\n";
}
}
const std::string& errors_str = errors.GetString();
if (!errors_str.empty()) {
fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
errors_str.c_str());
fflush(stderr);
posix::Abort();
}
return registered_tests;
}
|
O2
|
cpp
|
testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const*, char const*, int, char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x28(%rsp), %rdi
leaq 0x80(%rsp), %rdx
movq %r12, %rsi
callq 0x81f0
leaq 0xc0(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x13119
movq %rdx, 0xb0(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0xc0(%rsp)
jmp 0x1311f
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x30(%rsp), %rcx
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
leaq 0xb0(%rsp), %rsi
movq %rcx, 0x8(%rsi)
movb $0x0, 0x38(%rsp)
movl %ebp, 0x20(%rsi)
movq %rbx, %rdi
callq 0x13479
movq %r12, 0x48(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x8ad8
leaq 0x28(%rsp), %rdi
callq 0x8ad8
movb $0x1, (%r15)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %r14, 0x58(%rsp)
leaq -0x1(%r14), %rbx
movsbl 0x1(%rbx), %edi
incq %rbx
callq 0x2826a
testb %al, %al
jne 0x13182
leaq 0x60(%rsp), %r14
leaq 0x80(%rsp), %r12
leaq 0x10(%rsp), %r13
testq %rbx, %rbx
je 0x131e7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x281f4
movq %r12, %rdi
movq %r14, %rsi
callq 0x281a2
movq %r13, %rdi
movq %r12, %rsi
callq 0x2b138
movq %r12, %rdi
callq 0x8ad8
movq %r14, %rdi
callq 0x8ad8
movq %rbx, %rdi
callq 0x28240
movq %rax, %rbx
jmp 0x131a4
movl %ebp, 0xc(%rsp)
movq %rsp, %rdi
callq 0x1575e
leaq 0x88(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0x10(%rsp), %r13
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x10(%rax), %rbp
leaq 0x8(%r15), %r14
leaq 0x80(%rsp), %rbx
leaq 0x203cc(%rip), %r12 # 0x33601
cmpq 0x18(%rsp), %r13
je 0x132b7
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2509a
testq %rax, %rax
je 0x13273
movq %rbp, %rdi
leaq 0x203a5(%rip), %rsi # 0x335fb
callq 0x84c0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x8450
movq %r12, %rsi
movq %rbp, %rdi
callq 0x84c0
jmp 0x1328e
movq %r14, %rdi
movq %r13, %rsi
callq 0x250b4
testq %rax, %rax
je 0x13294
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2b1da
addq $0x20, %r13
jmp 0x13235
movq %rbp, %rdi
leaq 0x2037f(%rip), %rsi # 0x3361d
callq 0x84c0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x8450
leaq 0x20377(%rip), %rsi # 0x3362c
jmp 0x13269
movq 0x20(%r15), %rbx
addq $0x10, %r15
leaq 0x80(%rsp), %r14
leaq 0x20fc6(%rip), %r13 # 0x34294
cmpq %r15, %rbx
je 0x13326
leaq 0x20(%rbx), %rbp
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2509a
testq %rax, %rax
jne 0x13319
movq (%rsp), %r12
addq $0x10, %r12
movq %r12, %rdi
leaq 0x20356(%rip), %rsi # 0x3364f
callq 0x84c0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x8450
movq (%rsp), %rdi
addq $0x10, %rdi
movq %r13, %rsi
callq 0x84c0
movq %rbx, %rdi
callq 0x85d0
movq %rax, %rbx
jmp 0x132ce
movq (%rsp), %r14
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x15922
cmpq $0x0, 0x68(%rsp)
movq 0x58(%rsp), %rbx
jne 0x13388
leaq 0x60(%rsp), %rdi
callq 0x8ad8
leaq 0x80(%rsp), %rdi
callq 0x2827c
testq %r14, %r14
je 0x13369
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x246f8
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3ac39(%rip), %r15 # 0x4dfc8
movq (%r15), %rbx
leaq 0xd8(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x11bec
leaq 0xd8(%rsp), %r14
movq (%r14), %rdx
movq 0x60(%rsp), %rcx
leaq 0x202a9(%rip), %rsi # 0x33668
movq %rbx, %rdi
xorl %eax, %eax
callq 0x87f0
movq %r14, %rdi
callq 0x8ad8
movq (%r15), %rdi
callq 0x8610
callq 0x24a45
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x8ad8
jmp 0x1344c
movq %rax, %rbx
jmp 0x1344c
jmp 0x13415
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x8ad8
leaq 0x28(%rsp), %rdi
callq 0x8ad8
jmp 0x13471
movq %rax, %rbx
jmp 0x13471
movq %rax, %rbx
jmp 0x13467
movq %rax, %rbx
jmp 0x1342f
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x8ad8
leaq 0x60(%rsp), %rdi
callq 0x8ad8
jmp 0x13467
movq %rax, %rbx
movq (%rsp), %r14
jmp 0x1344c
movq %rax, %rbx
movq 0x50(%rsp), %r14
leaq 0x80(%rsp), %rdi
callq 0x2827c
testq %r14, %r14
je 0x13467
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x246f8
movq %rbx, %rdi
callq 0x89a0
|
_ZN7testing8internal20TypedTestSuitePState25VerifyRegisteredTestNamesEPKcS3_iS3_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r14, r8
mov ebp, ecx
mov r12, rdx
mov rbx, rsi
mov r15, rdi
lea rdi, [rsp+128h+var_100]
lea rdx, [rsp+128h+var_A8]
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
lea rcx, [rsp+128h+var_68]
mov [rcx-10h], rcx
lea rax, [rsp+128h+var_F0]
mov rdx, [rax-10h]
cmp rdx, rax
jz short loc_13119
mov qword ptr [rsp+128h+var_78], rdx
mov rcx, [rsp+128h+var_F0]
mov [rsp+128h+var_68], rcx
jmp short loc_1311F
loc_13119:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [rcx], xmm0
loc_1311F:
mov rcx, [rsp+128h+var_F8]
mov [rsp+128h+var_100], rax
and [rsp+128h+var_F8], 0
lea rsi, [rsp+128h+var_78]; char
mov [rsi+8], rcx
mov byte ptr [rsp+128h+var_F0], 0
mov [rsi+20h], ebp
mov rdi, rbx
call _ZN7testing8internal34RegisterTypeParameterizedTestSuiteEPKcNS0_12CodeLocationE; testing::internal::RegisterTypeParameterizedTestSuite(char const*,testing::internal::CodeLocation)
mov [rsp+128h+var_E0], r12
lea rdi, [rsp+128h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+128h+var_100]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov byte ptr [r15], 1
xorps xmm0, xmm0
movaps [rsp+128h+var_118], xmm0
and [rsp+128h+var_108], 0
mov [rsp+128h+var_D0], r14
lea rbx, [r14-1]
loc_13182:
movsx edi, byte ptr [rbx+1]; this
inc rbx
call _ZN7testing8internal7IsSpaceEc; testing::internal::IsSpace(char)
test al, al
jnz short loc_13182
lea r14, [rsp+128h+var_C8]
lea r12, [rsp+128h+var_A8]
lea r13, [rsp+128h+var_118]
loc_131A4:
test rbx, rbx
jz short loc_131E7
mov rdi, r14
mov rsi, rbx
call _ZN7testing8internal19GetPrefixUntilCommaB5cxx11EPKc; testing::internal::GetPrefixUntilComma(char const*)
mov rdi, r12
mov rsi, r14
call _ZN7testing8internal19StripTrailingSpacesENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::StripTrailingSpaces(std::string)
mov rdi, r13
mov rsi, r12; char *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEEvDpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx; this
call _ZN7testing8internal9SkipCommaEPKc; testing::internal::SkipComma(char const*)
mov rbx, rax
jmp short loc_131A4
loc_131E7:
mov [rsp+128h+var_11C], ebp
mov rdi, rsp; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
lea rax, [rsp+128h+var_A0]
and dword ptr [rax], 0
and qword ptr [rax+8], 0
mov [rax+10h], rax
mov [rax+18h], rax
and qword ptr [rax+20h], 0
mov r13, qword ptr [rsp+128h+var_118]
mov rax, [rsp+128h+var_128]
mov [rsp+128h+var_D8], rax
lea rbp, [rax+10h]
lea r14, [r15+8]
lea rbx, [rsp+128h+var_A8]
lea r12, aIsListedMoreTh; " is listed more than once.\n"
loc_13235:
cmp r13, qword ptr [rsp+128h+var_118+8]
jz short loc_132B7
mov rdi, rbx
mov rsi, r13
call _ZNKSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EE5countERKS5_; std::set<std::string>::count(std::string const&)
test rax, rax
jz short loc_13273
mov rdi, rbp
lea rsi, aTest; "Test "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rbp
mov rsi, r13
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rsi, r12
loc_13269:
mov rdi, rbp
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short loc_1328E
loc_13273:
mov rdi, r14
mov rsi, r13
call _ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal12CodeLocationESt4lessIvESaISt4pairIKS5_S8_EEE5countERSC_; std::map<std::string,testing::internal::CodeLocation>::count(std::string const&)
test rax, rax
jz short loc_13294
mov rdi, rbx
mov rsi, r13
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St9_IdentityIS5_ESt4lessIS5_ESaIS5_EE16_M_insert_uniqueIRKS5_EESt4pairISt17_Rb_tree_iteratorIS5_EbEOT_; std::_Rb_tree<std::string,std::string,std::_Identity<std::string>,std::less<std::string>,std::allocator<std::string>>::_M_insert_unique<std::string const&>(std::string const&)
loc_1328E:
add r13, 20h ; ' '
jmp short loc_13235
loc_13294:
mov rdi, rbp
lea rsi, aNoTestNamed; "No test named "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rbp
mov rsi, r13
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
lea rsi, aCanBeFoundInTh; " can be found in this test suite.\n"
jmp short loc_13269
loc_132B7:
mov rbx, [r15+20h]
add r15, 10h
lea r14, [rsp+128h+var_A8]
lea r13, aNoteRandomizin+32h; ".\n"
loc_132CE:
cmp rbx, r15
jz short loc_13326
lea rbp, [rbx+20h]
mov rdi, r14
mov rsi, rbp
call _ZNKSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EE5countERKS5_; std::set<std::string>::count(std::string const&)
test rax, rax
jnz short loc_13319
mov r12, [rsp+128h+var_128]
add r12, 10h
mov rdi, r12
lea rsi, aYouForgotToLis; "You forgot to list test "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, r12
mov rsi, rbp
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rdi, [rsp+128h+var_128]
add rdi, 10h
mov rsi, r13
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
loc_13319:
mov rdi, rbx
call __ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base const*)
mov rbx, rax
jmp short loc_132CE
loc_13326:
mov r14, [rsp+128h+var_128]
lea rdi, [rsp+128h+var_C8]
mov rsi, r14
call _ZN7testing8internal20StringStreamToStringEPNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE; testing::internal::StringStreamToString(std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> *)
cmp [rsp+128h+var_C0], 0
mov rbx, [rsp+128h+var_D0]
jnz short loc_13388
lea rdi, [rsp+128h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+128h+var_A8]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St9_IdentityIS5_ESt4lessIS5_ESaIS5_EED2Ev; std::_Rb_tree<std::string,std::string,std::_Identity<std::string>,std::less<std::string>,std::allocator<std::string>>::~_Rb_tree()
test r14, r14
jz short loc_13369
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+8]
loc_13369:
lea rdi, [rsp+128h+var_118]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, rbx
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13388:
mov r15, cs:stderr_ptr
mov rbx, [r15]
lea rdi, [rsp+128h+var_50]
mov rsi, [rsp+128h+var_E0]
mov edx, [rsp+128h+var_11C]
call _ZN7testing8internal18FormatFileLocationB5cxx11EPKci; testing::internal::FormatFileLocation(char const*,int)
lea r14, [rsp+128h+var_50]
mov rdx, [r14]
mov rcx, [rsp+128h+var_C8]
lea rsi, aSS; "%s %s"
mov rdi, rbx
xor eax, eax
call _fprintf
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [r15]; this
call _fflush
call _ZN7testing8internal5posix5AbortEv; testing::internal::posix::Abort(void)
mov rbx, rax
lea rdi, [rsp+128h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_1344C
mov rbx, rax
jmp short loc_1344C
jmp short loc_13415
mov rbx, rax
lea rdi, [rsp+128h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+128h+var_100]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_13471
mov rbx, rax
jmp short loc_13471
loc_13415:
mov rbx, rax
jmp short loc_13467
mov rbx, rax
jmp short loc_1342F
mov rbx, rax
lea rdi, [rsp+128h+var_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_1342F:
lea rdi, [rsp+128h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_13467
mov rbx, rax
mov r14, [rsp+128h+var_128]
jmp short loc_1344C
mov rbx, rax
mov r14, [rsp+128h+var_D8]
loc_1344C:
lea rdi, [rsp+128h+var_A8]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St9_IdentityIS5_ESt4lessIS5_ESaIS5_EED2Ev; std::_Rb_tree<std::string,std::string,std::_Identity<std::string>,std::less<std::string>,std::allocator<std::string>>::~_Rb_tree()
test r14, r14
jz short loc_13467
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+8]
loc_13467:
lea rdi, [rsp+128h+var_118]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_13471:
mov rdi, rbx
call __Unwind_Resume
|
const char * testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(
testing::internal::TypedTestSuitePState *this,
const char *a2,
const char *a3,
int a4,
const char *a5)
{
long long v9; // rcx
testing::internal *v10; // rbx
testing::internal *v11; // rdi
long long v12; // r13
long long v13; // rbp
const char *v14; // rsi
long long v15; // rbx
char *v16; // r15
long long v17; // r12
long long v18; // r14
const char *v19; // rbx
long long v21; // rbx
testing::internal::posix *v22; // rdi
long long v23; // [rsp+0h] [rbp-128h] BYREF
int v24; // [rsp+Ch] [rbp-11Ch]
__int128 v25; // [rsp+10h] [rbp-118h] BYREF
long long v26; // [rsp+20h] [rbp-108h]
__int128 *v27; // [rsp+28h] [rbp-100h] BYREF
long long v28; // [rsp+30h] [rbp-F8h]
__int128 v29; // [rsp+38h] [rbp-F0h] BYREF
const char *v30; // [rsp+48h] [rbp-E0h]
long long v31; // [rsp+50h] [rbp-D8h]
const char *v32; // [rsp+58h] [rbp-D0h]
const char *v33[4]; // [rsp+60h] [rbp-C8h] BYREF
char v34[8]; // [rsp+80h] [rbp-A8h] BYREF
int v35; // [rsp+88h] [rbp-A0h] BYREF
long long v36; // [rsp+90h] [rbp-98h]
int *v37; // [rsp+98h] [rbp-90h]
int *v38; // [rsp+A0h] [rbp-88h]
long long v39; // [rsp+A8h] [rbp-80h]
char v40[8]; // [rsp+B0h] [rbp-78h] BYREF
long long v41; // [rsp+B8h] [rbp-70h]
__int128 v42; // [rsp+C0h] [rbp-68h] BYREF
int v43; // [rsp+D0h] [rbp-58h]
const char *v44[10]; // [rsp+D8h] [rbp-50h] BYREF
std::string::basic_string(&v27, a3, v34);
*(_QWORD *)v40 = &v42;
if ( v27 == &v29 )
{
v42 = v29;
}
else
{
*(_QWORD *)v40 = v27;
*(_QWORD *)&v42 = v29;
}
v9 = v28;
v27 = &v29;
v28 = 0LL;
v41 = v9;
LOBYTE(v29) = 0;
v43 = a4;
testing::internal::RegisterTypeParameterizedTestSuite(a2);
v30 = a3;
std::string::~string(v40);
std::string::~string(&v27);
*(_BYTE *)this = 1;
v25 = 0LL;
v26 = 0LL;
v32 = a5;
v10 = (testing::internal *)(a5 - 1);
do
{
v11 = (testing::internal *)(unsigned int)*((char *)v10 + 1);
v10 = (testing::internal *)((char *)v10 + 1);
}
while ( (unsigned __int8)testing::internal::IsSpace(v11, (char)v40) );
while ( v10 )
{
testing::internal::GetPrefixUntilComma[abi:cxx11](v33, v10);
testing::internal::StripTrailingSpaces(v34, v33);
std::vector<std::string>::emplace_back<std::string>(&v25, v34);
std::string::~string(v34);
std::string::~string(v33);
v10 = (testing::internal *)testing::internal::SkipComma(v10, v34);
}
v24 = a4;
testing::Message::Message((testing::Message *)&v23);
v35 = 0;
v36 = 0LL;
v37 = &v35;
v38 = &v35;
v39 = 0LL;
v12 = v25;
v31 = v23;
v13 = v23 + 16;
while ( v12 != *((_QWORD *)&v25 + 1) )
{
if ( std::set<std::string>::count(v34, v12) )
{
std::operator<<<std::char_traits<char>>(v13, "Test ");
std::operator<<<char>(v13, v12);
v14 = " is listed more than once.\n";
LABEL_12:
std::operator<<<std::char_traits<char>>(v13, v14);
goto LABEL_15;
}
if ( !std::map<std::string,testing::internal::CodeLocation>::count((char *)this + 8, v12) )
{
std::operator<<<std::char_traits<char>>(v13, "No test named ");
std::operator<<<char>(v13, v12);
v14 = " can be found in this test suite.\n";
goto LABEL_12;
}
std::_Rb_tree<std::string,std::string,std::_Identity<std::string>,std::less<std::string>,std::allocator<std::string>>::_M_insert_unique<std::string const&>(
v34,
v12);
LABEL_15:
v12 += 32LL;
}
v15 = *((_QWORD *)this + 4);
v16 = (char *)this + 16;
while ( (char *)v15 != v16 )
{
if ( !std::set<std::string>::count(v34, v15 + 32) )
{
v17 = v23 + 16;
std::operator<<<std::char_traits<char>>(v23 + 16, "You forgot to list test ");
std::operator<<<char>(v17, v15 + 32);
std::operator<<<std::char_traits<char>>(v23 + 16, ".\n");
}
v15 = std::_Rb_tree_increment(v15);
}
v18 = v23;
testing::internal::StringStreamToString(v33, v23);
v19 = v32;
if ( v33[1] )
{
v21 = stderr;
testing::internal::FormatFileLocation[abi:cxx11]((long long)v44, v30, v24);
fprintf(v21, "%s %s", v44[0], v33[0]);
std::string::~string(v44);
v22 = (testing::internal::posix *)stderr;
fflush(stderr);
testing::internal::posix::Abort(v22);
}
std::string::~string(v33);
std::_Rb_tree<std::string,std::string,std::_Identity<std::string>,std::less<std::string>,std::allocator<std::string>>::~_Rb_tree(v34);
if ( v18 )
(*(void ( **)(long long))(*(_QWORD *)v18 + 8LL))(v18);
std::vector<std::string>::~vector(&v25);
return v19;
}
|
VerifyRegisteredTestNames:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R14,R8
MOV EBP,ECX
MOV R12,RDX
MOV RBX,RSI
MOV R15,RDI
LAB_001130d3:
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x80]
MOV RSI,R12
CALL 0x001081f0
LEA RCX,[RSP + 0xc0]
MOV qword ptr [RCX + -0x10],RCX
LEA RAX,[RSP + 0x38]
MOV RDX,qword ptr [RAX + -0x10]
CMP RDX,RAX
JZ 0x00113119
MOV qword ptr [RSP + 0xb0],RDX
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xc0],RCX
JMP 0x0011311f
LAB_00113119:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RCX],XMM0
LAB_0011311f:
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x28],RAX
AND qword ptr [RSP + 0x30],0x0
LEA RSI,[RSP + 0xb0]
MOV qword ptr [RSI + 0x8],RCX
MOV byte ptr [RSP + 0x38],0x0
MOV dword ptr [RSI + 0x20],EBP
LAB_00113143:
MOV RDI,RBX
CALL 0x00113479
MOV qword ptr [RSP + 0x48],R12
LEA RDI,[RSP + 0xb0]
CALL 0x00108ad8
LEA RDI,[RSP + 0x28]
CALL 0x00108ad8
MOV byte ptr [R15],0x1
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
AND qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x58],R14
LEA RBX,[R14 + -0x1]
LAB_00113182:
MOVSX EDI,byte ptr [RBX + 0x1]
INC RBX
CALL 0x0012826a
TEST AL,AL
JNZ 0x00113182
LEA R14,[RSP + 0x60]
LEA R12,[RSP + 0x80]
LEA R13,[RSP + 0x10]
LAB_001131a4:
TEST RBX,RBX
JZ 0x001131e7
LAB_001131a9:
MOV RDI,R14
MOV RSI,RBX
CALL 0x001281f4
LAB_001131b4:
MOV RDI,R12
MOV RSI,R14
CALL 0x001281a2
LAB_001131bf:
MOV RDI,R13
MOV RSI,R12
CALL 0x0012b138
MOV RDI,R12
CALL 0x00108ad8
MOV RDI,R14
CALL 0x00108ad8
MOV RDI,RBX
CALL 0x00128240
MOV RBX,RAX
JMP 0x001131a4
LAB_001131e7:
MOV dword ptr [RSP + 0xc],EBP
MOV RDI,RSP
CALL 0x0011575e
LEA RAX,[RSP + 0x88]
AND dword ptr [RAX],0x0
AND qword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX + 0x10],RAX
MOV qword ptr [RAX + 0x18],RAX
AND qword ptr [RAX + 0x20],0x0
MOV R13,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x50],RAX
LEA RBP,[RAX + 0x10]
LEA R14,[R15 + 0x8]
LEA RBX,[RSP + 0x80]
LEA R12,[0x133601]
LAB_00113235:
CMP R13,qword ptr [RSP + 0x18]
JZ 0x001132b7
LAB_0011323c:
MOV RDI,RBX
MOV RSI,R13
CALL 0x0012509a
TEST RAX,RAX
JZ 0x00113273
MOV RDI,RBP
LEA RSI,[0x1335fb]
CALL 0x001084c0
MOV RDI,RBP
MOV RSI,R13
CALL 0x00108450
MOV RSI,R12
LAB_00113269:
MOV RDI,RBP
CALL 0x001084c0
JMP 0x0011328e
LAB_00113273:
MOV RDI,R14
MOV RSI,R13
CALL 0x001250b4
TEST RAX,RAX
JZ 0x00113294
MOV RDI,RBX
MOV RSI,R13
CALL 0x0012b1da
LAB_0011328e:
ADD R13,0x20
JMP 0x00113235
LAB_00113294:
MOV RDI,RBP
LEA RSI,[0x13361d]
CALL 0x001084c0
MOV RDI,RBP
MOV RSI,R13
CALL 0x00108450
LEA RSI,[0x13362c]
JMP 0x00113269
LAB_001132b7:
MOV RBX,qword ptr [R15 + 0x20]
ADD R15,0x10
LEA R14,[RSP + 0x80]
LEA R13,[0x134294]
LAB_001132ce:
CMP RBX,R15
JZ 0x00113326
LEA RBP,[RBX + 0x20]
LAB_001132d7:
MOV RDI,R14
MOV RSI,RBP
CALL 0x0012509a
TEST RAX,RAX
JNZ 0x00113319
MOV R12,qword ptr [RSP]
ADD R12,0x10
MOV RDI,R12
LEA RSI,[0x13364f]
CALL 0x001084c0
MOV RDI,R12
MOV RSI,RBP
CALL 0x00108450
MOV RDI,qword ptr [RSP]
ADD RDI,0x10
MOV RSI,R13
CALL 0x001084c0
LAB_00113319:
MOV RDI,RBX
CALL 0x001085d0
MOV RBX,RAX
JMP 0x001132ce
LAB_00113326:
MOV R14,qword ptr [RSP]
LAB_0011332a:
LEA RDI,[RSP + 0x60]
MOV RSI,R14
CALL 0x00115922
LAB_00113337:
CMP qword ptr [RSP + 0x68],0x0
MOV RBX,qword ptr [RSP + 0x58]
JNZ 0x00113388
LEA RDI,[RSP + 0x60]
CALL 0x00108ad8
LEA RDI,[RSP + 0x80]
CALL 0x0012827c
TEST R14,R14
JZ 0x00113369
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x8]
LAB_00113369:
LEA RDI,[RSP + 0x10]
CALL 0x001246f8
MOV RAX,RBX
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00113388:
MOV R15,qword ptr [0x0014dfc8]
MOV RBX,qword ptr [R15]
LAB_00113392:
LEA RDI,[RSP + 0xd8]
MOV RSI,qword ptr [RSP + 0x48]
MOV EDX,dword ptr [RSP + 0xc]
CALL 0x00111bec
LAB_001133a8:
LEA R14,[RSP + 0xd8]
MOV RDX,qword ptr [R14]
MOV RCX,qword ptr [RSP + 0x60]
LEA RSI,[0x133668]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001087f0
MOV RDI,R14
CALL 0x00108ad8
MOV RDI,qword ptr [R15]
CALL 0x00108610
CALL 0x00124a45
|
/* testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const*, char const*, int,
char const*) */
char * __thiscall
testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames
(TypedTestSuitePState *this,char *param_1,char *param_2,int param_3,char *param_4)
{
char *pcVar1;
FILE *__stream;
int *puVar2;
char cVar3;
long lVar4;
_Rb_tree_node_base *p_Var5;
char *pcVar6;
ostream *poVar7;
string *psVar8;
long *local_128;
int local_11c;
string *local_118;
string *psStack_110;
int8 local_108;
uint *local_100;
int8 local_f8;
uint local_f0 [2];
int4 uStack_e8;
int4 uStack_e4;
char *local_e0;
long *local_d8;
char *local_d0;
int8 local_c8;
long local_c0;
allocator local_a8 [8];
int4 local_a0 [2];
int8 local_98;
int4 *local_90;
int4 *local_88;
int8 local_80;
uint *local_78;
int8 local_70;
uint local_68 [2];
int4 uStack_60;
int4 uStack_5c;
int local_58;
int8 local_50 [4];
/* try { // try from 001130d3 to 001130e7 has its CatchHandler @ 00113410 */
std::__cxx11::string::string((string *)&local_100,param_2,local_a8);
local_70 = local_f8;
local_78 = local_68;
if (local_100 == local_f0) {
uStack_60 = uStack_e8;
uStack_5c = uStack_e4;
}
else {
local_78 = local_100;
}
local_f8 = 0;
local_f0[0] = local_f0[0] & 0xffffff00;
local_100 = local_f0;
local_58 = param_3;
/* try { // try from 00113143 to 0011314a has its CatchHandler @ 001133f4 */
RegisterTypeParameterizedTestSuite(param_1);
local_e0 = param_2;
std::__cxx11::string::~string((string *)&local_78);
std::__cxx11::string::~string((string *)&local_100);
*this = (TypedTestSuitePState)0x1;
local_118 = (string *)0x0;
psStack_110 = (string *)0x0;
local_108 = 0;
pcVar6 = param_4 + -1;
local_d0 = param_4;
do {
pcVar1 = pcVar6 + 1;
pcVar6 = pcVar6 + 1;
cVar3 = IsSpace(*pcVar1);
} while (cVar3 != '\0');
for (; pcVar6 != (char *)0x0; pcVar6 = (char *)SkipComma(pcVar6)) {
/* try { // try from 001131a9 to 001131b3 has its CatchHandler @ 00113415 */
GetPrefixUntilComma_abi_cxx11_((internal *)&local_c8,pcVar6);
/* try { // try from 001131b4 to 001131be has its CatchHandler @ 0011341a */
StripTrailingSpaces((internal *)local_a8,(internal *)&local_c8);
/* try { // try from 001131bf to 001131c9 has its CatchHandler @ 0011341f */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_118,
(string *)local_a8);
std::__cxx11::string::~string((string *)local_a8);
std::__cxx11::string::~string((string *)&local_c8);
}
local_11c = param_3;
/* try { // try from 001131e7 to 001131f2 has its CatchHandler @ 001133f2 */
Message::Message((Message *)&local_128);
local_90 = local_a0;
local_a0[0] = 0;
local_98 = 0;
local_80 = 0;
local_d8 = local_128;
poVar7 = (ostream *)(local_128 + 2);
psVar8 = local_118;
local_88 = local_90;
do {
if (psVar8 == psStack_110) {
for (p_Var5 = *(_Rb_tree_node_base **)(this + 0x20);
p_Var5 != (_Rb_tree_node_base *)(this + 0x10);
p_Var5 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var5)) {
/* try { // try from 001132d7 to 00113318 has its CatchHandler @ 0011343b */
lVar4 = std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::count((set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
*)local_a8,(string *)(p_Var5 + 0x20));
if (lVar4 == 0) {
poVar7 = (ostream *)(local_128 + 2);
std::operator<<(poVar7,"You forgot to list test ");
std::operator<<(poVar7,(string *)(p_Var5 + 0x20));
std::operator<<((ostream *)(local_128 + 2),".\n");
}
}
/* try { // try from 0011332a to 00113336 has its CatchHandler @ 001133ed */
StringStreamToString((stringstream *)&local_c8);
pcVar6 = local_d0;
puVar2 = PTR_stderr_0014dfc8;
if (local_c0 == 0) {
std::__cxx11::string::~string((string *)&local_c8);
std::
_Rb_tree<std::__cxx11::string,std::__cxx11::string,std::_Identity<std::__cxx11::string>,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::~_Rb_tree((_Rb_tree<std::__cxx11::string,std::__cxx11::string,std::_Identity<std::__cxx11::string>,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
*)local_a8);
if (local_128 != (long *)0x0) {
(**(code **)(*local_128 + 8))(local_128);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_118);
return pcVar6;
}
__stream = *(FILE **)PTR_stderr_0014dfc8;
/* try { // try from 00113392 to 001133a7 has its CatchHandler @ 001133de */
FormatFileLocation_abi_cxx11_((internal *)local_50,local_e0,local_11c);
fprintf(__stream,"%s %s",local_50[0],local_c8);
std::__cxx11::string::~string((string *)local_50);
fflush(*(FILE **)puVar2);
/* WARNING: Subroutine does not return */
posix::Abort();
}
/* try { // try from 0011323c to 001132ad has its CatchHandler @ 00113444 */
lVar4 = std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::count((set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
*)local_a8,psVar8);
if (lVar4 == 0) {
lVar4 = std::
map<std::__cxx11::string,testing::internal::CodeLocation,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>>
::count((map<std::__cxx11::string,testing::internal::CodeLocation,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>>
*)(this + 8),psVar8);
if (lVar4 == 0) {
std::operator<<(poVar7,"No test named ");
std::operator<<(poVar7,psVar8);
pcVar6 = " can be found in this test suite.\n";
goto LAB_00113269;
}
std::
_Rb_tree<std::__cxx11::string,std::__cxx11::string,std::_Identity<std::__cxx11::string>,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::_M_insert_unique<std::__cxx11::string_const&>
((_Rb_tree<std::__cxx11::string,std::__cxx11::string,std::_Identity<std::__cxx11::string>,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
*)local_a8,psVar8);
}
else {
std::operator<<(poVar7,"Test ");
std::operator<<(poVar7,psVar8);
pcVar6 = " is listed more than once.\n";
LAB_00113269:
std::operator<<(poVar7,pcVar6);
}
psVar8 = psVar8 + 0x20;
} while( true );
}
|
|
66,499 |
alloc_root
|
eloqsql/mysys/my_alloc.c
|
void *alloc_root(MEM_ROOT *mem_root, size_t length)
{
#if defined(HAVE_valgrind) && defined(EXTRA_DEBUG)
reg1 USED_MEM *next;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_SET("-d,simulate_out_of_memory");
DBUG_RETURN((void*) 0); /* purecov: inspected */
});
length+=ALIGN_SIZE(sizeof(USED_MEM));
if (!(next = (USED_MEM*) my_malloc(mem_root->m_psi_key, length,
MYF(MY_WME | ME_FATAL |
MALLOC_FLAG(mem_root->block_size)))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((uchar*) 0); /* purecov: inspected */
}
next->next= mem_root->used;
next->left= 0;
next->size= length;
mem_root->used= next;
DBUG_PRINT("exit",("ptr: %p", (((char*)next)+ALIGN_SIZE(sizeof(USED_MEM)))));
DBUG_RETURN((((uchar*) next)+ALIGN_SIZE(sizeof(USED_MEM))));
#else
size_t get_size, block_size;
uchar* point;
reg1 USED_MEM *next= 0;
reg2 USED_MEM **prev;
size_t original_length __attribute__((unused)) = length;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
/* Avoid reusing an already allocated block */
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_SET("-d,simulate_out_of_memory");
DBUG_RETURN((void*) 0); /* purecov: inspected */
});
length= ALIGN_SIZE(length) + REDZONE_SIZE;
if ((*(prev= &mem_root->free)) != NULL)
{
if ((*prev)->left < length &&
mem_root->first_block_usage++ >= ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP &&
(*prev)->left < ALLOC_MAX_BLOCK_TO_DROP)
{
next= *prev;
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
for (next= *prev ; next && next->left < length ; next= next->next)
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
block_size= (mem_root->block_size & ~1) * (mem_root->block_num >> 2);
get_size= length+ALIGN_SIZE(sizeof(USED_MEM));
get_size= MY_MAX(get_size, block_size);
if (!(next = (USED_MEM*) my_malloc(mem_root->m_psi_key, get_size,
MYF(MY_WME | ME_FATAL |
MALLOC_FLAG(mem_root->
block_size)))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((void*) 0); /* purecov: inspected */
}
mem_root->block_num++;
next->next= *prev;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next;
TRASH_MEM(next);
}
point= (uchar*) ((char*) next+ (next->size-next->left));
/*TODO: next part may be unneded due to mem_root->first_block_usage counter*/
if ((next->left-= length) < mem_root->min_malloc)
{ /* Full block */
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
point+= REDZONE_SIZE;
TRASH_ALLOC(point, original_length);
DBUG_PRINT("exit",("ptr: %p", point));
DBUG_RETURN((void*) point);
#endif
}
|
O3
|
c
|
alloc_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x7, %r14
andq $-0x8, %r14
movq (%rdi), %rax
movq %rdi, %r12
testq %rax, %rax
je 0x2d93a
cmpq %r14, 0x8(%rax)
jae 0x2d921
movl 0x2c(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x2c(%rbx)
cmpl $0xa, %ecx
jb 0x2d921
cmpq $0xfff, 0x8(%rax) # imm = 0xFFF
ja 0x2d921
movq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rbx)
movl $0x0, 0x2c(%rbx)
movq %rbx, %rax
movq %rax, %r12
movq (%rax), %rax
testq %rax, %rax
je 0x2d93a
movq 0x8(%rax), %rdx
cmpq %r14, %rdx
jb 0x2d924
jmp 0x2d997
movq 0x20(%rbx), %rdx
movq %rdx, %rax
andq $-0x2, %rax
movl 0x28(%rbx), %r15d
shrl $0x2, %r15d
imulq %rax, %r15
leaq 0x18(%r14), %rax
cmpq %r15, %rax
cmovaq %rax, %r15
movl 0x38(%rbx), %edi
andl $0x1, %edx
shll $0x10, %edx
orq $0x1010, %rdx # imm = 0x1010
movq %r15, %rsi
callq 0x2b249
testq %rax, %rax
je 0x2d9c9
incl 0x28(%rbx)
movq (%r12), %rcx
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
addq $-0x18, %r15
movq %r15, 0x8(%rax)
movq %rax, (%r12)
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
subq %rdx, %rcx
addq %rax, %rcx
subq %r14, %rdx
movq %rdx, 0x8(%rax)
cmpq 0x18(%rbx), %rdx
jae 0x2d9d6
movq (%rax), %rdx
movq %rdx, (%r12)
movq 0x8(%rbx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rbx)
movl $0x0, 0x2c(%rbx)
jmp 0x2d9d6
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x2d9d4
callq *%rax
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
alloc_root:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rsi
mov rbx, rdi
add r14, 7
and r14, 0FFFFFFFFFFFFFFF8h
mov rax, [rdi]
mov r12, rdi
test rax, rax
jz short loc_2D93A
cmp [rax+8], r14
jnb short loc_2D921
mov ecx, [rbx+2Ch]
lea edx, [rcx+1]
mov [rbx+2Ch], edx
cmp ecx, 0Ah
jb short loc_2D921
cmp qword ptr [rax+8], 0FFFh
ja short loc_2D921
mov rcx, [rax]
mov [rbx], rcx
mov rcx, [rbx+8]
mov [rax], rcx
mov [rbx+8], rax
mov dword ptr [rbx+2Ch], 0
loc_2D921:
mov rax, rbx
loc_2D924:
mov r12, rax
mov rax, [rax]
test rax, rax
jz short loc_2D93A
mov rdx, [rax+8]
cmp rdx, r14
jb short loc_2D924
jmp short loc_2D997
loc_2D93A:
mov rdx, [rbx+20h]
mov rax, rdx
and rax, 0FFFFFFFFFFFFFFFEh
mov r15d, [rbx+28h]
shr r15d, 2
imul r15, rax
lea rax, [r14+18h]
cmp rax, r15
cmova r15, rax
mov edi, [rbx+38h]
and edx, 1
shl edx, 10h
or rdx, 1010h
mov rsi, r15
call my_malloc
test rax, rax
jz short loc_2D9C9
inc dword ptr [rbx+28h]
mov rcx, [r12]
mov [rax], rcx
mov [rax+10h], r15
add r15, 0FFFFFFFFFFFFFFE8h
mov [rax+8], r15
mov [r12], rax
mov rdx, [rax+8]
loc_2D997:
mov rcx, [rax+10h]
sub rcx, rdx
add rcx, rax
sub rdx, r14
mov [rax+8], rdx
cmp rdx, [rbx+18h]
jnb short loc_2D9D6
mov rdx, [rax]
mov [r12], rdx
mov rdx, [rbx+8]
mov [rax], rdx
mov [rbx+8], rax
mov dword ptr [rbx+2Ch], 0
jmp short loc_2D9D6
loc_2D9C9:
mov rax, [rbx+30h]
test rax, rax
jz short loc_2D9D4
call rax
loc_2D9D4:
xor ecx, ecx
loc_2D9D6:
mov rax, rcx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
char * alloc_root(long long a1, long long a2)
{
unsigned long long v2; // r14
_QWORD *v3; // rax
_QWORD *v4; // r12
unsigned int v5; // ecx
_QWORD *v6; // rax
unsigned long long v7; // rdx
long long v8; // rdx
unsigned long long v9; // r15
char *v10; // rcx
unsigned long long v11; // rdx
void (*v12)(void); // rax
v2 = (a2 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v3 = *(_QWORD **)a1;
v4 = (_QWORD *)a1;
if ( *(_QWORD *)a1 )
{
if ( v3[1] < v2 )
{
v5 = *(_DWORD *)(a1 + 44);
*(_DWORD *)(a1 + 44) = v5 + 1;
if ( v5 >= 0xA && v3[1] <= 0xFFFuLL )
{
*(_QWORD *)a1 = *v3;
*v3 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = v3;
*(_DWORD *)(a1 + 44) = 0;
}
}
v6 = (_QWORD *)a1;
while ( 1 )
{
v4 = v6;
v6 = (_QWORD *)*v6;
if ( !v6 )
break;
v7 = v6[1];
if ( v7 >= v2 )
goto LABEL_14;
}
}
v8 = *(_QWORD *)(a1 + 32);
v9 = (v8 & 0xFFFFFFFFFFFFFFFELL) * (*(_DWORD *)(a1 + 40) >> 2);
if ( v2 + 24 > v9 )
v9 = v2 + 24;
v6 = (_QWORD *)my_malloc(*(_DWORD *)(a1 + 56), v9, ((v8 & 1) << 16) | 0x1010);
if ( v6 )
{
++*(_DWORD *)(a1 + 40);
*v6 = *v4;
v6[2] = v9;
v6[1] = v9 - 24;
*v4 = v6;
v7 = v6[1];
LABEL_14:
v10 = (char *)v6 + v6[2] - v7;
v11 = v7 - v2;
v6[1] = v11;
if ( v11 < *(_QWORD *)(a1 + 24) )
{
*v4 = *v6;
*v6 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = v6;
*(_DWORD *)(a1 + 44) = 0;
}
}
else
{
v12 = *(void (**)(void))(a1 + 48);
if ( v12 )
v12();
return 0LL;
}
return v10;
}
|
alloc_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
ADD R14,0x7
AND R14,-0x8
MOV RAX,qword ptr [RDI]
MOV R12,RDI
TEST RAX,RAX
JZ 0x0012d93a
CMP qword ptr [RAX + 0x8],R14
JNC 0x0012d921
MOV ECX,dword ptr [RBX + 0x2c]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX + 0x2c],EDX
CMP ECX,0xa
JC 0x0012d921
CMP qword ptr [RAX + 0x8],0xfff
JA 0x0012d921
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBX],RCX
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x2c],0x0
LAB_0012d921:
MOV RAX,RBX
LAB_0012d924:
MOV R12,RAX
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0012d93a
MOV RDX,qword ptr [RAX + 0x8]
CMP RDX,R14
JC 0x0012d924
JMP 0x0012d997
LAB_0012d93a:
MOV RDX,qword ptr [RBX + 0x20]
MOV RAX,RDX
AND RAX,-0x2
MOV R15D,dword ptr [RBX + 0x28]
SHR R15D,0x2
IMUL R15,RAX
LEA RAX,[R14 + 0x18]
CMP RAX,R15
CMOVA R15,RAX
MOV EDI,dword ptr [RBX + 0x38]
AND EDX,0x1
SHL EDX,0x10
OR RDX,0x1010
MOV RSI,R15
CALL 0x0012b249
TEST RAX,RAX
JZ 0x0012d9c9
INC dword ptr [RBX + 0x28]
MOV RCX,qword ptr [R12]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x10],R15
ADD R15,-0x18
MOV qword ptr [RAX + 0x8],R15
MOV qword ptr [R12],RAX
MOV RDX,qword ptr [RAX + 0x8]
LAB_0012d997:
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,RDX
ADD RCX,RAX
SUB RDX,R14
MOV qword ptr [RAX + 0x8],RDX
CMP RDX,qword ptr [RBX + 0x18]
JNC 0x0012d9d6
MOV RDX,qword ptr [RAX]
MOV qword ptr [R12],RDX
MOV RDX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX],RDX
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x2c],0x0
JMP 0x0012d9d6
LAB_0012d9c9:
MOV RAX,qword ptr [RBX + 0x30]
TEST RAX,RAX
JZ 0x0012d9d4
CALL RAX
LAB_0012d9d4:
XOR ECX,ECX
LAB_0012d9d6:
MOV RAX,RCX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long alloc_root(long *param_1,long param_2)
{
uint uVar1;
long *plVar2;
long lVar3;
long *plVar4;
long *plVar5;
ulong uVar6;
ulong uVar7;
uVar6 = param_2 + 7U & 0xfffffffffffffff8;
plVar2 = (long *)*param_1;
plVar5 = param_1;
if (plVar2 == (long *)0x0) {
LAB_0012d93a:
uVar7 = (ulong)(*(uint *)(param_1 + 5) >> 2) * (param_1[4] & 0xfffffffffffffffeU);
if (uVar7 < uVar6 + 0x18) {
uVar7 = uVar6 + 0x18;
}
plVar4 = (long *)my_malloc((int)param_1[7],uVar7,((uint)param_1[4] & 1) << 0x10 | 0x1010);
if (plVar4 == (long *)0x0) {
if ((code *)param_1[6] != (code *)0x0) {
(*(code *)param_1[6])();
}
return 0;
}
*(int *)(param_1 + 5) = (int)param_1[5] + 1;
*plVar4 = *plVar5;
plVar4[2] = uVar7;
plVar4[1] = uVar7 - 0x18;
*plVar5 = (long)plVar4;
uVar7 = plVar4[1];
}
else {
plVar4 = param_1;
if ((((ulong)plVar2[1] < uVar6) &&
(uVar1 = *(uint *)((long)param_1 + 0x2c), *(uint *)((long)param_1 + 0x2c) = uVar1 + 1,
9 < uVar1)) && ((ulong)plVar2[1] < 0x1000)) {
*param_1 = *plVar2;
*plVar2 = param_1[1];
param_1[1] = (long)plVar2;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
do {
plVar5 = plVar4;
plVar4 = (long *)*plVar5;
if (plVar4 == (long *)0x0) goto LAB_0012d93a;
uVar7 = plVar4[1];
} while (uVar7 < uVar6);
}
lVar3 = plVar4[2];
plVar4[1] = uVar7 - uVar6;
if (uVar7 - uVar6 < (ulong)param_1[3]) {
*plVar5 = *plVar4;
*plVar4 = param_1[1];
param_1[1] = (long)plVar4;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
return (lVar3 - uVar7) + (long)plVar4;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.