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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
64,700 |
void nlohmann::json_abi_v3_11_3::detail::serializer<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>>::dump_integer<unsigned char, 0>(unsigned char)
|
monkey531[P]llama/common/json.hpp
|
void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
{{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
{{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
{{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
{{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
{{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
{{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
{{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
{{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
}
};
// special case for "0"
if (x == 0)
{
o->write_character('0');
return;
}
// use a pointer to fill the buffer
auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
number_unsigned_t abs_value;
unsigned int n_chars{};
if (is_negative_number(x))
{
*buffer_ptr = '-';
abs_value = remove_sign(static_cast<number_integer_t>(x));
// account one more byte for the minus sign
n_chars = 1 + count_digits(abs_value);
}
else
{
abs_value = static_cast<number_unsigned_t>(x);
n_chars = count_digits(abs_value);
}
// spare 1 byte for '\0'
JSON_ASSERT(n_chars < number_buffer.size() - 1);
// jump to the end to generate the string from backward,
// so we later avoid reversing the result
buffer_ptr += n_chars;
// Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
// See: https://www.youtube.com/watch?v=o4-CwDo2zpg
while (abs_value >= 100)
{
const auto digits_index = static_cast<unsigned>((abs_value % 100));
abs_value /= 100;
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
if (abs_value >= 10)
{
const auto digits_index = static_cast<unsigned>(abs_value);
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
else
{
*(--buffer_ptr) = static_cast<char>('0' + abs_value);
}
o->write_characters(number_buffer.data(), n_chars);
}
|
O2
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::serializer<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>>::dump_integer<unsigned char, 0>(unsigned char):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x79f5c
movq %rsi, %r14
js 0x79f71
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7a318
jmp 0x79f90
movq (%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rax
pushq $0x30
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movb $0x2d, 0x10(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7a2e0
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7a318
incl %eax
cmpl $0x3f, %eax
jae 0x7a006
leaq 0x10(%rbx), %rsi
movl %eax, %ecx
leaq (%rsi,%rcx), %rdi
pushq $0x64
popq %r9
leaq 0x28f2f(%rip), %r8 # 0xa2ed9
cmpq $0x64, %r14
jb 0x79fcc
movq %r14, %rax
xorl %edx, %edx
divq %r9
movl %edx, %edx
movzwl (%r8,%rdx,2), %edx
movw %dx, -0x2(%rdi)
addq $-0x2, %rdi
movq %rax, %r14
jmp 0x79faa
cmpq $0xa, %r14
jb 0x79fe3
movb (%r8,%r14,2), %al
movb 0x1(%r8,%r14,2), %dl
movb %dl, -0x1(%rdi)
pushq $-0x2
popq %rdx
jmp 0x79fed
orb $0x30, %r14b
pushq $-0x1
popq %rdx
movl %r14d, %eax
movb %al, (%rdi,%rdx)
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rcx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x23cbe(%rip), %rdi # 0x9dccb
leaq 0x20575(%rip), %rdx # 0x9a589
leaq 0x2675d(%rip), %rcx # 0xa0778
movl $0x4952, %esi # imm = 0x4952
xorl %eax, %eax
callq 0x22ce0
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
push r14
push rbx
push rax
mov rbx, rdi
test rsi, rsi
jz short loc_79F5C
mov r14, rsi
js short loc_79F71
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12count_digitsEm; nlohmann::json_abi_v3_11_3::detail::serializer<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>>::count_digits(ulong)
jmp short loc_79F90
loc_79F5C:
mov rdi, [rbx]
mov rax, [rdi]
mov rax, [rax]
push 30h ; '0'
pop rsi
add rsp, 8
pop rbx
pop r14
jmp rax
loc_79F71:
mov byte ptr [rbx+10h], 2Dh ; '-'
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE11remove_signEl; nlohmann::json_abi_v3_11_3::detail::serializer<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>>::remove_sign(long)
mov r14, rax
mov rdi, rbx
mov rsi, rax
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12count_digitsEm; nlohmann::json_abi_v3_11_3::detail::serializer<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>>::count_digits(ulong)
inc eax
loc_79F90:
cmp eax, 3Fh ; '?'
jnb short loc_7A006
lea rsi, [rbx+10h]
mov ecx, eax
lea rdi, [rsi+rcx]
push 64h ; 'd'
pop r9
lea r8, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99; "000102030405060708091011121314151617181"...
loc_79FAA:
cmp r14, 64h ; 'd'
jb short loc_79FCC
mov rax, r14
xor edx, edx
div r9
mov edx, edx
movzx edx, word ptr [r8+rdx*2]
mov [rdi-2], dx
add rdi, 0FFFFFFFFFFFFFFFEh
mov r14, rax
jmp short loc_79FAA
loc_79FCC:
cmp r14, 0Ah
jb short loc_79FE3
mov al, [r8+r14*2]
mov dl, [r8+r14*2+1]
mov [rdi-1], dl
push 0FFFFFFFFFFFFFFFEh
pop rdx
jmp short loc_79FED
loc_79FE3:
or r14b, 30h
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov eax, r14d
loc_79FED:
mov [rdi+rdx], al
mov rdi, [rbx]
mov rax, [rdi]
mov rax, [rax+8]
mov rdx, rcx
add rsp, 8
pop rbx
pop r14
jmp rax
loc_7A006:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNCharsNumberBu; "n_chars < number_buffer.size() - 1"
mov esi, 4952h
xor eax, eax
call _ggml_abort
nop
|
long long ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_(
_QWORD *a1,
long long a2)
{
unsigned long long v3; // r14
unsigned int v4; // eax
_QWORD *v6; // rsi
long long v7; // rcx
long long v8; // rdi
char v9; // al
long long v10; // rdx
if ( !a2 )
return (**(long long ( ***)(_QWORD, long long))*a1)(*a1, 48LL);
v3 = a2;
if ( a2 < 0 )
{
*((_BYTE *)a1 + 16) = 45;
v3 = nlohmann::json_abi_v3_11_3::detail::serializer<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>>::remove_sign(
a1,
a2);
v4 = nlohmann::json_abi_v3_11_3::detail::serializer<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>>::count_digits(
a1,
v3)
+ 1;
}
else
{
v4 = nlohmann::json_abi_v3_11_3::detail::serializer<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>>::count_digits(
a1,
a2);
}
if ( v4 >= 0x3F )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
18770LL,
"GGML_ASSERT(%s) failed",
"n_chars < number_buffer.size() - 1");
return nlohmann::json_abi_v3_11_3::detail::serializer<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>>::dump_float();
}
else
{
v6 = a1 + 2;
v7 = v4;
v8 = (long long)a1 + v4 + 16;
while ( v3 >= 0x64 )
{
*(_WORD *)(v8 - 2) = *(_WORD *)&ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99[2 * (v3 % 0x64)];
v8 -= 2LL;
v3 /= 0x64uLL;
}
if ( v3 < 0xA )
{
v10 = -1LL;
v9 = v3 | 0x30;
}
else
{
v9 = ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99[2 * v3];
*(_BYTE *)(v8 - 1) = ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99[2 * v3 + 1];
v10 = -2LL;
}
*(_BYTE *)(v8 + v10) = v9;
return (*(long long ( **)(_QWORD, _QWORD *, long long))(*(_QWORD *)*a1 + 8LL))(*a1, v6, v7);
}
}
|
_ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
TEST RSI,RSI
JZ 0x00179f5c
MOV R14,RSI
JS 0x00179f71
MOV RDI,RBX
MOV RSI,R14
CALL 0x0017a318
JMP 0x00179f90
LAB_00179f5c:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
PUSH 0x30
POP RSI
ADD RSP,0x8
POP RBX
POP R14
JMP RAX
LAB_00179f71:
MOV byte ptr [RBX + 0x10],0x2d
MOV RDI,RBX
MOV RSI,R14
CALL 0x0017a2e0
MOV R14,RAX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0017a318
INC EAX
LAB_00179f90:
CMP EAX,0x3f
JNC 0x0017a006
LEA RSI,[RBX + 0x10]
MOV ECX,EAX
LEA RDI,[RSI + RCX*0x1]
PUSH 0x64
POP R9
LEA R8,[0x1a2ed9]
LAB_00179faa:
CMP R14,0x64
JC 0x00179fcc
MOV RAX,R14
XOR EDX,EDX
DIV R9
MOV EDX,EDX
MOVZX EDX,word ptr [R8 + RDX*0x2]
MOV word ptr [RDI + -0x2],DX
ADD RDI,-0x2
MOV R14,RAX
JMP 0x00179faa
LAB_00179fcc:
CMP R14,0xa
JC 0x00179fe3
MOV AL,byte ptr [R8 + R14*0x2]
MOV DL,byte ptr [R8 + R14*0x2 + 0x1]
MOV byte ptr [RDI + -0x1],DL
PUSH -0x2
POP RDX
JMP 0x00179fed
LAB_00179fe3:
OR R14B,0x30
PUSH -0x1
POP RDX
MOV EAX,R14D
LAB_00179fed:
MOV byte ptr [RDI + RDX*0x1],AL
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,RCX
ADD RSP,0x8
POP RBX
POP R14
JMP RAX
LAB_0017a006:
LEA RDI,[0x19dccb]
LEA RDX,[0x19a589]
LEA RCX,[0x1a0778]
MOV ESI,0x4952
XOR EAX,EAX
CALL 0x00122ce0
|
void _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_
(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*param_1,ulong param_2)
{
uint uVar1;
int iVar2;
long lVar3;
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*psVar4;
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
sVar5;
if (param_2 == 0) {
/* WARNING: Could not recover jumptable at 0x00179f6f. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)**(int8 **)param_1)(*(int8 **)param_1,0x30);
return;
}
if ((long)param_2 < 0) {
param_1[0x10] =
(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x2d;
param_2 = nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::remove_sign(param_1,param_2);
iVar2 = nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::count_digits(param_1,param_2);
uVar1 = iVar2 + 1;
}
else {
uVar1 = nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::count_digits(param_1,param_2);
}
if (uVar1 < 0x3f) {
psVar4 = param_1 + 0x10 + uVar1;
for (; 99 < param_2; param_2 = param_2 / 100) {
*(int2 *)(psVar4 + -2) =
*(int2 *)
(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ (param_2 % 100) * 2);
psVar4 = psVar4 + -2;
}
if (param_2 < 10) {
sVar5 = (serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)((byte)param_2 | 0x30);
lVar3 = -1;
}
else {
sVar5 = *(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ param_2 * 2);
psVar4[-1] = *(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ param_2 * 2 + 1);
lVar3 = -2;
}
psVar4[lVar3] = sVar5;
/* WARNING: Could not recover jumptable at 0x0017a004. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(**(long **)param_1 + 8))(*(long **)param_1,param_1 + 0x10,(ulong)uVar1);
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x4952,
"GGML_ASSERT(%s) failed","n_chars < number_buffer.size() - 1");
}
|
|
64,701 |
lunasvg::SVGPreserveAspectRatio::transformRect(lunasvg::Rect&, lunasvg::Rect&) const
|
dmazzella[P]pylunasvg/lunasvg/source/svgproperty.cpp
|
void SVGPreserveAspectRatio::transformRect(Rect& dstRect, Rect& srcRect) const
{
if(m_alignType == AlignType::None)
return;
auto viewSize = dstRect.size();
auto imageSize = srcRect.size();
if(m_meetOrSlice == MeetOrSlice::Meet) {
auto scale = imageSize.h / imageSize.w;
if(viewSize.h > viewSize.w * scale) {
dstRect.h = viewSize.w * scale;
switch(m_alignType) {
case AlignType::xMinYMid:
case AlignType::xMidYMid:
case AlignType::xMaxYMid:
dstRect.y += (viewSize.h - dstRect.h) * 0.5f;
break;
case AlignType::xMinYMax:
case AlignType::xMidYMax:
case AlignType::xMaxYMax:
dstRect.y += viewSize.h - dstRect.h;
break;
default:
break;
}
}
if(viewSize.w > viewSize.h / scale) {
dstRect.w = viewSize.h / scale;
switch(m_alignType) {
case AlignType::xMidYMin:
case AlignType::xMidYMid:
case AlignType::xMidYMax:
dstRect.x += (viewSize.w - dstRect.w) * 0.5f;
break;
case AlignType::xMaxYMin:
case AlignType::xMaxYMid:
case AlignType::xMaxYMax:
dstRect.x += viewSize.w - dstRect.w;
break;
default:
break;
}
}
} else if(m_meetOrSlice == MeetOrSlice::Slice) {
auto scale = imageSize.h / imageSize.w;
if(viewSize.h < viewSize.w * scale) {
srcRect.h = viewSize.h * (imageSize.w / viewSize.w);
switch(m_alignType) {
case AlignType::xMinYMid:
case AlignType::xMidYMid:
case AlignType::xMaxYMid:
srcRect.y += (imageSize.h - srcRect.h) * 0.5f;
break;
case AlignType::xMinYMax:
case AlignType::xMidYMax:
case AlignType::xMaxYMax:
srcRect.y += imageSize.h - srcRect.h;
break;
default:
break;
}
}
if(viewSize.w < viewSize.h / scale) {
srcRect.w = viewSize.w * (imageSize.h / viewSize.h);
switch(m_alignType) {
case AlignType::xMidYMin:
case AlignType::xMidYMid:
case AlignType::xMidYMax:
srcRect.x += (imageSize.w - srcRect.w) * 0.5f;
break;
case AlignType::xMaxYMin:
case AlignType::xMaxYMid:
case AlignType::xMaxYMax:
srcRect.x += imageSize.w - srcRect.w;
break;
default:
break;
}
}
}
}
|
O0
|
cpp
|
lunasvg::SVGPreserveAspectRatio::transformRect(lunasvg::Rect&, lunasvg::Rect&) const:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0xc(%rax)
jne 0x4ab57
jmp 0x4ae84
movq -0x10(%rbp), %rdi
callq 0x1fff0
movlpd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fff0
movq -0x38(%rbp), %rax
movlpd %xmm0, -0x28(%rbp)
cmpl $0x0, 0x10(%rax)
jne 0x4acf3
movss -0x24(%rbp), %xmm0
divss -0x28(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
mulss -0x2c(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x4ac30
movq -0x38(%rbp), %rax
movss -0x20(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
mulss %xmm1, %xmm0
movq -0x10(%rbp), %rcx
movss %xmm0, 0xc(%rcx)
movl 0xc(%rax), %eax
movl %eax, -0x3c(%rbp)
addl $-0x4, %eax
subl $0x3, %eax
jb 0x4abe0
jmp 0x4abd3
movl -0x3c(%rbp), %eax
addl $-0x7, %eax
subl $0x3, %eax
jb 0x4ac0e
jmp 0x4ac2c
movss -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rax
subss 0xc(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm1
movss 0x41c61(%rip), %xmm2 # 0x8c860
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x4(%rax)
jmp 0x4ac2e
movss -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rax
subss 0xc(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
jmp 0x4ac2e
jmp 0x4ac2e
jmp 0x4ac30
movss -0x20(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
divss -0x2c(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x4acee
movq -0x38(%rbp), %rax
movss -0x1c(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x10(%rbp), %rcx
movss %xmm0, 0x8(%rcx)
movl 0xc(%rax), %eax
movl %eax, -0x40(%rbp)
subl $0x2, %eax
je 0x4aca2
jmp 0x4ac70
movl -0x40(%rbp), %eax
subl $0x3, %eax
je 0x4acce
jmp 0x4ac7a
movl -0x40(%rbp), %eax
subl $0x5, %eax
je 0x4aca2
jmp 0x4ac84
movl -0x40(%rbp), %eax
subl $0x6, %eax
je 0x4acce
jmp 0x4ac8e
movl -0x40(%rbp), %eax
subl $0x8, %eax
je 0x4aca2
jmp 0x4ac98
movl -0x40(%rbp), %eax
subl $0x9, %eax
je 0x4acce
jmp 0x4acea
movss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
subss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss (%rax), %xmm1
movss 0x41ba0(%rip), %xmm2 # 0x8c860
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
jmp 0x4acec
movss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
subss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, (%rax)
jmp 0x4acec
jmp 0x4acec
jmp 0x4acee
jmp 0x4ae84
movq -0x38(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x4ae82
movss -0x24(%rbp), %xmm0
divss -0x28(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x1c(%rbp), %xmm1
movss -0x20(%rbp), %xmm0
mulss -0x30(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4adb9
movq -0x38(%rbp), %rax
movss -0x20(%rbp), %xmm2
movss -0x1c(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
divss %xmm2, %xmm1
mulss %xmm1, %xmm0
movq -0x18(%rbp), %rcx
movss %xmm0, 0xc(%rcx)
movl 0xc(%rax), %eax
movl %eax, -0x44(%rbp)
addl $-0x4, %eax
subl $0x3, %eax
jb 0x4ad69
jmp 0x4ad5c
movl -0x44(%rbp), %eax
addl $-0x7, %eax
subl $0x3, %eax
jb 0x4ad97
jmp 0x4adb5
movss -0x24(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movss 0x41ad8(%rip), %xmm2 # 0x8c860
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x4(%rax)
jmp 0x4adb7
movss -0x24(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
addss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
jmp 0x4adb7
jmp 0x4adb7
jmp 0x4adb9
movss -0x20(%rbp), %xmm1
movss -0x1c(%rbp), %xmm0
divss -0x30(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4ae80
movq -0x38(%rbp), %rax
movss -0x24(%rbp), %xmm1
movss -0x20(%rbp), %xmm0
movss -0x1c(%rbp), %xmm2
divss %xmm2, %xmm1
mulss %xmm1, %xmm0
movq -0x18(%rbp), %rcx
movss %xmm0, 0x8(%rcx)
movl 0xc(%rax), %eax
movl %eax, -0x48(%rbp)
subl $0x2, %eax
je 0x4ae34
jmp 0x4ae02
movl -0x48(%rbp), %eax
subl $0x3, %eax
je 0x4ae60
jmp 0x4ae0c
movl -0x48(%rbp), %eax
subl $0x5, %eax
je 0x4ae34
jmp 0x4ae16
movl -0x48(%rbp), %eax
subl $0x6, %eax
je 0x4ae60
jmp 0x4ae20
movl -0x48(%rbp), %eax
subl $0x8, %eax
je 0x4ae34
jmp 0x4ae2a
movl -0x48(%rbp), %eax
subl $0x9, %eax
je 0x4ae60
jmp 0x4ae7c
movss -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
movss 0x41a0e(%rip), %xmm2 # 0x8c860
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
jmp 0x4ae7e
movss -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, (%rax)
jmp 0x4ae7e
jmp 0x4ae7e
jmp 0x4ae80
jmp 0x4ae82
jmp 0x4ae84
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZNK7lunasvg22SVGPreserveAspectRatio13transformRectERNS_4RectES2_:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
cmp dword ptr [rax+0Ch], 0
jnz short loc_4AB57
jmp loc_4AE84
loc_4AB57:
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg4Rect4sizeEv; lunasvg::Rect::size(void)
movlpd [rbp+var_20], xmm0
mov rdi, [rbp+var_18]; this
call _ZNK7lunasvg4Rect4sizeEv; lunasvg::Rect::size(void)
mov rax, [rbp+var_38]
movlpd [rbp+var_28], xmm0
cmp dword ptr [rax+10h], 0
jnz loc_4ACF3
movss xmm0, dword ptr [rbp+var_28+4]
divss xmm0, dword ptr [rbp+var_28]
movss [rbp+var_2C], xmm0
movss xmm0, dword ptr [rbp+var_20+4]
movss xmm1, dword ptr [rbp+var_20]
mulss xmm1, [rbp+var_2C]
ucomiss xmm0, xmm1
jbe loc_4AC30
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rbp+var_20]
movss xmm1, [rbp+var_2C]
mulss xmm0, xmm1
mov rcx, [rbp+var_10]
movss dword ptr [rcx+0Ch], xmm0
mov eax, [rax+0Ch]
mov [rbp+var_3C], eax
add eax, 0FFFFFFFCh
sub eax, 3
jb short loc_4ABE0
jmp short $+2
loc_4ABD3:
mov eax, [rbp+var_3C]
add eax, 0FFFFFFF9h
sub eax, 3
jb short loc_4AC0E
jmp short loc_4AC2C
loc_4ABE0:
movss xmm0, dword ptr [rbp+var_20+4]
mov rax, [rbp+var_10]
subss xmm0, dword ptr [rax+0Ch]
mov rax, [rbp+var_10]
movss xmm1, dword ptr [rax+4]
movss xmm2, cs:dword_8C860
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rax+4], xmm0
jmp short loc_4AC2E
loc_4AC0E:
movss xmm0, dword ptr [rbp+var_20+4]
mov rax, [rbp+var_10]
subss xmm0, dword ptr [rax+0Ch]
mov rax, [rbp+var_10]
addss xmm0, dword ptr [rax+4]
movss dword ptr [rax+4], xmm0
jmp short loc_4AC2E
loc_4AC2C:
jmp short $+2
loc_4AC2E:
jmp short $+2
loc_4AC30:
movss xmm0, dword ptr [rbp+var_20]
movss xmm1, dword ptr [rbp+var_20+4]
divss xmm1, [rbp+var_2C]
ucomiss xmm0, xmm1
jbe loc_4ACEE
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rbp+var_20+4]
movss xmm1, [rbp+var_2C]
divss xmm0, xmm1
mov rcx, [rbp+var_10]
movss dword ptr [rcx+8], xmm0
mov eax, [rax+0Ch]
mov [rbp+var_40], eax
sub eax, 2
jz short loc_4ACA2
jmp short $+2
loc_4AC70:
mov eax, [rbp+var_40]
sub eax, 3
jz short loc_4ACCE
jmp short $+2
loc_4AC7A:
mov eax, [rbp+var_40]
sub eax, 5
jz short loc_4ACA2
jmp short $+2
loc_4AC84:
mov eax, [rbp+var_40]
sub eax, 6
jz short loc_4ACCE
jmp short $+2
loc_4AC8E:
mov eax, [rbp+var_40]
sub eax, 8
jz short loc_4ACA2
jmp short $+2
loc_4AC98:
mov eax, [rbp+var_40]
sub eax, 9
jz short loc_4ACCE
jmp short loc_4ACEA
loc_4ACA2:
movss xmm0, dword ptr [rbp+var_20]
mov rax, [rbp+var_10]
subss xmm0, dword ptr [rax+8]
mov rax, [rbp+var_10]
movss xmm1, dword ptr [rax]
movss xmm2, cs:dword_8C860
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rax], xmm0
jmp short loc_4ACEC
loc_4ACCE:
movss xmm0, dword ptr [rbp+var_20]
mov rax, [rbp+var_10]
subss xmm0, dword ptr [rax+8]
mov rax, [rbp+var_10]
addss xmm0, dword ptr [rax]
movss dword ptr [rax], xmm0
jmp short loc_4ACEC
loc_4ACEA:
jmp short $+2
loc_4ACEC:
jmp short $+2
loc_4ACEE:
jmp loc_4AE84
loc_4ACF3:
mov rax, [rbp+var_38]
cmp dword ptr [rax+10h], 1
jnz loc_4AE82
movss xmm0, dword ptr [rbp+var_28+4]
divss xmm0, dword ptr [rbp+var_28]
movss [rbp+var_30], xmm0
movss xmm1, dword ptr [rbp+var_20+4]
movss xmm0, dword ptr [rbp+var_20]
mulss xmm0, [rbp+var_30]
ucomiss xmm0, xmm1
jbe loc_4ADB9
mov rax, [rbp+var_38]
movss xmm2, dword ptr [rbp+var_20]
movss xmm0, dword ptr [rbp+var_20+4]
movss xmm1, dword ptr [rbp+var_28]
divss xmm1, xmm2
mulss xmm0, xmm1
mov rcx, [rbp+var_18]
movss dword ptr [rcx+0Ch], xmm0
mov eax, [rax+0Ch]
mov [rbp+var_44], eax
add eax, 0FFFFFFFCh
sub eax, 3
jb short loc_4AD69
jmp short $+2
loc_4AD5C:
mov eax, [rbp+var_44]
add eax, 0FFFFFFF9h
sub eax, 3
jb short loc_4AD97
jmp short loc_4ADB5
loc_4AD69:
movss xmm0, dword ptr [rbp+var_28+4]
mov rax, [rbp+var_18]
subss xmm0, dword ptr [rax+0Ch]
mov rax, [rbp+var_18]
movss xmm1, dword ptr [rax+4]
movss xmm2, cs:dword_8C860
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rax+4], xmm0
jmp short loc_4ADB7
loc_4AD97:
movss xmm0, dword ptr [rbp+var_28+4]
mov rax, [rbp+var_18]
subss xmm0, dword ptr [rax+0Ch]
mov rax, [rbp+var_18]
addss xmm0, dword ptr [rax+4]
movss dword ptr [rax+4], xmm0
jmp short loc_4ADB7
loc_4ADB5:
jmp short $+2
loc_4ADB7:
jmp short $+2
loc_4ADB9:
movss xmm1, dword ptr [rbp+var_20]
movss xmm0, dword ptr [rbp+var_20+4]
divss xmm0, [rbp+var_30]
ucomiss xmm0, xmm1
jbe loc_4AE80
mov rax, [rbp+var_38]
movss xmm1, dword ptr [rbp+var_28+4]
movss xmm0, dword ptr [rbp+var_20]
movss xmm2, dword ptr [rbp+var_20+4]
divss xmm1, xmm2
mulss xmm0, xmm1
mov rcx, [rbp+var_18]
movss dword ptr [rcx+8], xmm0
mov eax, [rax+0Ch]
mov [rbp+var_48], eax
sub eax, 2
jz short loc_4AE34
jmp short $+2
loc_4AE02:
mov eax, [rbp+var_48]
sub eax, 3
jz short loc_4AE60
jmp short $+2
loc_4AE0C:
mov eax, [rbp+var_48]
sub eax, 5
jz short loc_4AE34
jmp short $+2
loc_4AE16:
mov eax, [rbp+var_48]
sub eax, 6
jz short loc_4AE60
jmp short $+2
loc_4AE20:
mov eax, [rbp+var_48]
sub eax, 8
jz short loc_4AE34
jmp short $+2
loc_4AE2A:
mov eax, [rbp+var_48]
sub eax, 9
jz short loc_4AE60
jmp short loc_4AE7C
loc_4AE34:
movss xmm0, dword ptr [rbp+var_28]
mov rax, [rbp+var_18]
subss xmm0, dword ptr [rax+8]
mov rax, [rbp+var_18]
movss xmm1, dword ptr [rax]
movss xmm2, cs:dword_8C860
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rax], xmm0
jmp short loc_4AE7E
loc_4AE60:
movss xmm0, dword ptr [rbp+var_28]
mov rax, [rbp+var_18]
subss xmm0, dword ptr [rax+8]
mov rax, [rbp+var_18]
addss xmm0, dword ptr [rax]
movss dword ptr [rax], xmm0
jmp short loc_4AE7E
loc_4AE7C:
jmp short $+2
loc_4AE7E:
jmp short $+2
loc_4AE80:
jmp short $+2
loc_4AE82:
jmp short $+2
loc_4AE84:
add rsp, 50h
pop rbp
retn
|
unsigned long long lunasvg::SVGPreserveAspectRatio::transformRect(
lunasvg::SVGPreserveAspectRatio *this,
lunasvg::Rect *a2,
lunasvg::Rect *a3)
{
unsigned long long result; // rax
double v4; // xmm0_8
int v5; // [rsp+8h] [rbp-48h]
int v6; // [rsp+Ch] [rbp-44h]
int v7; // [rsp+10h] [rbp-40h]
int v8; // [rsp+14h] [rbp-3Ch]
float v9; // [rsp+24h] [rbp-2Ch]
double v10; // [rsp+30h] [rbp-20h]
result = (unsigned long long)this;
if ( !*((_DWORD *)this + 3) )
return result;
v10 = lunasvg::Rect::size(a2);
v4 = lunasvg::Rect::size(a3);
result = (unsigned long long)this;
if ( *((_DWORD *)this + 4) )
{
result = (unsigned long long)this;
if ( *((_DWORD *)this + 4) != 1 )
return result;
if ( (float)(*(float *)&v10 * (float)(*((float *)&v4 + 1) / *(float *)&v4)) > *((float *)&v10 + 1) )
{
*((float *)a3 + 3) = *((float *)&v10 + 1) * (float)(*(float *)&v4 / *(float *)&v10);
v6 = *((_DWORD *)this + 3);
if ( (unsigned int)(v6 - 4) < 3 )
{
result = (unsigned long long)a3;
*((float *)a3 + 1) = (float)((float)(*((float *)&v4 + 1) - *((float *)a3 + 3)) * 0.5) + *((float *)a3 + 1);
}
else
{
result = (unsigned int)(v6 - 10);
if ( (unsigned int)(v6 - 7) < 3 )
{
result = (unsigned long long)a3;
*((float *)a3 + 1) = (float)(*((float *)&v4 + 1) - *((float *)a3 + 3)) + *((float *)a3 + 1);
}
}
}
if ( (float)(*((float *)&v10 + 1) / (float)(*((float *)&v4 + 1) / *(float *)&v4)) <= *(float *)&v10 )
return result;
*((float *)a3 + 2) = *(float *)&v10 * (float)(*((float *)&v4 + 1) / *((float *)&v10 + 1));
v5 = *((_DWORD *)this + 3);
if ( v5 != 2 )
{
if ( v5 == 3 )
goto LABEL_36;
if ( v5 != 5 )
{
if ( v5 == 6 )
goto LABEL_36;
if ( v5 != 8 )
{
result = (unsigned int)(v5 - 9);
if ( v5 != 9 )
return result;
LABEL_36:
result = (unsigned long long)a3;
*(float *)a3 = (float)(*(float *)&v4 - *((float *)a3 + 2)) + *(float *)a3;
return result;
}
}
}
result = (unsigned long long)a3;
*(float *)a3 = (float)((float)(*(float *)&v4 - *((float *)a3 + 2)) * 0.5) + *(float *)a3;
return result;
}
v9 = *((float *)&v4 + 1) / *(float *)&v4;
if ( *((float *)&v10 + 1) > (float)(*(float *)&v10 * (float)(*((float *)&v4 + 1) / *(float *)&v4)) )
{
*((float *)a2 + 3) = *(float *)&v10 * v9;
v8 = *((_DWORD *)this + 3);
if ( (unsigned int)(v8 - 4) < 3 )
{
result = (unsigned long long)a2;
*((float *)a2 + 1) = (float)((float)(*((float *)&v10 + 1) - *((float *)a2 + 3)) * 0.5) + *((float *)a2 + 1);
}
else
{
result = (unsigned int)(v8 - 10);
if ( (unsigned int)(v8 - 7) < 3 )
{
result = (unsigned long long)a2;
*((float *)a2 + 1) = (float)(*((float *)&v10 + 1) - *((float *)a2 + 3)) + *((float *)a2 + 1);
}
}
}
if ( *(float *)&v10 > (float)(*((float *)&v10 + 1) / v9) )
{
*((float *)a2 + 2) = *((float *)&v10 + 1) / v9;
v7 = *((_DWORD *)this + 3);
if ( v7 != 2 )
{
if ( v7 == 3 )
goto LABEL_18;
if ( v7 != 5 )
{
if ( v7 == 6 )
goto LABEL_18;
if ( v7 != 8 )
{
result = (unsigned int)(v7 - 9);
if ( v7 != 9 )
return result;
LABEL_18:
result = (unsigned long long)a2;
*(float *)a2 = (float)(*(float *)&v10 - *((float *)a2 + 2)) + *(float *)a2;
return result;
}
}
}
result = (unsigned long long)a2;
*(float *)a2 = (float)((float)(*(float *)&v10 - *((float *)a2 + 2)) * 0.5) + *(float *)a2;
}
return result;
}
|
transformRect:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
CMP dword ptr [RAX + 0xc],0x0
JNZ 0x0014ab57
JMP 0x0014ae84
LAB_0014ab57:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011fff0
MOVLPD qword ptr [RBP + -0x20],XMM0
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0011fff0
MOV RAX,qword ptr [RBP + -0x38]
MOVLPD qword ptr [RBP + -0x28],XMM0
CMP dword ptr [RAX + 0x10],0x0
JNZ 0x0014acf3
MOVSS XMM0,dword ptr [RBP + -0x24]
DIVSS XMM0,dword ptr [RBP + -0x28]
MOVSS dword ptr [RBP + -0x2c],XMM0
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOVSS XMM1,dword ptr [RBP + -0x20]
MULSS XMM1,dword ptr [RBP + -0x2c]
UCOMISS XMM0,XMM1
JBE 0x0014ac30
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RBP + -0x20]
MOVSS XMM1,dword ptr [RBP + -0x2c]
MULSS XMM0,XMM1
MOV RCX,qword ptr [RBP + -0x10]
MOVSS dword ptr [RCX + 0xc],XMM0
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x3c],EAX
ADD EAX,-0x4
SUB EAX,0x3
JC 0x0014abe0
JMP 0x0014abd3
LAB_0014abd3:
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,-0x7
SUB EAX,0x3
JC 0x0014ac0e
JMP 0x0014ac2c
LAB_0014abe0:
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
SUBSS XMM0,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM1,dword ptr [RAX + 0x4]
MOVSS XMM2,dword ptr [0x0018c860]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RAX + 0x4],XMM0
JMP 0x0014ac2e
LAB_0014ac0e:
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
SUBSS XMM0,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x10]
ADDSS XMM0,dword ptr [RAX + 0x4]
MOVSS dword ptr [RAX + 0x4],XMM0
JMP 0x0014ac2e
LAB_0014ac2c:
JMP 0x0014ac2e
LAB_0014ac2e:
JMP 0x0014ac30
LAB_0014ac30:
MOVSS XMM0,dword ptr [RBP + -0x20]
MOVSS XMM1,dword ptr [RBP + -0x1c]
DIVSS XMM1,dword ptr [RBP + -0x2c]
UCOMISS XMM0,XMM1
JBE 0x0014acee
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOVSS XMM1,dword ptr [RBP + -0x2c]
DIVSS XMM0,XMM1
MOV RCX,qword ptr [RBP + -0x10]
MOVSS dword ptr [RCX + 0x8],XMM0
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x40],EAX
SUB EAX,0x2
JZ 0x0014aca2
JMP 0x0014ac70
LAB_0014ac70:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x3
JZ 0x0014acce
JMP 0x0014ac7a
LAB_0014ac7a:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x5
JZ 0x0014aca2
JMP 0x0014ac84
LAB_0014ac84:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x6
JZ 0x0014acce
JMP 0x0014ac8e
LAB_0014ac8e:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x8
JZ 0x0014aca2
JMP 0x0014ac98
LAB_0014ac98:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x9
JZ 0x0014acce
JMP 0x0014acea
LAB_0014aca2:
MOVSS XMM0,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
SUBSS XMM0,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM1,dword ptr [RAX]
MOVSS XMM2,dword ptr [0x0018c860]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RAX],XMM0
JMP 0x0014acec
LAB_0014acce:
MOVSS XMM0,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
SUBSS XMM0,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADDSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RAX],XMM0
JMP 0x0014acec
LAB_0014acea:
JMP 0x0014acec
LAB_0014acec:
JMP 0x0014acee
LAB_0014acee:
JMP 0x0014ae84
LAB_0014acf3:
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX + 0x10],0x1
JNZ 0x0014ae82
MOVSS XMM0,dword ptr [RBP + -0x24]
DIVSS XMM0,dword ptr [RBP + -0x28]
MOVSS dword ptr [RBP + -0x30],XMM0
MOVSS XMM1,dword ptr [RBP + -0x1c]
MOVSS XMM0,dword ptr [RBP + -0x20]
MULSS XMM0,dword ptr [RBP + -0x30]
UCOMISS XMM0,XMM1
JBE 0x0014adb9
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM2,dword ptr [RBP + -0x20]
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOVSS XMM1,dword ptr [RBP + -0x28]
DIVSS XMM1,XMM2
MULSS XMM0,XMM1
MOV RCX,qword ptr [RBP + -0x18]
MOVSS dword ptr [RCX + 0xc],XMM0
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x44],EAX
ADD EAX,-0x4
SUB EAX,0x3
JC 0x0014ad69
JMP 0x0014ad5c
LAB_0014ad5c:
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,-0x7
SUB EAX,0x3
JC 0x0014ad97
JMP 0x0014adb5
LAB_0014ad69:
MOVSS XMM0,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x18]
SUBSS XMM0,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM1,dword ptr [RAX + 0x4]
MOVSS XMM2,dword ptr [0x0018c860]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RAX + 0x4],XMM0
JMP 0x0014adb7
LAB_0014ad97:
MOVSS XMM0,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x18]
SUBSS XMM0,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x18]
ADDSS XMM0,dword ptr [RAX + 0x4]
MOVSS dword ptr [RAX + 0x4],XMM0
JMP 0x0014adb7
LAB_0014adb5:
JMP 0x0014adb7
LAB_0014adb7:
JMP 0x0014adb9
LAB_0014adb9:
MOVSS XMM1,dword ptr [RBP + -0x20]
MOVSS XMM0,dword ptr [RBP + -0x1c]
DIVSS XMM0,dword ptr [RBP + -0x30]
UCOMISS XMM0,XMM1
JBE 0x0014ae80
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM1,dword ptr [RBP + -0x24]
MOVSS XMM0,dword ptr [RBP + -0x20]
MOVSS XMM2,dword ptr [RBP + -0x1c]
DIVSS XMM1,XMM2
MULSS XMM0,XMM1
MOV RCX,qword ptr [RBP + -0x18]
MOVSS dword ptr [RCX + 0x8],XMM0
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x48],EAX
SUB EAX,0x2
JZ 0x0014ae34
JMP 0x0014ae02
LAB_0014ae02:
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,0x3
JZ 0x0014ae60
JMP 0x0014ae0c
LAB_0014ae0c:
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,0x5
JZ 0x0014ae34
JMP 0x0014ae16
LAB_0014ae16:
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,0x6
JZ 0x0014ae60
JMP 0x0014ae20
LAB_0014ae20:
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,0x8
JZ 0x0014ae34
JMP 0x0014ae2a
LAB_0014ae2a:
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,0x9
JZ 0x0014ae60
JMP 0x0014ae7c
LAB_0014ae34:
MOVSS XMM0,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
SUBSS XMM0,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM1,dword ptr [RAX]
MOVSS XMM2,dword ptr [0x0018c860]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RAX],XMM0
JMP 0x0014ae7e
LAB_0014ae60:
MOVSS XMM0,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
SUBSS XMM0,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADDSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RAX],XMM0
JMP 0x0014ae7e
LAB_0014ae7c:
JMP 0x0014ae7e
LAB_0014ae7e:
JMP 0x0014ae80
LAB_0014ae80:
JMP 0x0014ae82
LAB_0014ae82:
JMP 0x0014ae84
LAB_0014ae84:
ADD RSP,0x50
POP RBP
RET
|
/* lunasvg::SVGPreserveAspectRatio::transformRect(lunasvg::Rect&, lunasvg::Rect&) const */
Rect * __thiscall
lunasvg::SVGPreserveAspectRatio::transformRect
(SVGPreserveAspectRatio *this,Rect *param_1,Rect *param_2)
{
int iVar1;
Rect *pRVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar7;
int8 uVar6;
if (*(int *)(this + 0xc) == 0) {
return (Rect *)this;
}
uVar6 = Rect::size(param_1);
fVar7 = (float)((ulong)uVar6 >> 0x20);
fVar3 = (float)uVar6;
uVar6 = Rect::size(param_2);
fVar5 = (float)((ulong)uVar6 >> 0x20);
fVar4 = (float)uVar6;
if (*(int *)(this + 0x10) != 0) {
if (*(int *)(this + 0x10) != 1) {
return (Rect *)this;
}
pRVar2 = (Rect *)this;
if (fVar7 < fVar3 * (fVar5 / fVar4)) {
*(float *)(param_2 + 0xc) = fVar7 * (fVar4 / fVar3);
iVar1 = *(int *)(this + 0xc);
if (iVar1 - 4U < 3) {
*(float *)(param_2 + 4) =
(fVar5 - *(float *)(param_2 + 0xc)) * DAT_0018c860 + *(float *)(param_2 + 4);
pRVar2 = param_2;
}
else {
pRVar2 = (Rect *)(ulong)(iVar1 - 10);
if (iVar1 - 7U < 3) {
*(float *)(param_2 + 4) = (fVar5 - *(float *)(param_2 + 0xc)) + *(float *)(param_2 + 4);
pRVar2 = param_2;
}
}
}
if (fVar7 / (fVar5 / fVar4) <= fVar3) {
return pRVar2;
}
*(float *)(param_2 + 8) = fVar3 * (fVar5 / fVar7);
iVar1 = *(int *)(this + 0xc);
if (iVar1 != 2) {
if (iVar1 != 3) {
if (iVar1 == 5) goto LAB_0014ae34;
if (iVar1 != 6) {
if (iVar1 == 8) goto LAB_0014ae34;
if (iVar1 - 9U != 0) {
return (Rect *)(ulong)(iVar1 - 9U);
}
}
}
*(float *)param_2 = (fVar4 - *(float *)(param_2 + 8)) + *(float *)param_2;
return param_2;
}
LAB_0014ae34:
*(float *)param_2 = (fVar4 - *(float *)(param_2 + 8)) * DAT_0018c860 + *(float *)param_2;
return param_2;
}
fVar5 = fVar5 / fVar4;
pRVar2 = (Rect *)this;
if (fVar3 * fVar5 < fVar7) {
*(float *)(param_1 + 0xc) = fVar3 * fVar5;
iVar1 = *(int *)(this + 0xc);
if (iVar1 - 4U < 3) {
*(float *)(param_1 + 4) =
(fVar7 - *(float *)(param_1 + 0xc)) * DAT_0018c860 + *(float *)(param_1 + 4);
pRVar2 = param_1;
}
else {
pRVar2 = (Rect *)(ulong)(iVar1 - 10);
if (iVar1 - 7U < 3) {
*(float *)(param_1 + 4) = (fVar7 - *(float *)(param_1 + 0xc)) + *(float *)(param_1 + 4);
pRVar2 = param_1;
}
}
}
if (fVar3 <= fVar7 / fVar5) {
return pRVar2;
}
*(float *)(param_1 + 8) = fVar7 / fVar5;
iVar1 = *(int *)(this + 0xc);
if (iVar1 == 2) {
LAB_0014aca2:
*(float *)param_1 = (fVar3 - *(float *)(param_1 + 8)) * DAT_0018c860 + *(float *)param_1;
}
else {
if (iVar1 != 3) {
if (iVar1 == 5) goto LAB_0014aca2;
if (iVar1 != 6) {
if (iVar1 == 8) goto LAB_0014aca2;
if (iVar1 - 9U != 0) {
return (Rect *)(ulong)(iVar1 - 9U);
}
}
}
*(float *)param_1 = (fVar3 - *(float *)(param_1 + 8)) + *(float *)param_1;
}
return param_1;
}
|
|
64,702 |
lunasvg::SVGPreserveAspectRatio::transformRect(lunasvg::Rect&, lunasvg::Rect&) const
|
dmazzella[P]pylunasvg/lunasvg/source/svgproperty.cpp
|
void SVGPreserveAspectRatio::transformRect(Rect& dstRect, Rect& srcRect) const
{
if(m_alignType == AlignType::None)
return;
auto viewSize = dstRect.size();
auto imageSize = srcRect.size();
if(m_meetOrSlice == MeetOrSlice::Meet) {
auto scale = imageSize.h / imageSize.w;
if(viewSize.h > viewSize.w * scale) {
dstRect.h = viewSize.w * scale;
switch(m_alignType) {
case AlignType::xMinYMid:
case AlignType::xMidYMid:
case AlignType::xMaxYMid:
dstRect.y += (viewSize.h - dstRect.h) * 0.5f;
break;
case AlignType::xMinYMax:
case AlignType::xMidYMax:
case AlignType::xMaxYMax:
dstRect.y += viewSize.h - dstRect.h;
break;
default:
break;
}
}
if(viewSize.w > viewSize.h / scale) {
dstRect.w = viewSize.h / scale;
switch(m_alignType) {
case AlignType::xMidYMin:
case AlignType::xMidYMid:
case AlignType::xMidYMax:
dstRect.x += (viewSize.w - dstRect.w) * 0.5f;
break;
case AlignType::xMaxYMin:
case AlignType::xMaxYMid:
case AlignType::xMaxYMax:
dstRect.x += viewSize.w - dstRect.w;
break;
default:
break;
}
}
} else if(m_meetOrSlice == MeetOrSlice::Slice) {
auto scale = imageSize.h / imageSize.w;
if(viewSize.h < viewSize.w * scale) {
srcRect.h = viewSize.h * (imageSize.w / viewSize.w);
switch(m_alignType) {
case AlignType::xMinYMid:
case AlignType::xMidYMid:
case AlignType::xMaxYMid:
srcRect.y += (imageSize.h - srcRect.h) * 0.5f;
break;
case AlignType::xMinYMax:
case AlignType::xMidYMax:
case AlignType::xMaxYMax:
srcRect.y += imageSize.h - srcRect.h;
break;
default:
break;
}
}
if(viewSize.w < viewSize.h / scale) {
srcRect.w = viewSize.w * (imageSize.h / viewSize.h);
switch(m_alignType) {
case AlignType::xMidYMin:
case AlignType::xMidYMid:
case AlignType::xMidYMax:
srcRect.x += (imageSize.w - srcRect.w) * 0.5f;
break;
case AlignType::xMaxYMin:
case AlignType::xMaxYMid:
case AlignType::xMaxYMax:
srcRect.x += imageSize.w - srcRect.w;
break;
default:
break;
}
}
}
}
|
O1
|
cpp
|
lunasvg::SVGPreserveAspectRatio::transformRect(lunasvg::Rect&, lunasvg::Rect&) const:
movl 0xc(%rdi), %eax
testl %eax, %eax
je 0x20661
movss 0x8(%rsi), %xmm0
movss 0xc(%rsi), %xmm1
movss 0x8(%rdx), %xmm3
movss 0xc(%rdx), %xmm2
movl 0x10(%rdi), %ecx
cmpl $0x1, %ecx
je 0x20561
testl %ecx, %ecx
jne 0x20661
divss %xmm3, %xmm2
movaps %xmm0, %xmm3
mulss %xmm2, %xmm3
ucomiss %xmm3, %xmm1
jbe 0x205ba
movss %xmm3, 0xc(%rsi)
leal -0x7(%rax), %ecx
cmpl $0x3, %ecx
jb 0x205a9
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
ja 0x205ba
movaps %xmm1, %xmm4
subss %xmm3, %xmm4
mulss 0x232ed(%rip), %xmm4 # 0x4384c
jmp 0x205b0
movaps %xmm2, %xmm4
divss %xmm3, %xmm4
movaps %xmm0, %xmm5
mulss %xmm4, %xmm5
ucomiss %xmm1, %xmm5
jbe 0x20615
movaps %xmm3, %xmm5
divss %xmm0, %xmm5
mulss %xmm1, %xmm5
movss %xmm5, 0xc(%rdx)
leal -0x7(%rax), %ecx
cmpl $0x3, %ecx
jb 0x20604
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
ja 0x20615
movaps %xmm2, %xmm6
subss %xmm5, %xmm6
mulss 0x232a5(%rip), %xmm6 # 0x4384c
jmp 0x2060b
movaps %xmm1, %xmm4
subss %xmm3, %xmm4
addss 0x4(%rsi), %xmm4
movss %xmm4, 0x4(%rsi)
divss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x20661
movss %xmm1, 0x8(%rsi)
cmpl $0x9, %eax
ja 0x20661
movl $0x124, %ecx # imm = 0x124
btl %eax, %ecx
jb 0x205ef
movl $0x248, %ecx # imm = 0x248
btl %eax, %ecx
jae 0x20661
subss %xmm1, %xmm0
jmp 0x205fb
subss %xmm1, %xmm0
mulss 0x23251(%rip), %xmm0 # 0x4384c
addss (%rsi), %xmm0
movss %xmm0, (%rsi)
retq
movaps %xmm2, %xmm6
subss %xmm5, %xmm6
addss 0x4(%rdx), %xmm6
movss %xmm6, 0x4(%rdx)
movaps %xmm1, %xmm5
divss %xmm4, %xmm5
ucomiss %xmm0, %xmm5
jbe 0x20661
divss %xmm1, %xmm2
mulss %xmm2, %xmm0
movss %xmm0, 0x8(%rdx)
cmpl $0x9, %eax
ja 0x20661
movl $0x124, %ecx # imm = 0x124
btl %eax, %ecx
jb 0x2064d
movl $0x248, %ecx # imm = 0x248
btl %eax, %ecx
jae 0x20661
subss %xmm0, %xmm3
jmp 0x20659
subss %xmm0, %xmm3
mulss 0x231f3(%rip), %xmm3 # 0x4384c
addss (%rdx), %xmm3
movss %xmm3, (%rdx)
retq
|
_ZNK7lunasvg22SVGPreserveAspectRatio13transformRectERNS_4RectES2_:
mov eax, [rdi+0Ch]
test eax, eax
jz locret_20661
movss xmm0, dword ptr [rsi+8]
movss xmm1, dword ptr [rsi+0Ch]
movss xmm3, dword ptr [rdx+8]
movss xmm2, dword ptr [rdx+0Ch]
mov ecx, [rdi+10h]
cmp ecx, 1
jz short loc_20561
test ecx, ecx
jnz locret_20661
divss xmm2, xmm3
movaps xmm3, xmm0
mulss xmm3, xmm2
ucomiss xmm1, xmm3
jbe short loc_205BA
movss dword ptr [rsi+0Ch], xmm3
lea ecx, [rax-7]
cmp ecx, 3
jb short loc_205A9
lea ecx, [rax-4]
cmp ecx, 2
ja short loc_205BA
movaps xmm4, xmm1
subss xmm4, xmm3
mulss xmm4, cs:dword_4384C
jmp short loc_205B0
loc_20561:
movaps xmm4, xmm2
divss xmm4, xmm3
movaps xmm5, xmm0
mulss xmm5, xmm4
ucomiss xmm5, xmm1
jbe loc_20615
movaps xmm5, xmm3
divss xmm5, xmm0
mulss xmm5, xmm1
movss dword ptr [rdx+0Ch], xmm5
lea ecx, [rax-7]
cmp ecx, 3
jb short loc_20604
lea ecx, [rax-4]
cmp ecx, 2
ja short loc_20615
movaps xmm6, xmm2
subss xmm6, xmm5
mulss xmm6, cs:dword_4384C
jmp short loc_2060B
loc_205A9:
movaps xmm4, xmm1
subss xmm4, xmm3
loc_205B0:
addss xmm4, dword ptr [rsi+4]
movss dword ptr [rsi+4], xmm4
loc_205BA:
divss xmm1, xmm2
ucomiss xmm0, xmm1
jbe locret_20661
movss dword ptr [rsi+8], xmm1
cmp eax, 9
ja locret_20661
mov ecx, 124h
bt ecx, eax
jb short loc_205EF
mov ecx, 248h
bt ecx, eax
jnb short locret_20661
subss xmm0, xmm1
jmp short loc_205FB
loc_205EF:
subss xmm0, xmm1
mulss xmm0, cs:dword_4384C
loc_205FB:
addss xmm0, dword ptr [rsi]
movss dword ptr [rsi], xmm0
retn
loc_20604:
movaps xmm6, xmm2
subss xmm6, xmm5
loc_2060B:
addss xmm6, dword ptr [rdx+4]
movss dword ptr [rdx+4], xmm6
loc_20615:
movaps xmm5, xmm1
divss xmm5, xmm4
ucomiss xmm5, xmm0
jbe short locret_20661
divss xmm2, xmm1
mulss xmm0, xmm2
movss dword ptr [rdx+8], xmm0
cmp eax, 9
ja short locret_20661
mov ecx, 124h
bt ecx, eax
jb short loc_2064D
mov ecx, 248h
bt ecx, eax
jnb short locret_20661
subss xmm3, xmm0
jmp short loc_20659
loc_2064D:
subss xmm3, xmm0
mulss xmm3, cs:dword_4384C
loc_20659:
addss xmm3, dword ptr [rdx]
movss dword ptr [rdx], xmm3
locret_20661:
retn
|
long long lunasvg::SVGPreserveAspectRatio::transformRect(
lunasvg::SVGPreserveAspectRatio *this,
lunasvg::Rect *a2,
lunasvg::Rect *a3)
{
long long result; // rax
float v4; // xmm0_4
float v5; // xmm1_4
float v6; // xmm3_4
float v7; // xmm2_4
int v8; // ecx
float v9; // xmm2_4
float v10; // xmm3_4
float v11; // xmm4_4
float v12; // xmm5_4
float v13; // xmm6_4
float v14; // xmm1_4
int v15; // ecx
int v16; // ecx
float v17; // xmm0_4
float v18; // xmm0_4
int v19; // ecx
int v20; // ecx
float v21; // xmm3_4
result = *((unsigned int *)this + 3);
if ( !(_DWORD)result )
return result;
v4 = *((float *)a2 + 2);
v5 = *((float *)a2 + 3);
v6 = *((float *)a3 + 2);
v7 = *((float *)a3 + 3);
v8 = *((_DWORD *)this + 4);
if ( v8 != 1 )
{
if ( v8 )
return result;
v9 = v7 / v6;
v10 = v4 * v9;
if ( v5 > (float)(v4 * v9) )
{
*((float *)a2 + 3) = v10;
if ( (unsigned int)(result - 7) < 3 )
{
v11 = v5 - v10;
goto LABEL_13;
}
if ( (unsigned int)(result - 4) <= 2 )
{
v11 = (float)(v5 - v10) * 0.5;
LABEL_13:
*((float *)a2 + 1) = v11 + *((float *)a2 + 1);
}
}
v14 = v5 / v9;
if ( v4 > v14 )
{
*((float *)a2 + 2) = v14;
if ( (unsigned int)result <= 9 )
{
v15 = 292;
if ( _bittest(&v15, result) )
{
v17 = (float)(v4 - v14) * 0.5;
}
else
{
v16 = 584;
if ( !_bittest(&v16, result) )
return result;
v17 = v4 - v14;
}
*(float *)a2 = v17 + *(float *)a2;
}
}
return result;
}
if ( (float)(v4 * (float)(v7 / v6)) > v5 )
{
v12 = (float)(v6 / v4) * v5;
*((float *)a3 + 3) = v12;
if ( (unsigned int)(result - 7) < 3 )
{
v13 = v7 - v12;
goto LABEL_22;
}
if ( (unsigned int)(result - 4) <= 2 )
{
v13 = (float)(v7 - v12) * 0.5;
LABEL_22:
*((float *)a3 + 1) = v13 + *((float *)a3 + 1);
}
}
if ( (float)(v5 / (float)(v7 / v6)) > v4 )
{
v18 = v4 * (float)(v7 / v5);
*((float *)a3 + 2) = v18;
if ( (unsigned int)result <= 9 )
{
v19 = 292;
if ( _bittest(&v19, result) )
{
v21 = (float)(v6 - v18) * 0.5;
}
else
{
v20 = 584;
if ( !_bittest(&v20, result) )
return result;
v21 = v6 - v18;
}
*(float *)a3 = v21 + *(float *)a3;
}
}
return result;
}
|
transformRect:
MOV EAX,dword ptr [RDI + 0xc]
TEST EAX,EAX
JZ 0x00120661
MOVSS XMM0,dword ptr [RSI + 0x8]
MOVSS XMM1,dword ptr [RSI + 0xc]
MOVSS XMM3,dword ptr [RDX + 0x8]
MOVSS XMM2,dword ptr [RDX + 0xc]
MOV ECX,dword ptr [RDI + 0x10]
CMP ECX,0x1
JZ 0x00120561
TEST ECX,ECX
JNZ 0x00120661
DIVSS XMM2,XMM3
MOVAPS XMM3,XMM0
MULSS XMM3,XMM2
UCOMISS XMM1,XMM3
JBE 0x001205ba
MOVSS dword ptr [RSI + 0xc],XMM3
LEA ECX,[RAX + -0x7]
CMP ECX,0x3
JC 0x001205a9
LEA ECX,[RAX + -0x4]
CMP ECX,0x2
JA 0x001205ba
MOVAPS XMM4,XMM1
SUBSS XMM4,XMM3
MULSS XMM4,dword ptr [0x0014384c]
JMP 0x001205b0
LAB_00120561:
MOVAPS XMM4,XMM2
DIVSS XMM4,XMM3
MOVAPS XMM5,XMM0
MULSS XMM5,XMM4
UCOMISS XMM5,XMM1
JBE 0x00120615
MOVAPS XMM5,XMM3
DIVSS XMM5,XMM0
MULSS XMM5,XMM1
MOVSS dword ptr [RDX + 0xc],XMM5
LEA ECX,[RAX + -0x7]
CMP ECX,0x3
JC 0x00120604
LEA ECX,[RAX + -0x4]
CMP ECX,0x2
JA 0x00120615
MOVAPS XMM6,XMM2
SUBSS XMM6,XMM5
MULSS XMM6,dword ptr [0x0014384c]
JMP 0x0012060b
LAB_001205a9:
MOVAPS XMM4,XMM1
SUBSS XMM4,XMM3
LAB_001205b0:
ADDSS XMM4,dword ptr [RSI + 0x4]
MOVSS dword ptr [RSI + 0x4],XMM4
LAB_001205ba:
DIVSS XMM1,XMM2
UCOMISS XMM0,XMM1
JBE 0x00120661
MOVSS dword ptr [RSI + 0x8],XMM1
CMP EAX,0x9
JA 0x00120661
MOV ECX,0x124
BT ECX,EAX
JC 0x001205ef
MOV ECX,0x248
BT ECX,EAX
JNC 0x00120661
SUBSS XMM0,XMM1
JMP 0x001205fb
LAB_001205ef:
SUBSS XMM0,XMM1
MULSS XMM0,dword ptr [0x0014384c]
LAB_001205fb:
ADDSS XMM0,dword ptr [RSI]
MOVSS dword ptr [RSI],XMM0
RET
LAB_00120604:
MOVAPS XMM6,XMM2
SUBSS XMM6,XMM5
LAB_0012060b:
ADDSS XMM6,dword ptr [RDX + 0x4]
MOVSS dword ptr [RDX + 0x4],XMM6
LAB_00120615:
MOVAPS XMM5,XMM1
DIVSS XMM5,XMM4
UCOMISS XMM5,XMM0
JBE 0x00120661
DIVSS XMM2,XMM1
MULSS XMM0,XMM2
MOVSS dword ptr [RDX + 0x8],XMM0
CMP EAX,0x9
JA 0x00120661
MOV ECX,0x124
BT ECX,EAX
JC 0x0012064d
MOV ECX,0x248
BT ECX,EAX
JNC 0x00120661
SUBSS XMM3,XMM0
JMP 0x00120659
LAB_0012064d:
SUBSS XMM3,XMM0
MULSS XMM3,dword ptr [0x0014384c]
LAB_00120659:
ADDSS XMM3,dword ptr [RDX]
MOVSS dword ptr [RDX],XMM3
LAB_00120661:
RET
|
/* lunasvg::SVGPreserveAspectRatio::transformRect(lunasvg::Rect&, lunasvg::Rect&) const */
void __thiscall
lunasvg::SVGPreserveAspectRatio::transformRect
(SVGPreserveAspectRatio *this,Rect *param_1,Rect *param_2)
{
float fVar1;
uint uVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
uVar2 = *(uint *)(this + 0xc);
if (uVar2 == 0) {
return;
}
fVar3 = *(float *)(param_1 + 8);
fVar4 = *(float *)(param_1 + 0xc);
fVar6 = *(float *)(param_2 + 8);
fVar1 = *(float *)(param_2 + 0xc);
if (*(int *)(this + 0x10) != 1) {
if (*(int *)(this + 0x10) != 0) {
return;
}
fVar5 = fVar3 * (fVar1 / fVar6);
if (fVar5 < fVar4) {
*(float *)(param_1 + 0xc) = fVar5;
if (uVar2 - 7 < 3) {
fVar5 = fVar4 - fVar5;
}
else {
if (2 < uVar2 - 4) goto LAB_001205ba;
fVar5 = (fVar4 - fVar5) * DAT_0014384c;
}
*(float *)(param_1 + 4) = fVar5 + *(float *)(param_1 + 4);
}
LAB_001205ba:
fVar4 = fVar4 / (fVar1 / fVar6);
if (fVar3 <= fVar4) {
return;
}
*(float *)(param_1 + 8) = fVar4;
if (9 < uVar2) {
return;
}
if ((0x124U >> (uVar2 & 0x1f) & 1) == 0) {
if ((0x248U >> (uVar2 & 0x1f) & 1) == 0) {
return;
}
fVar3 = fVar3 - fVar4;
}
else {
fVar3 = (fVar3 - fVar4) * DAT_0014384c;
}
*(float *)param_1 = fVar3 + *(float *)param_1;
return;
}
if (fVar4 < fVar3 * (fVar1 / fVar6)) {
fVar5 = (fVar6 / fVar3) * fVar4;
*(float *)(param_2 + 0xc) = fVar5;
if (uVar2 - 7 < 3) {
fVar5 = fVar1 - fVar5;
}
else {
if (2 < uVar2 - 4) goto LAB_00120615;
fVar5 = (fVar1 - fVar5) * DAT_0014384c;
}
*(float *)(param_2 + 4) = fVar5 + *(float *)(param_2 + 4);
}
LAB_00120615:
if (fVar3 < fVar4 / (fVar1 / fVar6)) {
fVar3 = fVar3 * (fVar1 / fVar4);
*(float *)(param_2 + 8) = fVar3;
if (uVar2 < 10) {
if ((0x124U >> (uVar2 & 0x1f) & 1) == 0) {
if ((0x248U >> (uVar2 & 0x1f) & 1) == 0) {
return;
}
fVar6 = fVar6 - fVar3;
}
else {
fVar6 = (fVar6 - fVar3) * DAT_0014384c;
}
*(float *)param_2 = fVar6 + *(float *)param_2;
}
}
return;
}
|
|
64,703 |
get_length_arg
|
eloqsql/strings/my_vsnprintf.c
|
static const char *get_length_arg(const char *fmt, ARGS_INFO *args_arr,
size_t *arg_count, size_t *length, uint *flags)
{
fmt= get_length(fmt+1, length, flags);
*arg_count= MY_MAX(*arg_count, *length);
(*length)--;
DBUG_ASSERT(*fmt == '$' && *length < MAX_ARGS);
args_arr[*length].arg_type= 'd';
args_arr[*length].have_longlong= 0;
return fmt+1;
}
|
O0
|
c
|
get_length_arg:
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 %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7ab90
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x7c9a2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x7c9ad
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x7c9c8
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x64, (%rax)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
get_length_arg:
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 [rbp+var_28], r8
mov rdi, [rbp+var_8]
add rdi, 1
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call get_length
mov [rbp+var_8], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov rcx, [rbp+var_20]
cmp rax, [rcx]
jbe short loc_7C9A2
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_30], rax
jmp short loc_7C9AD
loc_7C9A2:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_30], rax
loc_7C9AD:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_20]
mov rcx, [rax]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax], rcx
jmp short $+2
loc_7C9C8:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
mov rcx, [rcx]
shl rcx, 5
add rax, rcx
mov byte ptr [rax], 64h ; 'd'
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
mov rcx, [rcx]
shl rcx, 5
add rax, rcx
mov dword ptr [rax+4], 0
mov rax, [rbp+var_8]
add rax, 1
add rsp, 30h
pop rbp
retn
|
unsigned __int8 * get_length_arg(long long a1, long long a2, long long *a3, long long *a4, _DWORD *a5)
{
long long v6; // [rsp+0h] [rbp-30h]
unsigned __int8 *length; // [rsp+28h] [rbp-8h]
length = get_length((unsigned __int8 *)(a1 + 1), a4, a5);
if ( *a3 <= (unsigned long long)*a4 )
v6 = *a4;
else
v6 = *a3;
*a3 = v6;
--*a4;
*(_BYTE *)(32 * *a4 + a2) = 100;
*(_DWORD *)(32 * *a4 + a2 + 4) = 0;
return length + 1;
}
|
get_length_arg:
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 qword ptr [RBP + -0x28],R8
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x1
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x0017ab90
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RCX]
JBE 0x0017c9a2
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0017c9ad
LAB_0017c9a2:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
LAB_0017c9ad:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
ADD RCX,-0x1
MOV qword ptr [RAX],RCX
JMP 0x0017c9c8
LAB_0017c9c8:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX]
SHL RCX,0x5
ADD RAX,RCX
MOV byte ptr [RAX],0x64
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX]
SHL RCX,0x5
ADD RAX,RCX
MOV dword ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
ADD RSP,0x30
POP RBP
RET
|
long get_length_arg(long param_1,long param_2,ulong *param_3,ulong *param_4,int8 param_5)
{
long lVar1;
int8 local_38;
lVar1 = get_length(param_1 + 1,param_4,param_5);
if (*param_4 < *param_3) {
local_38 = *param_3;
}
else {
local_38 = *param_4;
}
*param_3 = local_38;
*param_4 = *param_4 - 1;
*(int1 *)(param_2 + *param_4 * 0x20) = 100;
*(int4 *)(param_2 + *param_4 * 0x20 + 4) = 0;
return lVar1 + 1;
}
|
|
64,704 |
my_free_open_file_info
|
eloqsql/mysys/my_file.c
|
void my_free_open_file_info()
{
DBUG_ENTER("my_free_file_info");
if (my_file_info != my_file_info_default)
{
/* Copy data back for my_print_open_files */
memcpy((char*) my_file_info_default, my_file_info,
sizeof(*my_file_info_default)* MY_NFILE);
my_free(my_file_info);
my_file_info= my_file_info_default;
my_file_limit= MY_NFILE;
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_free_open_file_info:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2e7675(%rip), %r15 # 0x385b18
movq (%r15), %rbx
cmpq 0x2e5b13(%rip), %rbx # 0x383fc0
je 0x9e4de
leaq 0xb6986a(%rip), %r14 # 0xc07d20
movl $0x400, %edx # imm = 0x400
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29080
movq %rbx, %rdi
callq 0x9ff6e
movq %r14, (%r15)
leaq 0x2e7638(%rip), %rax # 0x385b10
movl $0x40, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
|
my_free_open_file_info:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
lea r15, my_file_info
mov rbx, [r15]
cmp rbx, cs:my_file_info_default_ptr
jz short loc_9E4DE
lea r14, my_file_info_default
mov edx, 400h
mov rdi, r14
mov rsi, rbx
call _memcpy
mov rdi, rbx
call my_free
mov [r15], r14
lea rax, my_file_limit
mov dword ptr [rax], 40h ; '@'
loc_9E4DE:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
_DWORD *my_free_open_file_info()
{
void *v0; // rbx
_DWORD *result; // rax
v0 = my_file_info;
if ( my_file_info != &my_file_info_default )
{
memcpy(&my_file_info_default, my_file_info, 1024LL);
my_free(v0);
my_file_info = &my_file_info_default;
result = my_file_limit;
my_file_limit[0] = 64;
}
return result;
}
|
my_free_open_file_info:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
LEA R15,[0x485b18]
MOV RBX,qword ptr [R15]
CMP RBX,qword ptr [0x00483fc0]
JZ 0x0019e4de
LEA R14,[0xd07d20]
MOV EDX,0x400
MOV RDI,R14
MOV RSI,RBX
CALL 0x00129080
MOV RDI,RBX
CALL 0x0019ff6e
MOV qword ptr [R15],R14
LEA RAX,[0x485b10]
MOV dword ptr [RAX],0x40
LAB_0019e4de:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void my_free_open_file_info(void)
{
int *puVar1;
puVar1 = my_file_info;
if (my_file_info != PTR_my_file_info_default_00483fc0) {
memcpy(my_file_info_default,my_file_info,0x400);
my_free(puVar1);
my_file_info = my_file_info_default;
my_file_limit = 0x40;
}
return;
}
|
|
64,705 |
mysql_real_query_cont
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_real_query_cont(int *ret, MYSQL *mysql, int ready_status)
{
MK_ASYNC_CONT_BODY(
mysql,
1,
r_int)
}
|
O3
|
c
|
mysql_real_query_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x480(%rsi), %rax
movq 0x28(%rax), %r15
cmpb $0x0, 0x15(%r15)
je 0x2986a
movb $0x1, 0x14(%r15)
movl %edx, 0x4(%r15)
leaq 0x38(%r15), %rdi
callq 0x2e28f
movb $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x298c5
movl (%r15), %r15d
jmp 0x2992f
movl $0x7de, 0x90(%r14) # imm = 0x7DE
leaq 0x297(%r14), %rdi
leaq 0x2129d(%rip), %rax # 0x4ab20
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r15d, %r15d
movb %r15b, 0x29c(%r14)
leaq 0x97(%r14), %rdi
leaq 0x21288(%rip), %rax # 0x4ab30
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movb %r15b, 0x296(%r14)
movl $0x1, (%rbx)
jmp 0x2992f
movb $0x0, 0x15(%r15)
js 0x298d2
movl 0x8(%r15), %eax
jmp 0x2992a
movl $0x7d8, 0x90(%r14) # imm = 0x7D8
leaq 0x297(%r14), %rdi
leaq 0x21235(%rip), %rax # 0x4ab20
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r15d, %r15d
movb %r15b, 0x29c(%r14)
leaq 0x97(%r14), %rdi
leaq 0x21220(%rip), %rax # 0x4ab30
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movb %r15b, 0x296(%r14)
movl $0x1, %eax
movl %eax, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
mysql_real_query_cont:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+480h]
mov r15, [rax+28h]
cmp byte ptr [r15+15h], 0
jz short loc_2986A
mov byte ptr [r15+14h], 1
mov [r15+4], edx
lea rdi, [r15+38h]
call my_context_continue
mov byte ptr [r15+14h], 0
test eax, eax
jle short loc_298C5
mov r15d, [r15]
jmp loc_2992F
loc_2986A:
mov dword ptr [r14+90h], 7DEh
lea rdi, [r14+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r15d, r15d
mov [r14+29Ch], r15b
lea rdi, [r14+97h]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov [r14+296h], r15b
mov dword ptr [rbx], 1
jmp short loc_2992F
loc_298C5:
mov byte ptr [r15+15h], 0
js short loc_298D2
mov eax, [r15+8]
jmp short loc_2992A
loc_298D2:
mov dword ptr [r14+90h], 7D8h
lea rdi, [r14+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r15d, r15d
mov [r14+29Ch], r15b
lea rdi, [r14+97h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov [r14+296h], r15b
mov eax, 1
loc_2992A:
mov [rbx], eax
xor r15d, r15d
loc_2992F:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long mysql_real_query_cont(int *a1, long long a2, unsigned int a3)
{
unsigned int *v3; // r15
int v4; // eax
unsigned int v5; // r15d
int v6; // eax
v3 = *(unsigned int **)(*(_QWORD *)(a2 + 1152) + 40LL);
if ( *((_BYTE *)v3 + 21) )
{
*((_BYTE *)v3 + 20) = 1;
v3[1] = a3;
v4 = my_context_continue(v3 + 14);
*((_BYTE *)v3 + 20) = 0;
if ( v4 <= 0 )
{
*((_BYTE *)v3 + 21) = 0;
if ( v4 < 0 )
{
*(_DWORD *)(a2 + 144) = 2008;
strncpy(a2 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a2 + 668) = 0;
strncpy(a2 + 151, client_errors[8], 511LL);
*(_BYTE *)(a2 + 662) = 0;
v6 = 1;
}
else
{
v6 = v3[2];
}
*a1 = v6;
return 0;
}
else
{
return *v3;
}
}
else
{
*(_DWORD *)(a2 + 144) = 2014;
strncpy(a2 + 663, SQLSTATE_UNKNOWN, 5LL);
v5 = 0;
*(_BYTE *)(a2 + 668) = 0;
strncpy(a2 + 151, client_errors[14], 511LL);
*(_BYTE *)(a2 + 662) = 0;
*a1 = 1;
}
return v5;
}
|
mysql_real_query_cont:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x480]
MOV R15,qword ptr [RAX + 0x28]
CMP byte ptr [R15 + 0x15],0x0
JZ 0x0012986a
MOV byte ptr [R15 + 0x14],0x1
MOV dword ptr [R15 + 0x4],EDX
LEA RDI,[R15 + 0x38]
CALL 0x0012e28f
MOV byte ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x001298c5
MOV R15D,dword ptr [R15]
JMP 0x0012992f
LAB_0012986a:
MOV dword ptr [R14 + 0x90],0x7de
LEA RDI,[R14 + 0x297]
LEA RAX,[0x14ab20]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R15D,R15D
MOV byte ptr [R14 + 0x29c],R15B
LEA RDI,[R14 + 0x97]
LEA RAX,[0x14ab30]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV byte ptr [R14 + 0x296],R15B
MOV dword ptr [RBX],0x1
JMP 0x0012992f
LAB_001298c5:
MOV byte ptr [R15 + 0x15],0x0
JS 0x001298d2
MOV EAX,dword ptr [R15 + 0x8]
JMP 0x0012992a
LAB_001298d2:
MOV dword ptr [R14 + 0x90],0x7d8
LEA RDI,[R14 + 0x297]
LEA RAX,[0x14ab20]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R15D,R15D
MOV byte ptr [R14 + 0x29c],R15B
LEA RDI,[R14 + 0x97]
LEA RAX,[0x14ab30]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV byte ptr [R14 + 0x296],R15B
MOV EAX,0x1
LAB_0012992a:
MOV dword ptr [RBX],EAX
XOR R15D,R15D
LAB_0012992f:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_real_query_cont(int4 *param_1,long param_2,int4 param_3)
{
int4 *puVar1;
int iVar2;
int4 uVar3;
puVar1 = *(int4 **)(*(long *)(param_2 + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(param_2 + 0x90) = 0x7de;
strncpy((char *)(param_2 + 0x297),SQLSTATE_UNKNOWN,5);
uVar3 = 0;
*(int1 *)(param_2 + 0x29c) = 0;
strncpy((char *)(param_2 + 0x97),PTR_s_Commands_out_of_sync__you_can_t_r_0014aba0,0x1ff);
*(int1 *)(param_2 + 0x296) = 0;
*param_1 = 1;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_3;
iVar2 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (iVar2 < 1) {
*(int1 *)((long)puVar1 + 0x15) = 0;
if (iVar2 < 0) {
*(int4 *)(param_2 + 0x90) = 0x7d8;
strncpy((char *)(param_2 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_2 + 0x29c) = 0;
strncpy((char *)(param_2 + 0x97),PTR_s_Client_run_out_of_memory_0014ab70,0x1ff);
*(int1 *)(param_2 + 0x296) = 0;
uVar3 = 1;
}
else {
uVar3 = puVar1[2];
}
*param_1 = uVar3;
uVar3 = 0;
}
else {
uVar3 = *puVar1;
}
}
return uVar3;
}
|
|
64,706 |
cpu_autograd_broadcast_Test::cpu_autograd_broadcast_Test()
|
magnetron/test/unittests/tensor/autograd.cpp
|
TEST(cpu_autograd, broadcast) {
context ctx {compute_device::cpu};
tensor x {ctx, dtype::e8m23, 3, 3, 3, 3};
x.fill(3.0f);
tensor y {ctx, dtype::e8m23, 3, 3, };
y.fill(2.0f);
tensor k {ctx, dtype::e8m23, 1};
k.fill(10.0f);
tensor z {((x + y)*(x - y)/k).sum()};
z.backward();
ASSERT_TRUE(x.grad().has_value());
ASSERT_TRUE(y.grad().has_value());
ASSERT_TRUE(k.grad().has_value());
ASSERT_TRUE(z.grad().has_value());
// check forward pass
for (std::int64_t i {}; i < x.numel(); ++i) {
ASSERT_FLOAT_EQ(x(0), 3.0f);
}
for (std::int64_t i {}; i < y.numel(); ++i) {
ASSERT_FLOAT_EQ(y(0), 2.0f);
}
for (std::int64_t i {}; i < z.numel(); ++i) {
ASSERT_FLOAT_EQ(z(0), 40.5f);
}
// check backward pass
auto x_grad {x.grad().value()};
for (std::int64_t i {}; i < x_grad.numel(); ++i) { // ∂z/∂x = 0.6
ASSERT_FLOAT_EQ(x_grad(i), 0.6f);
}
auto y_grad {y.grad().value()};
for (std::int64_t i {}; i < y_grad.numel(); ++i) { // ∂z/∂x = -3.6f
ASSERT_FLOAT_EQ(y_grad(i), -3.6f);
}
auto z_grad {z.grad().value()};
for (std::int64_t i {}; i < z_grad.numel(); ++i) { // ∂z/∂x = 1
ASSERT_FLOAT_EQ(z_grad(i), 1.0f);
}
}
|
O0
|
cpp
|
cpu_autograd_broadcast_Test::cpu_autograd_broadcast_Test():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x9ed60
movq -0x10(%rbp), %rax
leaq 0xfd204(%rip), %rcx # 0x1334d8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
_ZN27cpu_autograd_broadcast_TestC2Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_10], rdi
call _ZN7testing4TestC2Ev; testing::Test::Test(void)
mov rax, [rbp+var_10]
lea rcx, _ZTV27cpu_autograd_broadcast_Test; `vtable for'cpu_autograd_broadcast_Test
add rcx, 10h
mov [rax], rcx
add rsp, 10h
pop rbp
retn
|
void cpu_autograd_broadcast_Test::cpu_autograd_broadcast_Test(cpu_autograd_broadcast_Test *this)
{
testing::Test::Test(this);
*(_QWORD *)this = &`vtable for'cpu_autograd_broadcast_Test + 2;
}
|
cpu_autograd_broadcast_Test:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RDI
CALL 0x0019ed60
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x2334d8]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x10
POP RBP
RET
|
/* cpu_autograd_broadcast_Test::cpu_autograd_broadcast_Test() */
void __thiscall
cpu_autograd_broadcast_Test::cpu_autograd_broadcast_Test(cpu_autograd_broadcast_Test *this)
{
testing::Test::Test((Test *)this);
*(int ***)this = &PTR__cpu_autograd_broadcast_Test_002334e8;
return;
}
|
|
64,707 |
pfs_start_file_wait_v1
|
eloqsql/storage/perfschema/pfs.cc
|
void pfs_start_file_wait_v1(PSI_file_locker *locker,
size_t count,
const char *src_file,
uint src_line)
{
ulonglong timer_start= 0;
PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
assert(state != NULL);
uint flags= state->m_flags;
if (flags & STATE_FLAG_TIMED)
{
timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
state->m_timer_start= timer_start;
}
if (flags & STATE_FLAG_EVENT)
{
PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
assert(wait != NULL);
wait->m_timer_start= timer_start;
wait->m_source_file= src_file;
wait->m_source_line= src_line;
wait->m_number_of_bytes= count;
}
}
|
O0
|
cpp
|
pfs_start_file_wait_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x495b1
leaq 0x1c9e2a(%rip), %rax # 0x2133bc
movl (%rax), %edi
movq -0x30(%rbp), %rsi
addq $0x38, %rsi
callq 0x42d20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x34(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x495f9
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x1c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x98(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
|
pfs_start_file_wait_v1:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], 0
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov eax, [rax]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
and eax, 1
cmp eax, 0
jz short loc_495B1
lea rax, wait_timer
mov edi, [rax]
mov rsi, [rbp+var_30]
add rsi, 38h ; '8'
call _Z32get_timer_raw_value_and_function15enum_timer_namePPFyvE; get_timer_raw_value_and_function(enum_timer_name,ulong long (**)(void))
mov [rbp+var_28], rax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_30]
mov [rax+30h], rcx
loc_495B1:
mov eax, [rbp+var_34]
and eax, 4
cmp eax, 0
jz short loc_495F9
mov rax, [rbp+var_30]
mov rax, [rax+40h]
mov [rbp+var_40], rax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_40]
mov [rax+38h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_40]
mov [rax+48h], rcx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_40]
mov [rax+50h], ecx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_40]
mov [rax+98h], rcx
loc_495F9:
add rsp, 40h
pop rbp
retn
|
long long pfs_start_file_wait_v1(int *a1, long long a2, long long a3, int a4)
{
long long result; // rax
long long v5; // [rsp+0h] [rbp-40h]
int v6; // [rsp+Ch] [rbp-34h]
unsigned long long timer_raw_value_and_function; // [rsp+18h] [rbp-28h]
timer_raw_value_and_function = 0LL;
v6 = *a1;
if ( (*a1 & 1) != 0 )
{
timer_raw_value_and_function = get_timer_raw_value_and_function(
(unsigned int)wait_timer,
(unsigned long long (**)(void))a1 + 7);
*((_QWORD *)a1 + 6) = timer_raw_value_and_function;
}
result = v6 & 4;
if ( (v6 & 4) != 0 )
{
v5 = *((_QWORD *)a1 + 8);
*(_QWORD *)(v5 + 56) = timer_raw_value_and_function;
*(_QWORD *)(v5 + 72) = a3;
*(_DWORD *)(v5 + 80) = a4;
result = v5;
*(_QWORD *)(v5 + 152) = a2;
}
return result;
}
|
pfs_start_file_wait_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001495b1
LEA RAX,[0x3133bc]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x30]
ADD RSI,0x38
CALL 0x00142d20
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x30],RCX
LAB_001495b1:
MOV EAX,dword ptr [RBP + -0x34]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001495f9
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x48],RCX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x50],ECX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x98],RCX
LAB_001495f9:
ADD RSP,0x40
POP RBP
RET
|
void pfs_start_file_wait_v1(uint *param_1,int8 param_2,int8 param_3,int4 param_4)
{
uint uVar1;
long lVar2;
int8 local_30;
local_30 = 0;
uVar1 = *param_1;
if ((uVar1 & 1) != 0) {
local_30 = get_timer_raw_value_and_function(wait_timer,param_1 + 0xe);
*(int8 *)(param_1 + 0xc) = local_30;
}
if ((uVar1 & 4) != 0) {
lVar2 = *(long *)(param_1 + 0x10);
*(int8 *)(lVar2 + 0x38) = local_30;
*(int8 *)(lVar2 + 0x48) = param_3;
*(int4 *)(lVar2 + 0x50) = param_4;
*(int8 *)(lVar2 + 0x98) = param_2;
}
return;
}
|
|
64,708 |
my_b_cache_write
|
eloqsql/mysys/mf_iocache.c
|
int _my_b_cache_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
if (Buffer != info->write_buffer)
{
Count= IO_ROUND_DN(Count);
if (!Count)
return 0;
}
if (info->seek_not_done)
{
/*
Whenever a function which operates on IO_CACHE flushes/writes
some part of the IO_CACHE to disk it will set the property
"seek_not_done" to indicate this to other functions operating
on the IO_CACHE.
*/
if (mysql_file_seek(info->file, info->pos_in_file, MY_SEEK_SET,
MYF(info->myflags & MY_WME)) == MY_FILEPOS_ERROR)
{
info->error= -1;
return 1;
}
info->seek_not_done=0;
}
if (mysql_file_write(info->file, Buffer, Count, info->myflags | MY_NABP))
return info->error= -1;
info->pos_in_file+= Count;
return 0;
}
|
O3
|
c
|
my_b_cache_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rsi, 0x30(%rdi)
je 0x9bc98
movl $0xfffff000, %eax # imm = 0xFFFFF000
andq %rax, %rdx
je 0x9bd6b
movq %rdx, -0x30(%rbp)
cmpl $0x0, 0xe0(%rbx)
je 0x9bd07
movl 0xd4(%rbx), %r13d
movq (%rbx), %rax
movq %rax, -0x38(%rbp)
movq 0xf8(%rbx), %r12
andl $0x10, %r12d
leaq 0x2f5213(%rip), %rax # 0x390ed8
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
movl %r13d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x9bdec
movl %r13d, %edi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0xa7e58
movq %rax, %r12
cmpq $-0x1, %r12
je 0x9bd6f
movl $0x0, 0xe0(%rbx)
movl 0xd4(%rbx), %r13d
movq 0xf8(%rbx), %r12
orq $0x4, %r12
leaq 0x2f51b8(%rip), %rax # 0x390ed8
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
movl %r13d, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x9bd8d
movl %r13d, %edi
movq %r15, %rsi
movq -0x30(%rbp), %r13
movq %r13, %rdx
movq %r12, %rcx
callq 0x303a4
movq %rax, %r15
testq %r15, %r15
je 0x9bd68
movl $0xffffffff, 0xe4(%rbx) # imm = 0xFFFFFFFF
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x9bd7e
addq %r13, (%rbx)
xorl %eax, %eax
jmp 0x9bd7e
movl $0xffffffff, 0xe4(%rbx) # imm = 0xFFFFFFFF
movl $0x1, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x2f5141(%rip), %rax # 0x390ed8
movq (%rax), %rax
leaq 0x48baa(%rip), %rdx # 0xe494b
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movl $0x5f6, %ecx # imm = 0x5F6
callq *0x210(%rax)
movl %r13d, %edi
movq -0x30(%rbp), %r13
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x303a4
movq %rax, %r15
xorl %esi, %esi
testq %rax, %rax
cmoveq %r13, %rsi
leaq 0x2f50fd(%rip), %rax # 0x390ed8
movq (%rax), %rax
movq %r14, %rdi
callq *0x218(%rax)
jmp 0x9bd52
movq %rax, %r14
leaq 0x2f50e2(%rip), %rax # 0x390ed8
movq (%rax), %rax
leaq 0x48b4b(%rip), %rdx # 0xe494b
movq %r14, %rdi
xorl %esi, %esi
movl $0x5ef, %ecx # imm = 0x5EF
callq *0x210(%rax)
movl %r13d, %edi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0xa7e58
movq %rax, %r12
leaq 0x2f50ad(%rip), %rax # 0x390ed8
movq (%rax), %rax
movq %r14, %rdi
xorl %esi, %esi
callq *0x218(%rax)
jmp 0x9bcf7
|
_my_b_cache_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rsi
mov rbx, rdi
cmp [rdi+30h], rsi
jz short loc_9BC98
mov eax, 0FFFFF000h
and rdx, rax
jz loc_9BD6B
loc_9BC98:
mov [rbp+var_30], rdx
cmp dword ptr [rbx+0E0h], 0
jz short loc_9BD07
mov r13d, [rbx+0D4h]
mov rax, [rbx]
mov [rbp+var_38], rax
mov r12, [rbx+0F8h]
and r12d, 10h
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_80]
mov esi, r13d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_9BDEC
mov edi, r13d
mov rsi, [rbp+var_38]
xor edx, edx
mov rcx, r12
call my_seek
mov r12, rax
loc_9BCF7:
cmp r12, 0FFFFFFFFFFFFFFFFh
jz short loc_9BD6F
mov dword ptr [rbx+0E0h], 0
loc_9BD07:
mov r13d, [rbx+0D4h]
mov r12, [rbx+0F8h]
or r12, 4
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_80]
mov esi, r13d
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz short loc_9BD8D
mov edi, r13d
mov rsi, r15
mov r13, [rbp+var_30]
mov rdx, r13
mov rcx, r12
call my_write
mov r15, rax
loc_9BD52:
test r15, r15
jz short loc_9BD68
mov dword ptr [rbx+0E4h], 0FFFFFFFFh
mov eax, 0FFFFFFFFh
jmp short loc_9BD7E
loc_9BD68:
add [rbx], r13
loc_9BD6B:
xor eax, eax
jmp short loc_9BD7E
loc_9BD6F:
mov dword ptr [rbx+0E4h], 0FFFFFFFFh
mov eax, 1
loc_9BD7E:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9BD8D:
mov r14, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov rsi, [rbp+var_30]
mov ecx, 5F6h
call qword ptr [rax+210h]
mov edi, r13d
mov r13, [rbp+var_30]
mov rsi, r15
mov rdx, r13
mov rcx, r12
call my_write
mov r15, rax
xor esi, esi
test rax, rax
cmovz rsi, r13
lea rax, PSI_server
mov rax, [rax]
mov rdi, r14
call qword ptr [rax+218h]
jmp loc_9BD52
loc_9BDEC:
mov r14, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
xor esi, esi
mov ecx, 5EFh
call qword ptr [rax+210h]
mov edi, r13d
mov rsi, [rbp+var_38]
xor edx, edx
mov rcx, r12
call my_seek
mov r12, rax
lea rax, PSI_server
mov rax, [rax]
mov rdi, r14
xor esi, esi
call qword ptr [rax+218h]
jmp loc_9BCF7
|
long long my_b_cache_write(long long *a1, long long a2, long long a3)
{
unsigned int v4; // r13d
long long v5; // r12
long long v6; // rax
long long v7; // r12
unsigned int v8; // r13d
long long v9; // r12
long long v10; // rax
unsigned int v11; // edi
long long v12; // r13
long long v13; // r15
long long v15; // r14
unsigned int v16; // edi
long long v17; // rsi
long long v18; // r14
_BYTE v19[72]; // [rsp+0h] [rbp-80h] BYREF
long long v20; // [rsp+48h] [rbp-38h]
long long v21; // [rsp+50h] [rbp-30h]
if ( a1[6] != a2 )
{
a3 = (unsigned int)a3 & 0xFFFFF000;
if ( !a3 )
return 0LL;
}
v21 = a3;
if ( !*((_DWORD *)a1 + 56) )
{
LABEL_8:
v8 = *((_DWORD *)a1 + 53);
v9 = a1[31] | 4;
v10 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v19, v8, 7LL);
if ( v10 )
{
v15 = v10;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v10,
v21,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1526LL);
v16 = v8;
v12 = v21;
v13 = my_write(v16, a2, v21, v9);
v17 = 0LL;
if ( !v13 )
v17 = v12;
((void ( *)(long long, long long))PSI_server[67])(v15, v17);
}
else
{
v11 = v8;
v12 = v21;
v13 = my_write(v11, a2, v21, v9);
}
if ( v13 )
{
*((_DWORD *)a1 + 57) = -1;
return 0xFFFFFFFFLL;
}
*a1 += v12;
return 0LL;
}
v4 = *((_DWORD *)a1 + 53);
v20 = *a1;
v5 = a1[31] & 0x10;
v6 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v19, v4, 8LL);
if ( v6 )
{
v18 = v6;
((void ( *)(long long, _QWORD, const char *, long long))PSI_server[66])(
v6,
0LL,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1519LL);
v7 = my_seek(v4, v20, 0LL, v5);
((void ( *)(long long, _QWORD))PSI_server[67])(v18, 0LL);
}
else
{
v7 = my_seek(v4, v20, 0LL, v5);
}
if ( v7 != -1 )
{
*((_DWORD *)a1 + 56) = 0;
goto LABEL_8;
}
*((_DWORD *)a1 + 57) = -1;
return 1LL;
}
|
_my_b_cache_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RSI
MOV RBX,RDI
CMP qword ptr [RDI + 0x30],RSI
JZ 0x0019bc98
MOV EAX,0xfffff000
AND RDX,RAX
JZ 0x0019bd6b
LAB_0019bc98:
MOV qword ptr [RBP + -0x30],RDX
CMP dword ptr [RBX + 0xe0],0x0
JZ 0x0019bd07
MOV R13D,dword ptr [RBX + 0xd4]
MOV RAX,qword ptr [RBX]
MOV qword ptr [RBP + -0x38],RAX
MOV R12,qword ptr [RBX + 0xf8]
AND R12D,0x10
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x80]
MOV ESI,R13D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0019bdec
MOV EDI,R13D
MOV RSI,qword ptr [RBP + -0x38]
XOR EDX,EDX
MOV RCX,R12
CALL 0x001a7e58
MOV R12,RAX
LAB_0019bcf7:
CMP R12,-0x1
JZ 0x0019bd6f
MOV dword ptr [RBX + 0xe0],0x0
LAB_0019bd07:
MOV R13D,dword ptr [RBX + 0xd4]
MOV R12,qword ptr [RBX + 0xf8]
OR R12,0x4
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x80]
MOV ESI,R13D
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0019bd8d
MOV EDI,R13D
MOV RSI,R15
MOV R13,qword ptr [RBP + -0x30]
MOV RDX,R13
MOV RCX,R12
CALL 0x001303a4
MOV R15,RAX
LAB_0019bd52:
TEST R15,R15
JZ 0x0019bd68
MOV dword ptr [RBX + 0xe4],0xffffffff
MOV EAX,0xffffffff
JMP 0x0019bd7e
LAB_0019bd68:
ADD qword ptr [RBX],R13
LAB_0019bd6b:
XOR EAX,EAX
JMP 0x0019bd7e
LAB_0019bd6f:
MOV dword ptr [RBX + 0xe4],0xffffffff
MOV EAX,0x1
LAB_0019bd7e:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019bd8d:
MOV R14,RAX
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1e494b]
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x30]
MOV ECX,0x5f6
CALL qword ptr [RAX + 0x210]
MOV EDI,R13D
MOV R13,qword ptr [RBP + -0x30]
MOV RSI,R15
MOV RDX,R13
MOV RCX,R12
CALL 0x001303a4
MOV R15,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,R13
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
MOV RDI,R14
CALL qword ptr [RAX + 0x218]
JMP 0x0019bd52
LAB_0019bdec:
MOV R14,RAX
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1e494b]
MOV RDI,R14
XOR ESI,ESI
MOV ECX,0x5ef
CALL qword ptr [RAX + 0x210]
MOV EDI,R13D
MOV RSI,qword ptr [RBP + -0x38]
XOR EDX,EDX
MOV RCX,R12
CALL 0x001a7e58
MOV R12,RAX
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
MOV RDI,R14
XOR ESI,ESI
CALL qword ptr [RAX + 0x218]
JMP 0x0019bcf7
|
int8 _my_b_cache_write(long *param_1,long param_2,ulong param_3)
{
int4 uVar1;
long lVar2;
long lVar3;
ulong uVar4;
uint uVar5;
ulong uVar6;
int1 local_88 [72];
long local_40;
ulong local_38;
if ((param_1[6] == param_2) || (param_3 = param_3 & 0xfffff000, param_3 != 0)) {
local_38 = param_3;
if ((int)param_1[0x1c] != 0) {
uVar1 = *(int4 *)((long)param_1 + 0xd4);
local_40 = *param_1;
uVar5 = (uint)param_1[0x1f] & 0x10;
lVar2 = (**(code **)(PSI_server + 0x158))(local_88,uVar1,8);
if (lVar2 == 0) {
lVar3 = my_seek(uVar1,local_40,0,uVar5);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar2,0,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x5ef);
lVar3 = my_seek(uVar1,local_40,0,uVar5);
(**(code **)(PSI_server + 0x218))(lVar2,0);
}
if (lVar3 == -1) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
return 1;
}
*(int4 *)(param_1 + 0x1c) = 0;
}
uVar1 = *(int4 *)((long)param_1 + 0xd4);
uVar4 = param_1[0x1f];
lVar2 = (**(code **)(PSI_server + 0x158))(local_88,uVar1,7);
uVar6 = local_38;
if (lVar2 == 0) {
lVar3 = my_write(uVar1,param_2,local_38,uVar4 | 4);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar2,local_38,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x5f6)
;
uVar6 = local_38;
lVar3 = my_write(uVar1,param_2,local_38,uVar4 | 4);
uVar4 = 0;
if (lVar3 == 0) {
uVar4 = uVar6;
}
(**(code **)(PSI_server + 0x218))(lVar2,uVar4);
}
if (lVar3 != 0) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
return 0xffffffff;
}
*param_1 = *param_1 + uVar6;
}
return 0;
}
|
|
64,709 |
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/json.hpp
|
T& operator[](const key_type& key)
{
return emplace(key, T{}).first->second;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movb $0x0, (%r15)
movq $0x0, 0x8(%r15)
movq %r15, %rdi
movl $0x1, %esi
callq 0x3d7c0
movq %r15, %rdi
movl $0x1, %esi
callq 0x3d7c0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4a452
movq %rax, %rbx
addq $0x20, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3d7c0
movq %r14, %rdi
callq 0x4a3ae
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3d7c0
movq %r14, %rdi
callq 0x4a3ae
movq %rbx, %rdi
callq 0x18b90
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rsi
mov r14, rdi
mov r15, rsp
mov byte ptr [r15], 0
mov qword ptr [r15+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 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 rdi, r14
mov rsi, rbx
mov rdx, r15
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rbx, rax
add rbx, 20h ; ' '
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator[](
long long a1,
long long a2)
{
long long v2; // rbx
char v4[8]; // [rsp+0h] [rbp-28h] BYREF
long long v5; // [rsp+8h] [rbp-20h]
v4[0] = 0;
v5 = 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(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(v4);
v2 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
a1,
a2,
v4)
+ 32;
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(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>::data::~data(v4);
return v2;
}
|
operator[]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV R14,RDI
MOV R15,RSP
MOV byte ptr [R15],0x0
MOV qword ptr [R15 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0013d7c0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0013d7c0
LAB_0014a356:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x0014a452
LAB_0014a364:
MOV RBX,RAX
ADD RBX,0x20
MOV R14,RSP
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013d7c0
MOV RDI,R14
CALL 0x0014a3ae
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > >::operator[](std::__cxx11::string const&) */
long __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this,string *param_1)
{
long lVar1;
bool bVar2;
basic_json local_28 [8];
int8 local_20;
local_28[0] = (basic_json)0x0;
local_20 = 0;
bVar2 = SUB81(local_28,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar2);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar2);
/* try { // try from 0014a356 to 0014a363 has its CatchHandler @ 0014a38d */
lVar1 = emplace(this,param_1,local_28);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar2);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_28);
return lVar1 + 0x20;
}
|
|
64,710 |
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>>>>>::scan_string()
|
llama.cpp/common/json.hpp
|
token_type scan_string()
{
// reset token_buffer (ignore opening quote)
reset();
// we entered the function by reading an open quote
JSON_ASSERT(current == '\"');
while (true)
{
// get next character
switch (get())
{
// end of file while parsing string
case char_traits<char_type>::eof():
{
error_message = "invalid string: missing closing quote";
return token_type::parse_error;
}
// closing quote
case '\"':
{
return token_type::value_string;
}
// escapes
case '\\':
{
switch (get())
{
// quotation mark
case '\"':
add('\"');
break;
// reverse solidus
case '\\':
add('\\');
break;
// solidus
case '/':
add('/');
break;
// backspace
case 'b':
add('\b');
break;
// form feed
case 'f':
add('\f');
break;
// line feed
case 'n':
add('\n');
break;
// carriage return
case 'r':
add('\r');
break;
// tab
case 't':
add('\t');
break;
// unicode escapes
case 'u':
{
const int codepoint1 = get_codepoint();
int codepoint = codepoint1; // start with codepoint1
if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if code point is a high surrogate
if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
{
// expect next \uxxxx entry
if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
{
const int codepoint2 = get_codepoint();
if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if codepoint2 is a low surrogate
if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
{
// overwrite codepoint
codepoint = static_cast<int>(
// high surrogate occupies the most significant 22 bits
(static_cast<unsigned int>(codepoint1) << 10u)
// low surrogate occupies the least significant 15 bits
+ static_cast<unsigned int>(codepoint2)
// there is still the 0xD800, 0xDC00 and 0x10000 noise
// in the result, so we have to subtract with:
// (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
- 0x35FDC00u);
}
else
{
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
return token_type::parse_error;
}
}
else
{
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
return token_type::parse_error;
}
}
else
{
if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
{
error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
return token_type::parse_error;
}
}
// result of the above calculation yields a proper codepoint
JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
// translate codepoint into bytes
if (codepoint < 0x80)
{
// 1-byte characters: 0xxxxxxx (ASCII)
add(static_cast<char_int_type>(codepoint));
}
else if (codepoint <= 0x7FF)
{
// 2-byte characters: 110xxxxx 10xxxxxx
add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else if (codepoint <= 0xFFFF)
{
// 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else
{
// 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
break;
}
// other characters after escape
default:
error_message = "invalid string: forbidden character after backslash";
return token_type::parse_error;
}
break;
}
// invalid control characters
case 0x00:
{
error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
return token_type::parse_error;
}
case 0x01:
{
error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
return token_type::parse_error;
}
case 0x02:
{
error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
return token_type::parse_error;
}
case 0x03:
{
error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
return token_type::parse_error;
}
case 0x04:
{
error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
return token_type::parse_error;
}
case 0x05:
{
error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
return token_type::parse_error;
}
case 0x06:
{
error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
return token_type::parse_error;
}
case 0x07:
{
error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
return token_type::parse_error;
}
case 0x08:
{
error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
return token_type::parse_error;
}
case 0x09:
{
error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
return token_type::parse_error;
}
case 0x0A:
{
error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
return token_type::parse_error;
}
case 0x0B:
{
error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
return token_type::parse_error;
}
case 0x0C:
{
error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
return token_type::parse_error;
}
case 0x0D:
{
error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
return token_type::parse_error;
}
case 0x0E:
{
error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
return token_type::parse_error;
}
case 0x0F:
{
error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
return token_type::parse_error;
}
case 0x10:
{
error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
return token_type::parse_error;
}
case 0x11:
{
error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
return token_type::parse_error;
}
case 0x12:
{
error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
return token_type::parse_error;
}
case 0x13:
{
error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
return token_type::parse_error;
}
case 0x14:
{
error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
return token_type::parse_error;
}
case 0x15:
{
error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
return token_type::parse_error;
}
case 0x16:
{
error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
return token_type::parse_error;
}
case 0x17:
{
error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
return token_type::parse_error;
}
case 0x18:
{
error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
return token_type::parse_error;
}
case 0x19:
{
error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
return token_type::parse_error;
}
case 0x1A:
{
error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
return token_type::parse_error;
}
case 0x1B:
{
error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
return token_type::parse_error;
}
case 0x1C:
{
error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
return token_type::parse_error;
}
case 0x1D:
{
error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
return token_type::parse_error;
}
case 0x1E:
{
error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
return token_type::parse_error;
}
case 0x1F:
{
error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
return token_type::parse_error;
}
// U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
case 0x20:
case 0x21:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2A:
case 0x2B:
case 0x2C:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3C:
case 0x3D:
case 0x3E:
case 0x3F:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4A:
case 0x4B:
case 0x4C:
case 0x4D:
case 0x4E:
case 0x4F:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5A:
case 0x5B:
case 0x5D:
case 0x5E:
case 0x5F:
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6A:
case 0x6B:
case 0x6C:
case 0x6D:
case 0x6E:
case 0x6F:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7A:
case 0x7B:
case 0x7C:
case 0x7D:
case 0x7E:
case 0x7F:
{
add(current);
break;
}
// U+0080..U+07FF: bytes C2..DF 80..BF
case 0xC2:
case 0xC3:
case 0xC4:
case 0xC5:
case 0xC6:
case 0xC7:
case 0xC8:
case 0xC9:
case 0xCA:
case 0xCB:
case 0xCC:
case 0xCD:
case 0xCE:
case 0xCF:
case 0xD0:
case 0xD1:
case 0xD2:
case 0xD3:
case 0xD4:
case 0xD5:
case 0xD6:
case 0xD7:
case 0xD8:
case 0xD9:
case 0xDA:
case 0xDB:
case 0xDC:
case 0xDD:
case 0xDE:
case 0xDF:
{
if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
{
return token_type::parse_error;
}
break;
}
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF
case 0xE0:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
// U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
case 0xE1:
case 0xE2:
case 0xE3:
case 0xE4:
case 0xE5:
case 0xE6:
case 0xE7:
case 0xE8:
case 0xE9:
case 0xEA:
case 0xEB:
case 0xEC:
case 0xEE:
case 0xEF:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+D000..U+D7FF: bytes ED 80..9F 80..BF
case 0xED:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
case 0xF0:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
case 0xF1:
case 0xF2:
case 0xF3:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
case 0xF4:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// remaining bytes (80..C1 and F5..FF) are ill-formed
default:
{
error_message = "invalid string: ill-formed UTF-8 byte";
return token_type::parse_error;
}
}
}
}
|
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>>>>>::scan_string():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x95f6c
cmpl $0x22, 0x14(%rbx)
jne 0x95b65
leaq 0x50(%rbx), %r14
leaq 0x872b8(%rip), %r12 # 0x11ca13
leaq 0x89762(%rip), %r13 # 0x11eec4
movq %rbx, %rdi
callq 0x22d18
incl %eax
cmpl $0xf5, %eax
ja 0x95b34
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movabsq $0xbf00000080, %rax # imm = 0xBF00000080
movq %rsp, %rsi
movq %rax, (%rsi)
movl $0x2, %edx
jmp 0x95802
movaps 0x849d1(%rip), %xmm0 # 0x11a170
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x4, %edx
jmp 0x95802
movb 0x14(%rbx), %r15b
movsbl %r15b, %esi
movq %r14, %rdi
callq 0x22400
jmp 0x95762
movups 0x9181b(%rip), %xmm0 # 0x126fe0
jmp 0x957e9
movaps 0x84992(%rip), %xmm0 # 0x11a160
jmp 0x9579f
movaps 0x849a9(%rip), %xmm0 # 0x11a180
jmp 0x9579f
movups 0x91818(%rip), %xmm0 # 0x126ff8
jmp 0x957e9
movups 0x917df(%rip), %xmm0 # 0x126fc8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movabsq $0xbf00000080, %rax # imm = 0xBF00000080
movq %rax, 0x10(%rsi)
movl $0x6, %edx
movq %rbx, %rdi
callq 0x95ff0
testb %al, %al
jne 0x95762
jmp 0x95b3f
movq %rbx, %rdi
callq 0x22d18
leaq 0x87170(%rip), %rbp # 0x11c996
cmpl $0x61, %eax
jle 0x95951
leal -0x6e(%rax), %ecx
cmpl $0x7, %ecx
ja 0x9596c
leaq 0x89a5a(%rip), %rax # 0x11f29c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x95faa
leaq 0x87076(%rip), %rbp # 0x11c8d0
cmpl $-0x1, %eax
je 0x95b3b
movl %eax, %r15d
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xd800, %eax # imm = 0xD800
jne 0x9591c
movq %rbx, %rdi
callq 0x22d18
cmpl $0x5c, %eax
jne 0x95b53
movq %rbx, %rdi
callq 0x22d18
cmpl $0x75, %eax
jne 0x95b53
movq %rbx, %rdi
callq 0x95faa
cmpl $-0x1, %eax
je 0x95b3b
movl %eax, %ecx
andl $0xfffffc00, %ecx # imm = 0xFFFFFC00
leaq 0x8704e(%rip), %rbp # 0x11c906
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x95b3b
shll $0xa, %r15d
addl %eax, %r15d
addl $0xfca02400, %r15d # imm = 0xFCA02400
movl %r15d, %eax
shrl $0x12, %eax
orb $-0x10, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x22400
movl %r15d, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x22400
movl %r15d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x22400
andb $0x3f, %r15b
orb $-0x80, %r15b
jmp 0x957b0
cmpl $0xdc00, %eax # imm = 0xDC00
je 0x95b5c
cmpl $0x110000, %r15d # imm = 0x110000
jae 0x95b81
cmpl $0x7f, %r15d
jbe 0x957b0
cmpl $0x7ff, %r15d # imm = 0x7FF
ja 0x95982
movl %r15d, %eax
shrl $0x6, %eax
orb $-0x40, %al
jmp 0x95904
cmpl $0x22, %eax
je 0x959a4
cmpl $0x2f, %eax
je 0x9599c
cmpl $0x5c, %eax
jne 0x95b3b
movb $0x5c, %r15b
jmp 0x957b0
cmpl $0x62, %eax
je 0x959c4
cmpl $0x66, %eax
jne 0x95b3b
movb $0xc, %r15b
jmp 0x957b0
cmpl $0xffff, %r15d # imm = 0xFFFF
ja 0x958d2
movl %r15d, %eax
shrl $0xc, %eax
orb $-0x20, %al
jmp 0x958ef
movb $0x2f, %r15b
jmp 0x957b0
movb $0x22, %r15b
jmp 0x957b0
movb $0x9, %r15b
jmp 0x957b0
movb $0xa, %r15b
jmp 0x957b0
movb $0xd, %r15b
jmp 0x957b0
movb $0x8, %r15b
jmp 0x957b0
movl $0x4, %eax
jmp 0x95b44
leaq 0x878d6(%rip), %rbp # 0x11d2b3
jmp 0x95b3b
leaq 0x87718(%rip), %rbp # 0x11d101
jmp 0x95b3b
leaq 0x87876(%rip), %rbp # 0x11d26b
jmp 0x95b3b
leaq 0x87343(%rip), %rbp # 0x11cd44
jmp 0x95b3b
leaq 0x877ce(%rip), %rbp # 0x11d1db
jmp 0x95b3b
leaq 0x8769f(%rip), %rbp # 0x11d0b8
jmp 0x95b3b
leaq 0x870c9(%rip), %rbp # 0x11caee
jmp 0x95b3b
leaq 0x871e1(%rip), %rbp # 0x11cc12
jmp 0x95b3b
leaq 0x87068(%rip), %rbp # 0x11caa5
jmp 0x95b3b
leaq 0x87137(%rip), %rbp # 0x11cb80
jmp 0x95b3b
leaq 0x87174(%rip), %rbp # 0x11cbc9
jmp 0x95b3b
movq %r12, %rbp
jmp 0x95b3b
leaq 0x87407(%rip), %rbp # 0x11ce70
jmp 0x95b3b
leaq 0x8736b(%rip), %rbp # 0x11cde0
jmp 0x95b3b
leaq 0x86e29(%rip), %rbp # 0x11c8aa
jmp 0x95b3b
leaq 0x870aa(%rip), %rbp # 0x11cb37
jmp 0x95b3b
leaq 0x87420(%rip), %rbp # 0x11ceb9
jmp 0x95b3b
leaq 0x86f25(%rip), %rbp # 0x11c9ca
jmp 0x95b3b
leaq 0x86fab(%rip), %rbp # 0x11ca5c
jmp 0x95b3b
leaq 0x8748e(%rip), %rbp # 0x11cf4b
jmp 0x95b3b
leaq 0x874ce(%rip), %rbp # 0x11cf94
jmp 0x95b3b
leaq 0x876c3(%rip), %rbp # 0x11d192
jmp 0x95b3b
leaq 0x87188(%rip), %rbp # 0x11cc60
jmp 0x95b3b
leaq 0x874fc(%rip), %rbp # 0x11cfdd
jmp 0x95b3b
leaq 0x872a8(%rip), %rbp # 0x11cd92
jmp 0x95b3b
leaq 0x87656(%rip), %rbp # 0x11d149
jmp 0x95b3b
leaq 0x871b2(%rip), %rbp # 0x11ccae
jmp 0x95b3b
leaq 0x871f7(%rip), %rbp # 0x11ccfc
jmp 0x95b3b
leaq 0x873f4(%rip), %rbp # 0x11cf02
jmp 0x95b3b
leaq 0x87311(%rip), %rbp # 0x11ce28
jmp 0x95b3b
leaq 0x87703(%rip), %rbp # 0x11d223
jmp 0x95b3b
leaq 0x874fd(%rip), %rbp # 0x11d026
jmp 0x95b3b
leaq 0x8753d(%rip), %rbp # 0x11d06f
jmp 0x95b3b
leaq 0x877c0(%rip), %rbp # 0x11d2fb
movq %rbp, 0x70(%rbx)
movl $0xe, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x86dac(%rip), %rbp # 0x11c906
jmp 0x95b3b
leaq 0x86def(%rip), %rbp # 0x11c952
jmp 0x95b3b
leaq 0x8f73a(%rip), %rdi # 0x1252a6
leaq 0x8688d(%rip), %rdx # 0x11c400
leaq 0x8f8df(%rip), %rcx # 0x125459
movl $0x1dd1, %esi # imm = 0x1DD1
jmp 0x95b9b
leaq 0x8f71e(%rip), %rdi # 0x1252a6
leaq 0x86871(%rip), %rdx # 0x11c400
leaq 0x8f8d3(%rip), %rcx # 0x125469
movl $0x1e49, %esi # imm = 0x1E49
xorl %eax, %eax
callq 0x21ec0
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE11scan_stringEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
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_EEEEE5resetEv; 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>>>::reset(void)
cmp dword ptr [rbx+14h], 22h ; '"'
jnz loc_95B65
lea r14, [rbx+50h]
lea r12, aInvalidStringC; "invalid string: control character U+000"...
lea r13, jpt_9577F
loc_95762:
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)
inc eax; switch 246 cases
cmp eax, 0F5h
ja def_9577F; jumptable 000000000009577F default case, cases 128-193
movsxd rax, ds:(jpt_9577F - 11EEC4h)[r13+rax*4]
add rax, r13
jmp rax; switch jump
loc_95781:
mov rax, 0BF00000080h; jumptable 000000000009577F cases 194-223
mov rsi, rsp
mov [rsi], rax
mov edx, 2
jmp short loc_95802
loc_95798:
movaps xmm0, cs:xmmword_11A170; jumptable 000000000009577F cases 225-236,238,239
loc_9579F:
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov edx, 4
jmp short loc_95802
loc_957AC:
mov r15b, [rbx+14h]; jumptable 000000000009577F cases 32,33,35-91,93-127
loc_957B0:
movsx esi, r15b
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_95762
loc_957BE:
movups xmm0, cs:xmmword_126FE0; jumptable 000000000009577F cases 241-243
jmp short loc_957E9
loc_957C7:
movaps xmm0, cs:xmmword_11A160; jumptable 000000000009577F case 237
jmp short loc_9579F
loc_957D0:
movaps xmm0, cs:xmmword_11A180; jumptable 000000000009577F case 224
jmp short loc_9579F
loc_957D9:
movups xmm0, cs:xmmword_126FF8; jumptable 000000000009577F case 244
jmp short loc_957E9
loc_957E2:
movups xmm0, cs:xmmword_126FC8; jumptable 000000000009577F case 240
loc_957E9:
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov rax, 0BF00000080h
mov [rsi+10h], rax
mov edx, 6
loc_95802:
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_EEEEE18next_byte_in_rangeESt16initializer_listIiE; 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>>>::next_byte_in_range(std::initializer_list<int>)
test al, al
jnz loc_95762
jmp loc_95B3F
loc_95817:
mov rdi, rbx; jumptable 000000000009577F case 92
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)
lea rbp, aInvalidStringF; "invalid string: forbidden character aft"...
cmp eax, 61h ; 'a'
jle loc_95951
lea ecx, [rax-6Eh]; switch 8 cases
cmp ecx, 7
ja def_95849; jumptable 0000000000095849 default case
lea rax, jpt_95849
movsxd rcx, ds:(jpt_95849 - 11F29Ch)[rax+rcx*4]
add rcx, rax
jmp rcx; switch jump
loc_9584B:
mov rdi, rbx; jumptable 0000000000095849 case 117
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv; 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_codepoint(void)
lea rbp, aInvalidStringU; "invalid string: '\\u' must be followed "...
cmp eax, 0FFFFFFFFh
jz loc_95B3B; jumptable 0000000000095849 cases 111-113,115
mov r15d, eax
and eax, 0FFFFFC00h
cmp eax, 0D800h
jnz loc_9591C
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, 5Ch ; '\'
jnz loc_95B53
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, 75h ; 'u'
jnz loc_95B53
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_EEEEE13get_codepointEv; 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_codepoint(void)
cmp eax, 0FFFFFFFFh
jz loc_95B3B; jumptable 0000000000095849 cases 111-113,115
mov ecx, eax
and ecx, 0FFFFFC00h
lea rbp, aInvalidStringS; "invalid string: surrogate U+D800..U+DBF"...
cmp ecx, 0DC00h
jnz loc_95B3B; jumptable 0000000000095849 cases 111-113,115
shl r15d, 0Ah
add r15d, eax
add r15d, 0FCA02400h
loc_958D2:
mov eax, r15d
shr eax, 12h
or al, 0F0h
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov eax, r15d
shr eax, 0Ch
and al, 3Fh
or al, 80h
loc_958EF:
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov eax, r15d
shr eax, 6
and al, 3Fh
or al, 80h
loc_95904:
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
and r15b, 3Fh
or r15b, 80h
jmp loc_957B0
loc_9591C:
cmp eax, 0DC00h
jz loc_95B5C
cmp r15d, offset loc_110000
jnb loc_95B81
cmp r15d, 7Fh
jbe loc_957B0
cmp r15d, 7FFh
ja short loc_95982
mov eax, r15d
shr eax, 6
or al, 0C0h
jmp short loc_95904
loc_95951:
cmp eax, 22h ; '"'
jz short loc_959A4
cmp eax, 2Fh ; '/'
jz short loc_9599C
cmp eax, 5Ch ; '\'
jnz loc_95B3B; jumptable 0000000000095849 cases 111-113,115
mov r15b, 5Ch ; '\'
jmp loc_957B0
def_95849:
cmp eax, 62h ; 'b'; jumptable 0000000000095849 default case
jz short loc_959C4
cmp eax, 66h ; 'f'
jnz loc_95B3B; jumptable 0000000000095849 cases 111-113,115
mov r15b, 0Ch
jmp loc_957B0
loc_95982:
cmp r15d, 0FFFFh
ja loc_958D2
mov eax, r15d
shr eax, 0Ch
or al, 0E0h
jmp loc_958EF
loc_9599C:
mov r15b, 2Fh ; '/'
jmp loc_957B0
loc_959A4:
mov r15b, 22h ; '"'
jmp loc_957B0
loc_959AC:
mov r15b, 9; jumptable 0000000000095849 case 116
jmp loc_957B0
loc_959B4:
mov r15b, 0Ah; jumptable 0000000000095849 case 110
jmp loc_957B0
loc_959BC:
mov r15b, 0Dh; jumptable 0000000000095849 case 114
jmp loc_957B0
loc_959C4:
mov r15b, 8
jmp loc_957B0
loc_959CC:
mov eax, 4; jumptable 000000000009577F case 34
jmp loc_95B44
loc_959D6:
lea rbp, aInvalidStringC_30; jumptable 000000000009577F case 31
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_959E2:
lea rbp, aInvalidStringC_2; jumptable 000000000009577F case 25
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_959EE:
lea rbp, aInvalidStringC_17; jumptable 000000000009577F case 30
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_959FA:
lea rbp, aInvalidStringC_5; jumptable 000000000009577F case 12
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A06:
lea rbp, aInvalidStringC_1; jumptable 000000000009577F case 28
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A12:
lea rbp, aInvalidStringC_0; jumptable 000000000009577F case 24
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A1E:
lea rbp, aInvalidStringC_7; jumptable 000000000009577F case 4
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A2A:
lea rbp, aInvalidStringC_10; jumptable 000000000009577F case 8
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A36:
lea rbp, aInvalidStringC_13; jumptable 000000000009577F case 3
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A42:
lea rbp, aInvalidStringC_12; jumptable 000000000009577F case 6
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A4E:
lea rbp, aInvalidStringC_15; jumptable 000000000009577F case 7
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A5A:
mov rbp, r12; jumptable 000000000009577F case 1
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A62:
lea rbp, aInvalidStringC_9; jumptable 000000000009577F case 16
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A6E:
lea rbp, aInvalidStringC_23; jumptable 000000000009577F case 14
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A7A:
lea rbp, aInvalidStringM; jumptable 000000000009577F case -1
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A86:
lea rbp, aInvalidStringC_18; jumptable 000000000009577F case 5
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A92:
lea rbp, aInvalidStringC_25; jumptable 000000000009577F case 17
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95A9E:
lea rbp, aInvalidStringC_8; jumptable 000000000009577F case 0
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95AAA:
lea rbp, aInvalidStringC_16; jumptable 000000000009577F case 2
jmp loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95AB6:
lea rbp, aInvalidStringC_19; jumptable 000000000009577F case 19
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95ABF:
lea rbp, aInvalidStringC_4; jumptable 000000000009577F case 20
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95AC8:
lea rbp, aInvalidStringC_27; jumptable 000000000009577F case 27
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95AD1:
lea rbp, aInvalidStringC_3; jumptable 000000000009577F case 9
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95ADA:
lea rbp, aInvalidStringC_29; jumptable 000000000009577F case 21
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95AE3:
lea rbp, aInvalidStringC_22; jumptable 000000000009577F case 13
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95AEC:
lea rbp, aInvalidStringC_11; jumptable 000000000009577F case 26
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95AF5:
lea rbp, aInvalidStringC_6; jumptable 000000000009577F case 10
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95AFE:
lea rbp, aInvalidStringC_14; jumptable 000000000009577F case 11
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95B07:
lea rbp, aInvalidStringC_24; jumptable 000000000009577F case 18
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95B10:
lea rbp, aInvalidStringC_20; jumptable 000000000009577F case 15
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95B19:
lea rbp, aInvalidStringC_21; jumptable 000000000009577F case 29
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95B22:
lea rbp, aInvalidStringC_28; jumptable 000000000009577F case 22
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95B2B:
lea rbp, aInvalidStringC_26; jumptable 000000000009577F case 23
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
def_9577F:
lea rbp, aInvalidStringI; jumptable 000000000009577F default case, cases 128-193
loc_95B3B:
mov [rbx+70h], rbp; jumptable 0000000000095849 cases 111-113,115
loc_95B3F:
mov eax, 0Eh
loc_95B44:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_95B53:
lea rbp, aInvalidStringS; "invalid string: surrogate U+D800..U+DBF"...
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95B5C:
lea rbp, aInvalidStringS_0; "invalid string: surrogate U+DC00..U+DFF"...
jmp short loc_95B3B; jumptable 0000000000095849 cases 111-113,115
loc_95B65:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrent; "current == '\\\"'"
mov esi, 1DD1h
jmp short loc_95B9B
loc_95B81:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, a0x00CodepointC; "0x00 <= codepoint && codepoint <= 0x10F"...
mov esi, 1E49h
loc_95B9B:
xor eax, eax
call _ggml_abort
|
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>>>::scan_string(
__m128i *a1)
{
long long v1; // rdx
long long v2; // rcx
long long v3; // r8
long long v4; // r9
long long v5; // rdx
__int128 v6; // xmm0
unsigned int v7; // r15d
__int128 v8; // xmm0
int v9; // eax
const char *v10; // rbp
unsigned int codepoint; // eax
unsigned int v12; // eax
int v13; // eax
char v14; // al
char v15; // al
__int128 v17; // [rsp+0h] [rbp-48h] BYREF
long long v18; // [rsp+10h] [rbp-38h]
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>>>::reset();
if ( a1[1].m128i_i32[1] != 34 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7633LL,
"GGML_ASSERT(%s) failed",
"current == '\\\"'");
return 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>>>::scan_number("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp");
}
while ( 2 )
{
while ( 2 )
{
switch ( (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) )
{
case 0xFFFFFFFF:
v10 = "invalid string: missing closing quote";
goto LABEL_83;
case 0u:
v10 = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
goto LABEL_83;
case 1u:
v10 = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
goto LABEL_83;
case 2u:
v10 = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
goto LABEL_83;
case 3u:
v10 = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
goto LABEL_83;
case 4u:
v10 = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
goto LABEL_83;
case 5u:
v10 = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
goto LABEL_83;
case 6u:
v10 = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
goto LABEL_83;
case 7u:
v10 = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
goto LABEL_83;
case 8u:
v10 = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
goto LABEL_83;
case 9u:
v10 = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
goto LABEL_83;
case 0xAu:
v10 = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
goto LABEL_83;
case 0xBu:
v10 = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
goto LABEL_83;
case 0xCu:
v10 = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
goto LABEL_83;
case 0xDu:
v10 = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
goto LABEL_83;
case 0xEu:
v10 = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
goto LABEL_83;
case 0xFu:
v10 = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
goto LABEL_83;
case 0x10u:
v10 = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
goto LABEL_83;
case 0x11u:
v10 = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
goto LABEL_83;
case 0x12u:
v10 = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
goto LABEL_83;
case 0x13u:
v10 = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
goto LABEL_83;
case 0x14u:
v10 = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
goto LABEL_83;
case 0x15u:
v10 = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
goto LABEL_83;
case 0x16u:
v10 = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
goto LABEL_83;
case 0x17u:
v10 = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
goto LABEL_83;
case 0x18u:
v10 = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
goto LABEL_83;
case 0x19u:
v10 = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
goto LABEL_83;
case 0x1Au:
v10 = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
goto LABEL_83;
case 0x1Bu:
v10 = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
goto LABEL_83;
case 0x1Cu:
v10 = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
goto LABEL_83;
case 0x1Du:
v10 = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
goto LABEL_83;
case 0x1Eu:
v10 = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
goto LABEL_83;
case 0x1Fu:
v10 = "invalid string: control character U+001F (US) must be escaped to \\u001F";
goto LABEL_83;
case 0x20u:
case 0x21u:
case 0x23u:
case 0x24u:
case 0x25u:
case 0x26u:
case 0x27u:
case 0x28u:
case 0x29u:
case 0x2Au:
case 0x2Bu:
case 0x2Cu:
case 0x2Du:
case 0x2Eu:
case 0x2Fu:
case 0x30u:
case 0x31u:
case 0x32u:
case 0x33u:
case 0x34u:
case 0x35u:
case 0x36u:
case 0x37u:
case 0x38u:
case 0x39u:
case 0x3Au:
case 0x3Bu:
case 0x3Cu:
case 0x3Du:
case 0x3Eu:
case 0x3Fu:
case 0x40u:
case 0x41u:
case 0x42u:
case 0x43u:
case 0x44u:
case 0x45u:
case 0x46u:
case 0x47u:
case 0x48u:
case 0x49u:
case 0x4Au:
case 0x4Bu:
case 0x4Cu:
case 0x4Du:
case 0x4Eu:
case 0x4Fu:
case 0x50u:
case 0x51u:
case 0x52u:
case 0x53u:
case 0x54u:
case 0x55u:
case 0x56u:
case 0x57u:
case 0x58u:
case 0x59u:
case 0x5Au:
case 0x5Bu:
case 0x5Du:
case 0x5Eu:
case 0x5Fu:
case 0x60u:
case 0x61u:
case 0x62u:
case 0x63u:
case 0x64u:
case 0x65u:
case 0x66u:
case 0x67u:
case 0x68u:
case 0x69u:
case 0x6Au:
case 0x6Bu:
case 0x6Cu:
case 0x6Du:
case 0x6Eu:
case 0x6Fu:
case 0x70u:
case 0x71u:
case 0x72u:
case 0x73u:
case 0x74u:
case 0x75u:
case 0x76u:
case 0x77u:
case 0x78u:
case 0x79u:
case 0x7Au:
case 0x7Bu:
case 0x7Cu:
case 0x7Du:
case 0x7Eu:
case 0x7Fu:
LOBYTE(v7) = a1[1].m128i_i8[4];
goto LABEL_7;
case 0x22u:
return 4LL;
case 0x5Cu:
v9 = 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);
v10 = "invalid string: forbidden character after backslash";
if ( v9 <= 97 )
{
switch ( v9 )
{
case '"':
LOBYTE(v7) = 34;
break;
case '/':
LOBYTE(v7) = 47;
break;
case '\\':
LOBYTE(v7) = 92;
break;
default:
goto LABEL_83;
}
goto LABEL_7;
}
break;
case 0xC2u:
case 0xC3u:
case 0xC4u:
case 0xC5u:
case 0xC6u:
case 0xC7u:
case 0xC8u:
case 0xC9u:
case 0xCAu:
case 0xCBu:
case 0xCCu:
case 0xCDu:
case 0xCEu:
case 0xCFu:
case 0xD0u:
case 0xD1u:
case 0xD2u:
case 0xD3u:
case 0xD4u:
case 0xD5u:
case 0xD6u:
case 0xD7u:
case 0xD8u:
case 0xD9u:
case 0xDAu:
case 0xDBu:
case 0xDCu:
case 0xDDu:
case 0xDEu:
case 0xDFu:
*(_QWORD *)&v17 = 0xBF00000080LL;
v5 = 2LL;
goto LABEL_14;
case 0xE0u:
v6 = xmmword_11A180;
goto LABEL_5;
case 0xE1u:
case 0xE2u:
case 0xE3u:
case 0xE4u:
case 0xE5u:
case 0xE6u:
case 0xE7u:
case 0xE8u:
case 0xE9u:
case 0xEAu:
case 0xEBu:
case 0xECu:
case 0xEEu:
case 0xEFu:
v6 = xmmword_11A170;
goto LABEL_5;
case 0xEDu:
v6 = xmmword_11A160;
LABEL_5:
v17 = v6;
v5 = 4LL;
goto LABEL_14;
case 0xF0u:
v8 = xmmword_126FC8;
goto LABEL_13;
case 0xF1u:
case 0xF2u:
case 0xF3u:
v8 = xmmword_126FE0;
goto LABEL_13;
case 0xF4u:
v8 = xmmword_126FF8;
LABEL_13:
v17 = v8;
v18 = 0xBF00000080LL;
v5 = 6LL;
LABEL_14:
if ( !(unsigned __int8)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>>>::next_byte_in_range(
a1,
&v17,
v5,
v2,
v3,
v4,
v17,
*((_QWORD *)&v17 + 1),
v18) )
return 14LL;
continue;
default:
v10 = "invalid string: ill-formed UTF-8 byte";
goto LABEL_83;
}
break;
}
v2 = (unsigned int)(v9 - 110);
switch ( v9 )
{
case 'n':
LOBYTE(v7) = 10;
goto LABEL_7;
case 'o':
case 'p':
case 'q':
case 's':
goto LABEL_83;
case 'r':
LOBYTE(v7) = 13;
goto LABEL_7;
case 't':
LOBYTE(v7) = 9;
goto LABEL_7;
case 'u':
codepoint = 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_codepoint(a1);
v10 = "invalid string: '\\u' must be followed by 4 hex digits";
if ( codepoint == -1 )
goto LABEL_83;
v7 = codepoint;
v12 = codepoint & 0xFFFFFC00;
if ( v12 == 55296 )
{
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) != 92
|| (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) != 117 )
{
v10 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
LABEL_83:
a1[7].m128i_i64[0] = (long long)v10;
return 14LL;
}
v13 = 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_codepoint(a1);
if ( v13 == -1 )
goto LABEL_83;
v2 = v13 & 0xFFFFFC00;
v10 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
if ( (_DWORD)v2 != 56320 )
goto LABEL_83;
v7 = v13 + (v7 << 10) - 56613888;
goto LABEL_25;
}
if ( v12 == 56320 )
{
v10 = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
goto LABEL_83;
}
if ( v7 < (unsigned int)&loc_110000 )
{
if ( v7 > 0x7F )
{
if ( v7 <= 0x7FF )
{
v15 = (v7 >> 6) | 0xC0;
goto LABEL_27;
}
if ( v7 <= 0xFFFF )
{
v14 = (v7 >> 12) | 0xE0;
goto LABEL_26;
}
LABEL_25:
std::string::push_back(&a1[5], (unsigned int)(char)((v7 >> 18) | 0xF0), v1, v2, v3, v4);
v14 = (v7 >> 12) & 0x3F | 0x80;
LABEL_26:
std::string::push_back(&a1[5], (unsigned int)v14, v1, v2, v3, v4);
v15 = (v7 >> 6) & 0x3F | 0x80;
LABEL_27:
std::string::push_back(&a1[5], (unsigned int)v15, v1, v2, v3, v4);
LOBYTE(v7) = v7 & 0x3F | 0x80;
}
LABEL_7:
std::string::push_back(&a1[5], (unsigned int)(char)v7, v1, v2, v3, v4);
continue;
}
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7753LL,
"GGML_ASSERT(%s) failed",
"0x00 <= codepoint && codepoint <= 0x10FFFF");
return 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>>>::scan_number("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp");
default:
if ( v9 == 98 )
{
LOBYTE(v7) = 8;
}
else
{
if ( v9 != 102 )
goto LABEL_83;
LOBYTE(v7) = 12;
}
goto LABEL_7;
}
}
}
|
scan_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
CALL 0x00195f6c
CMP dword ptr [RBX + 0x14],0x22
JNZ 0x00195b65
LEA R14,[RBX + 0x50]
LEA R12,[0x21ca13]
LEA R13,[0x21eec4]
LAB_00195762:
MOV RDI,RBX
CALL 0x00122d18
INC EAX
CMP EAX,0xf5
JA 0x00195b34
MOVSXD RAX,dword ptr [R13 + RAX*0x4]
ADD RAX,R13
switchD:
JMP RAX
caseD_c2:
MOV RAX,0xbf00000080
MOV RSI,RSP
MOV qword ptr [RSI],RAX
MOV EDX,0x2
JMP 0x00195802
caseD_e1:
MOVAPS XMM0,xmmword ptr [0x0021a170]
LAB_0019579f:
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV EDX,0x4
JMP 0x00195802
caseD_20:
MOV R15B,byte ptr [RBX + 0x14]
LAB_001957b0:
MOVSX ESI,R15B
MOV RDI,R14
CALL 0x00122400
JMP 0x00195762
caseD_f1:
MOVUPS XMM0,xmmword ptr [0x00226fe0]
JMP 0x001957e9
caseD_ed:
MOVAPS XMM0,xmmword ptr [0x0021a160]
JMP 0x0019579f
caseD_e0:
MOVAPS XMM0,xmmword ptr [0x0021a180]
JMP 0x0019579f
caseD_f4:
MOVUPS XMM0,xmmword ptr [0x00226ff8]
JMP 0x001957e9
caseD_f0:
MOVUPS XMM0,xmmword ptr [0x00226fc8]
LAB_001957e9:
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV RAX,0xbf00000080
MOV qword ptr [RSI + 0x10],RAX
MOV EDX,0x6
LAB_00195802:
MOV RDI,RBX
CALL 0x00195ff0
TEST AL,AL
JNZ 0x00195762
JMP 0x00195b3f
caseD_5c:
MOV RDI,RBX
CALL 0x00122d18
LEA RBP,[0x21c996]
CMP EAX,0x61
JLE 0x00195951
LEA ECX,[RAX + -0x6e]
CMP ECX,0x7
JA 0x0019596c
LEA RAX,[0x21f29c]
MOVSXD RCX,dword ptr [RAX + RCX*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_75:
MOV RDI,RBX
CALL 0x00195faa
LEA RBP,[0x21c8d0]
CMP EAX,-0x1
JZ 0x00195b3b
MOV R15D,EAX
AND EAX,0xfffffc00
CMP EAX,0xd800
JNZ 0x0019591c
MOV RDI,RBX
CALL 0x00122d18
CMP EAX,0x5c
JNZ 0x00195b53
MOV RDI,RBX
CALL 0x00122d18
CMP EAX,0x75
JNZ 0x00195b53
MOV RDI,RBX
CALL 0x00195faa
CMP EAX,-0x1
JZ 0x00195b3b
MOV ECX,EAX
AND ECX,0xfffffc00
LEA RBP,[0x21c906]
CMP ECX,0xdc00
JNZ 0x00195b3b
SHL R15D,0xa
ADD R15D,EAX
ADD R15D,0xfca02400
LAB_001958d2:
MOV EAX,R15D
SHR EAX,0x12
OR AL,0xf0
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00122400
MOV EAX,R15D
SHR EAX,0xc
AND AL,0x3f
OR AL,0x80
LAB_001958ef:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00122400
MOV EAX,R15D
SHR EAX,0x6
AND AL,0x3f
OR AL,0x80
LAB_00195904:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00122400
AND R15B,0x3f
OR R15B,0x80
JMP 0x001957b0
LAB_0019591c:
CMP EAX,0xdc00
JZ 0x00195b5c
CMP R15D,0x110000
JNC 0x00195b81
CMP R15D,0x7f
JBE 0x001957b0
CMP R15D,0x7ff
JA 0x00195982
MOV EAX,R15D
SHR EAX,0x6
OR AL,0xc0
JMP 0x00195904
LAB_00195951:
CMP EAX,0x22
JZ 0x001959a4
CMP EAX,0x2f
JZ 0x0019599c
CMP EAX,0x5c
JNZ 0x00195b3b
MOV R15B,0x5c
JMP 0x001957b0
default:
CMP EAX,0x62
JZ 0x001959c4
CMP EAX,0x66
JNZ 0x00195b3b
MOV R15B,0xc
JMP 0x001957b0
LAB_00195982:
CMP R15D,0xffff
JA 0x001958d2
MOV EAX,R15D
SHR EAX,0xc
OR AL,0xe0
JMP 0x001958ef
LAB_0019599c:
MOV R15B,0x2f
JMP 0x001957b0
LAB_001959a4:
MOV R15B,0x22
JMP 0x001957b0
caseD_74:
MOV R15B,0x9
JMP 0x001957b0
caseD_6e:
MOV R15B,0xa
JMP 0x001957b0
caseD_72:
MOV R15B,0xd
JMP 0x001957b0
LAB_001959c4:
MOV R15B,0x8
JMP 0x001957b0
caseD_22:
MOV EAX,0x4
JMP 0x00195b44
caseD_1f:
LEA RBP,[0x21d2b3]
JMP 0x00195b3b
caseD_19:
LEA RBP,[0x21d101]
JMP 0x00195b3b
caseD_1e:
LEA RBP,[0x21d26b]
JMP 0x00195b3b
caseD_c:
LEA RBP,[0x21cd44]
JMP 0x00195b3b
caseD_1c:
LEA RBP,[0x21d1db]
JMP 0x00195b3b
caseD_18:
LEA RBP,[0x21d0b8]
JMP 0x00195b3b
caseD_4:
LEA RBP,[0x21caee]
JMP 0x00195b3b
caseD_8:
LEA RBP,[0x21cc12]
JMP 0x00195b3b
caseD_3:
LEA RBP,[0x21caa5]
JMP 0x00195b3b
caseD_6:
LEA RBP,[0x21cb80]
JMP 0x00195b3b
caseD_7:
LEA RBP,[0x21cbc9]
JMP 0x00195b3b
caseD_1:
MOV RBP,R12
JMP 0x00195b3b
caseD_10:
LEA RBP,[0x21ce70]
JMP 0x00195b3b
caseD_e:
LEA RBP,[0x21cde0]
JMP 0x00195b3b
caseD_ffffffff:
LEA RBP,[0x21c8aa]
JMP 0x00195b3b
caseD_5:
LEA RBP,[0x21cb37]
JMP 0x00195b3b
caseD_11:
LEA RBP,[0x21ceb9]
JMP 0x00195b3b
caseD_0:
LEA RBP,[0x21c9ca]
JMP 0x00195b3b
caseD_2:
LEA RBP,[0x21ca5c]
JMP 0x00195b3b
caseD_13:
LEA RBP,[0x21cf4b]
JMP 0x00195b3b
caseD_14:
LEA RBP,[0x21cf94]
JMP 0x00195b3b
caseD_1b:
LEA RBP,[0x21d192]
JMP 0x00195b3b
caseD_9:
LEA RBP,[0x21cc60]
JMP 0x00195b3b
caseD_15:
LEA RBP,[0x21cfdd]
JMP 0x00195b3b
caseD_d:
LEA RBP,[0x21cd92]
JMP 0x00195b3b
caseD_1a:
LEA RBP,[0x21d149]
JMP 0x00195b3b
caseD_a:
LEA RBP,[0x21ccae]
JMP 0x00195b3b
caseD_b:
LEA RBP,[0x21ccfc]
JMP 0x00195b3b
caseD_12:
LEA RBP,[0x21cf02]
JMP 0x00195b3b
caseD_f:
LEA RBP,[0x21ce28]
JMP 0x00195b3b
caseD_1d:
LEA RBP,[0x21d223]
JMP 0x00195b3b
caseD_16:
LEA RBP,[0x21d026]
JMP 0x00195b3b
caseD_17:
LEA RBP,[0x21d06f]
JMP 0x00195b3b
caseD_80:
LEA RBP,[0x21d2fb]
caseD_6f:
MOV qword ptr [RBX + 0x70],RBP
LAB_00195b3f:
MOV EAX,0xe
LAB_00195b44:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00195b53:
LEA RBP,[0x21c906]
JMP 0x00195b3b
LAB_00195b5c:
LEA RBP,[0x21c952]
JMP 0x00195b3b
LAB_00195b65:
LEA RDI,[0x2252a6]
LEA RDX,[0x21c400]
LEA RCX,[0x225459]
MOV ESI,0x1dd1
JMP 0x00195b9b
LAB_00195b81:
LEA RDI,[0x2252a6]
LEA RDX,[0x21c400]
LEA RCX,[0x225469]
MOV ESI,0x1e49
LAB_00195b9b:
XOR EAX,EAX
CALL 0x00121ec0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* 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 > > >::scan_string() */
int8 __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>>>
::scan_string(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)
{
char cVar1;
int4 uVar2;
int iVar3;
uint uVar4;
char *pcVar5;
int8 uVar6;
char cVar7;
int4 uVar8;
int8 local_48;
int4 uStack_40;
int4 uStack_3c;
int8 local_38;
reset(this);
if (*(int *)(this + 0x14) != 0x22) {
pcVar5 = "current == \'\\\"\'";
uVar6 = 0x1dd1;
LAB_00195b9b:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar5);
}
cVar7 = (char)this + 'P';
LAB_00195762:
uVar2 = get(this);
switch(uVar2) {
case 0:
pcVar5 = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
break;
case 1:
pcVar5 = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
break;
case 2:
pcVar5 = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
break;
case 3:
pcVar5 = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
break;
case 4:
pcVar5 = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
break;
case 5:
pcVar5 = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
break;
case 6:
pcVar5 = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
break;
case 7:
pcVar5 = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
break;
case 8:
pcVar5 = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
break;
case 9:
pcVar5 = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
break;
case 10:
pcVar5 = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
break;
case 0xb:
pcVar5 = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
break;
case 0xc:
pcVar5 = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
break;
case 0xd:
pcVar5 = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
break;
case 0xe:
pcVar5 = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
break;
case 0xf:
pcVar5 = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
break;
case 0x10:
pcVar5 = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
break;
case 0x11:
pcVar5 = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
break;
case 0x12:
pcVar5 = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
break;
case 0x13:
pcVar5 = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
break;
case 0x14:
pcVar5 = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
break;
case 0x15:
pcVar5 = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
break;
case 0x16:
pcVar5 = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
break;
case 0x17:
pcVar5 = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
break;
case 0x18:
pcVar5 = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
break;
case 0x19:
pcVar5 = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
break;
case 0x1a:
pcVar5 = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
break;
case 0x1b:
pcVar5 = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
break;
case 0x1c:
pcVar5 = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
break;
case 0x1d:
pcVar5 = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
break;
case 0x1e:
pcVar5 = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
break;
case 0x1f:
pcVar5 = "invalid string: control character U+001F (US) must be escaped to \\u001F";
break;
case 0x20:
case 0x21:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2a:
case 0x2b:
case 0x2c:
case 0x2d:
case 0x2e:
case 0x2f:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3a:
case 0x3b:
case 0x3c:
case 0x3d:
case 0x3e:
case 0x3f:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4a:
case 0x4b:
case 0x4c:
case 0x4d:
case 0x4e:
case 0x4f:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5a:
case 0x5b:
case 0x5d:
case 0x5e:
case 0x5f:
case 0x60:
case 0x61:
case 0x62:
case 99:
case 100:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6a:
case 0x6b:
case 0x6c:
case 0x6d:
case 0x6e:
case 0x6f:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7a:
case 0x7b:
case 0x7c:
case 0x7d:
case 0x7e:
case 0x7f:
goto LAB_001957b0;
case 0x22:
return 4;
case 0x5c:
iVar3 = get(this);
pcVar5 = "invalid string: forbidden character after backslash";
if (iVar3 < 0x62) {
if (((iVar3 != 0x22) && (iVar3 != 0x2f)) && (iVar3 != 0x5c)) break;
}
else {
switch(iVar3) {
case 0x6e:
break;
case 0x6f:
case 0x70:
case 0x71:
case 0x73:
goto switchD_00195849_caseD_6f;
case 0x72:
break;
case 0x74:
break;
case 0x75:
uVar4 = get_codepoint(this);
pcVar5 = "invalid string: \'\\u\' must be followed by 4 hex digits";
if (uVar4 == 0xffffffff) goto switchD_00195849_caseD_6f;
if ((uVar4 & 0xfffffc00) == 0xd800) {
iVar3 = get(this);
if ((iVar3 != 0x5c) || (iVar3 = get(this), iVar3 != 0x75)) {
pcVar5 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
goto switchD_00195849_caseD_6f;
}
uVar4 = get_codepoint(this);
if ((uVar4 == 0xffffffff) ||
(pcVar5 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF"
, (uVar4 & 0xfffffc00) != 0xdc00)) goto switchD_00195849_caseD_6f;
LAB_001958d2:
std::__cxx11::string::push_back(cVar7);
LAB_001958ef:
std::__cxx11::string::push_back(cVar7);
}
else {
if ((uVar4 & 0xfffffc00) == 0xdc00) {
pcVar5 = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
goto switchD_00195849_caseD_6f;
}
if (0x10ffff < uVar4) {
pcVar5 = "0x00 <= codepoint && codepoint <= 0x10FFFF";
uVar6 = 0x1e49;
goto LAB_00195b9b;
}
if (uVar4 < 0x80) break;
if (0x7ff < uVar4) {
if (0xffff < uVar4) goto LAB_001958d2;
goto LAB_001958ef;
}
}
std::__cxx11::string::push_back(cVar7);
break;
default:
if ((iVar3 != 0x62) && (iVar3 != 0x66)) goto switchD_00195849_caseD_6f;
}
}
LAB_001957b0:
std::__cxx11::string::push_back(cVar7);
goto LAB_00195762;
default:
pcVar5 = "invalid string: ill-formed UTF-8 byte";
break;
case 0xc2:
case 0xc3:
case 0xc4:
case 0xc5:
case 0xc6:
case 199:
case 200:
case 0xc9:
case 0xca:
case 0xcb:
case 0xcc:
case 0xcd:
case 0xce:
case 0xcf:
case 0xd0:
case 0xd1:
case 0xd2:
case 0xd3:
case 0xd4:
case 0xd5:
case 0xd6:
case 0xd7:
case 0xd8:
case 0xd9:
case 0xda:
case 0xdb:
case 0xdc:
case 0xdd:
case 0xde:
case 0xdf:
local_48 = 0xbf00000080;
uVar6 = 2;
goto LAB_00195802;
case 0xe0:
uVar2 = _DAT_0021a180;
uVar8 = _UNK_0021a184;
uStack_40 = _UNK_0021a188;
uStack_3c = _UNK_0021a18c;
goto LAB_0019579f;
case 0xe1:
case 0xe2:
case 0xe3:
case 0xe4:
case 0xe5:
case 0xe6:
case 0xe7:
case 0xe8:
case 0xe9:
case 0xea:
case 0xeb:
case 0xec:
case 0xee:
case 0xef:
uVar2 = _DAT_0021a170;
uVar8 = _UNK_0021a174;
uStack_40 = _UNK_0021a178;
uStack_3c = _UNK_0021a17c;
goto LAB_0019579f;
case 0xed:
uVar2 = _DAT_0021a160;
uVar8 = _UNK_0021a164;
uStack_40 = _UNK_0021a168;
uStack_3c = _UNK_0021a16c;
LAB_0019579f:
local_48 = CONCAT44(uVar8,uVar2);
uVar6 = 4;
LAB_00195802:
cVar1 = next_byte_in_range(this,&local_48,uVar6);
if (cVar1 == '\0') {
return 0xe;
}
goto LAB_00195762;
case 0xf0:
uVar2 = _DAT_00226fc8;
uVar8 = _UNK_00226fcc;
uStack_40 = _UNK_00226fd0;
uStack_3c = _UNK_00226fd4;
goto LAB_001957e9;
case 0xf1:
case 0xf2:
case 0xf3:
uVar2 = _DAT_00226fe0;
uVar8 = _UNK_00226fe4;
uStack_40 = _UNK_00226fe8;
uStack_3c = _UNK_00226fec;
goto LAB_001957e9;
case 0xf4:
uVar2 = _DAT_00226ff8;
uVar8 = _UNK_00226ffc;
uStack_40 = _UNK_00227000;
uStack_3c = _UNK_00227004;
LAB_001957e9:
local_48 = CONCAT44(uVar8,uVar2);
local_38 = 0xbf00000080;
uVar6 = 6;
goto LAB_00195802;
case 0xffffffff:
pcVar5 = "invalid string: missing closing quote";
}
switchD_00195849_caseD_6f:
*(char **)(this + 0x70) = pcVar5;
return 0xe;
}
|
|
64,711 |
minja::Value::get(minja::Value const&)
|
monkey531[P]llama/common/minja.hpp
|
Value get(const Value& key) {
if (array_) {
if (!key.is_number_integer()) {
return Value();
}
auto index = key.get<int>();
return array_->at(index < 0 ? array_->size() + index : index);
} else if (object_) {
if (!key.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
auto it = object_->find(key.primitive_);
if (it == object_->end()) return Value();
return it->second;
}
return Value();
}
|
O3
|
cpp
|
minja::Value::get(minja::Value const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rsi)
je 0x9419a
movb 0x40(%r15), %al
addb $-0x5, %al
cmpb $0x2, %al
jae 0x94248
movq %r15, %rdi
callq 0x9444c
movq 0x10(%r14), %rcx
testl %eax, %eax
js 0x941f7
movl %eax, %eax
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
jmp 0x94218
movq 0x20(%r14), %r13
testq %r13, %r13
je 0x94248
cmpq $0x0, 0x10(%r15)
jne 0x942a7
cmpq $0x0, 0x20(%r15)
jne 0x942a7
cmpq $0x0, 0x30(%r15)
jne 0x942a7
movq (%r13), %r12
movq 0x8(%r13), %rsi
cmpq %rsi, %r12
je 0x94235
addq $0x40, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x90d94
testb %al, %al
jne 0x9422a
addq $0x60, %r12
movq 0x8(%r13), %rsi
cmpq %rsi, %r12
jne 0x941d9
jmp 0x9422d
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cltq
addq %rdx, %rax
cmpq %rax, %rdx
jbe 0x94296
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rsi
jmp 0x9423e
movq %r12, %rsi
movq 0x20(%r14), %rax
movq 0x8(%rax), %r12
cmpq %r12, %rsi
je 0x94248
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x91452
jmp 0x94284
leaq 0x40(%rbx), %r14
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x5c5ee
movq %r14, %rdi
movl $0x1, %esi
callq 0x5c5ee
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f5b6(%rip), %rdi # 0xf3853
movq %rax, %rsi
xorl %eax, %eax
callq 0x1bf60
movl $0x10, %edi
callq 0x1b4d0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x8a0c8
leaq 0x5f416(%rip), %rsi # 0xf36e5
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x7c85d
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c0a0
xorl %ebp, %ebp
movq 0x9bcf1(%rip), %rsi # 0x12ffe8
movq 0x9bc52(%rip), %rdx # 0x12ff50
movq %rbx, %rdi
callq 0x1c1c0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x94324
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1ba60
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9433f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1ba60
testb %bpl, %bpl
jne 0x94369
jmp 0x94371
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x94369
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1ba60
jmp 0x94369
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b760
movq %r14, %rdi
callq 0x1c250
nop
|
_ZN5minja5Value3getERKS0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
cmp qword ptr [rsi+10h], 0
jz short loc_9419A
mov al, [r15+40h]
add al, 0FBh
cmp al, 2
jnb loc_94248
mov rdi, r15
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
mov rcx, [r14+10h]
test eax, eax
js short loc_941F7
mov eax, eax
mov rsi, [rcx]
mov rcx, [rcx+8]
sub rcx, rsi
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
jmp short loc_94218
loc_9419A:
mov r13, [r14+20h]
test r13, r13
jz loc_94248
cmp qword ptr [r15+10h], 0
jnz loc_942A7
cmp qword ptr [r15+20h], 0
jnz loc_942A7
cmp qword ptr [r15+30h], 0
jnz loc_942A7
mov r12, [r13+0]
mov rsi, [r13+8]
cmp r12, rsi
jz short loc_94235
add r15, 40h ; '@'
loc_941D9:
mov rdi, r12
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
test al, al
jnz short loc_9422A
add r12, 60h ; '`'
mov rsi, [r13+8]
cmp r12, rsi
jnz short loc_941D9
jmp short loc_9422D
loc_941F7:
mov rsi, [rcx]
mov rcx, [rcx+8]
sub rcx, rsi
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
cdqe
add rax, rdx
loc_94218:
cmp rdx, rax
jbe short loc_94296
lea rax, [rax+rax*4]
shl rax, 4
add rsi, rax
jmp short loc_9423E
loc_9422A:
mov rsi, r12
loc_9422D:
mov rax, [r14+20h]
mov r12, [rax+8]
loc_94235:
cmp rsi, r12
jz short loc_94248
add rsi, 10h; minja::Value *
loc_9423E:
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
jmp short loc_94284
loc_94248:
lea r14, [rbx+40h]
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
loc_94284:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_94296:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
mov rsi, rax
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
loc_942A7:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+78h+var_70]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_94324
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_94324:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9433F
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9433F:
test bpl, bpl
jnz short loc_94369
jmp short loc_94371
mov r14, rax
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_94369
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_94369
mov r14, rax
loc_94369:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_94371:
mov rdi, r14
call __Unwind_Resume
|
minja::Value * minja::Value::get(minja::Value *this, const minja::Value *a2, long long a3, __m128d a4)
{
unsigned long long v5; // rax
long long *v6; // rcx
long long v7; // rsi
unsigned long long v8; // rdx
unsigned __int8 **v9; // r13
unsigned __int8 *v10; // r12
unsigned __int8 *v11; // rsi
unsigned __int8 *v12; // r15
const minja::Value *v13; // rsi
void *exception; // rbx
_BYTE v16[16]; // [rsp+8h] [rbp-70h] BYREF
_BYTE v17[16]; // [rsp+28h] [rbp-50h] BYREF
if ( *((_QWORD *)a2 + 2) )
{
if ( (unsigned __int8)(*(_BYTE *)(a3 + 64) - 5) < 2u )
{
LODWORD(v5) = minja::Value::get<int>(a3);
v6 = (long long *)*((_QWORD *)a2 + 2);
if ( (v5 & 0x80000000) != 0LL )
{
v7 = *v6;
v8 = 0xCCCCCCCCCCCCCCCDLL * ((v6[1] - *v6) >> 4);
v5 = v8 + (int)v5;
}
else
{
v5 = (unsigned int)v5;
v7 = *v6;
v8 = 0xCCCCCCCCCCCCCCCDLL * ((v6[1] - *v6) >> 4);
}
if ( v8 <= v5 )
std::__throw_out_of_range_fmt(
"vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",
v5,
v8);
v13 = (const minja::Value *)(80 * v5 + v7);
goto LABEL_21;
}
LABEL_22:
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
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 *)this + 64);
return this;
}
v9 = (unsigned __int8 **)*((_QWORD *)a2 + 4);
if ( !v9 )
goto LABEL_22;
if ( *(_QWORD *)(a3 + 16) || *(_QWORD *)(a3 + 32) || *(_QWORD *)(a3 + 48) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v16, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v17, (long long)"Unashable type: ", (long long)v16);
std::runtime_error::runtime_error(exception, v17);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v10 = *v9;
v11 = v9[1];
if ( *v9 != v11 )
{
v12 = (unsigned __int8 *)(a3 + 64);
while ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::operator==(v10, v12, a4) )
{
v10 += 96;
v11 = v9[1];
if ( v10 == v11 )
goto LABEL_18;
}
v11 = v10;
LABEL_18:
v10 = *(unsigned __int8 **)(*((_QWORD *)a2 + 4) + 8LL);
}
if ( v11 == v10 )
goto LABEL_22;
v13 = (const minja::Value *)(v11 + 16);
LABEL_21:
minja::Value::Value(this, v13);
return this;
}
|
get:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
CMP qword ptr [RSI + 0x10],0x0
JZ 0x0019419a
MOV AL,byte ptr [R15 + 0x40]
ADD AL,0xfb
CMP AL,0x2
JNC 0x00194248
MOV RDI,R15
CALL 0x0019444c
MOV RCX,qword ptr [R14 + 0x10]
TEST EAX,EAX
JS 0x001941f7
MOV EAX,EAX
MOV RSI,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,RSI
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
JMP 0x00194218
LAB_0019419a:
MOV R13,qword ptr [R14 + 0x20]
TEST R13,R13
JZ 0x00194248
CMP qword ptr [R15 + 0x10],0x0
JNZ 0x001942a7
CMP qword ptr [R15 + 0x20],0x0
JNZ 0x001942a7
CMP qword ptr [R15 + 0x30],0x0
JNZ 0x001942a7
MOV R12,qword ptr [R13]
MOV RSI,qword ptr [R13 + 0x8]
CMP R12,RSI
JZ 0x00194235
ADD R15,0x40
LAB_001941d9:
MOV RDI,R12
MOV RSI,R15
CALL 0x00190d94
TEST AL,AL
JNZ 0x0019422a
ADD R12,0x60
MOV RSI,qword ptr [R13 + 0x8]
CMP R12,RSI
JNZ 0x001941d9
JMP 0x0019422d
LAB_001941f7:
MOV RSI,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,RSI
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
CDQE
ADD RAX,RDX
LAB_00194218:
CMP RDX,RAX
JBE 0x00194296
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x4
ADD RSI,RAX
JMP 0x0019423e
LAB_0019422a:
MOV RSI,R12
LAB_0019422d:
MOV RAX,qword ptr [R14 + 0x20]
MOV R12,qword ptr [RAX + 0x8]
LAB_00194235:
CMP RSI,R12
JZ 0x00194248
ADD RSI,0x10
LAB_0019423e:
MOV RDI,RBX
CALL 0x00191452
JMP 0x00194284
LAB_00194248:
LEA R14,[RBX + 0x40]
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015c5ee
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015c5ee
LAB_00194284:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00194296:
LEA RDI,[0x1f3853]
MOV RSI,RAX
XOR EAX,EAX
CALL 0x0011bf60
LAB_001942a7:
MOV EDI,0x10
CALL 0x0011b4d0
MOV RBX,RAX
LAB_001942b4:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0018a0c8
LAB_001942c8:
LEA RSI,[0x1f36e5]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x0017c85d
MOV BPL,0x1
LAB_001942e1:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0011c0a0
XOR EBP,EBP
MOV RSI,qword ptr [0x0022ffe8]
MOV RDX,qword ptr [0x0022ff50]
MOV RDI,RBX
CALL 0x0011c1c0
|
/* minja::Value::get(minja::Value const&) */
Value * minja::Value::get(Value *param_1)
{
long *plVar1;
char cVar2;
uint uVar3;
ulong uVar4;
runtime_error *this;
Value *in_RDX;
ulong uVar5;
long in_RSI;
long lVar6;
Value *pVVar7;
basic_json *pbVar8;
bool bVar9;
basic_json *pbVar10;
int1 local_70 [32];
string local_50 [32];
if (*(long *)(in_RSI + 0x10) == 0) {
plVar1 = *(long **)(in_RSI + 0x20);
if (plVar1 != (long *)0x0) {
if (((*(long *)(in_RDX + 0x10) != 0) || (*(long *)(in_RDX + 0x20) != 0)) ||
(*(long *)(in_RDX + 0x30) != 0)) goto LAB_001942a7;
pbVar10 = (basic_json *)*plVar1;
pbVar8 = (basic_json *)plVar1[1];
if (pbVar10 != pbVar8) {
do {
pbVar8 = pbVar10;
cVar2 = nlohmann::json_abi_v3_11_3::operator==(pbVar8,(basic_json *)(in_RDX + 0x40));
if (cVar2 != '\0') break;
pbVar10 = pbVar8 + 0x60;
pbVar8 = (basic_json *)plVar1[1];
} while (pbVar10 != pbVar8);
pbVar10 = *(basic_json **)(*(long *)(in_RSI + 0x20) + 8);
}
if (pbVar8 != pbVar10) {
pVVar7 = (Value *)(pbVar8 + 0x10);
goto LAB_0019423e;
}
}
}
else if ((byte)((char)in_RDX[0x40] - 5U) < 2) {
uVar3 = get<int>(in_RDX);
plVar1 = *(long **)(in_RSI + 0x10);
if ((int)uVar3 < 0) {
lVar6 = *plVar1;
uVar5 = (plVar1[1] - lVar6 >> 4) * -0x3333333333333333;
uVar4 = (long)(int)uVar3 + uVar5;
}
else {
uVar4 = (ulong)uVar3;
lVar6 = *plVar1;
uVar5 = (plVar1[1] - lVar6 >> 4) * -0x3333333333333333;
}
if (uVar4 < uVar5) {
pVVar7 = (Value *)(lVar6 + uVar4 * 0x50);
LAB_0019423e:
Value(param_1,pVVar7);
return param_1;
}
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",uVar4);
LAB_001942a7:
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001942b4 to 001942c7 has its CatchHandler @ 00194366 */
dump_abi_cxx11_((int)local_70,SUB81(in_RSI,0));
/* try { // try from 001942c8 to 001942dd has its CatchHandler @ 00194346 */
std::operator+((char *)local_50,(string *)"Unashable type: ");
/* try { // try from 001942e1 to 00194305 has its CatchHandler @ 00194306 */
std::runtime_error::runtime_error(this,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0022ffe8,PTR__runtime_error_0022ff50);
}
bVar9 = (bool)((char)param_1 + '@');
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (Value)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar9);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar9);
return param_1;
}
|
|
64,712 |
used_buffs_register_unlock
|
eloqsql/storage/maria/ma_loghandler.c
|
static void
used_buffs_register_unlock(TRUNSLOG_USED_BUFFERS *buffs,
struct st_translog_buffer *buff
__attribute__((unused)) )
{
DBUG_ENTER("used_buffs_register_unlock");
DBUG_PRINT("enter", ("SUB buffs: %p unlk %u (%p) wrt_ptr: %u (%p)"
" buff %p (%u)",
buffs,
buffs->wrt_ptr, buffs->buff[buffs->wrt_ptr],
buffs->unlck_ptr, buffs->buff[buffs->unlck_ptr],
buff, buff->buffer_no));
DBUG_ASSERT(buffs->buff[buffs->unlck_ptr] == buff);
buffs->unlck_ptr++;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
used_buffs_register_unlock:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x3809e
jmp 0x380a0
jmp 0x380a2
movq -0x8(%rbp), %rax
movb 0x19(%rax), %cl
addb $0x1, %cl
movb %cl, 0x19(%rax)
jmp 0x380b1
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
used_buffs_register_unlock:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_3809E:
jmp short $+2
loc_380A0:
jmp short $+2
loc_380A2:
mov rax, [rbp+var_8]
mov cl, [rax+19h]
add cl, 1
mov [rax+19h], cl
jmp short $+2
loc_380B1:
pop rbp
retn
|
long long used_buffs_register_unlock(long long a1)
{
long long result; // rax
result = a1;
++*(_BYTE *)(a1 + 25);
return result;
}
|
used_buffs_register_unlock:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x0013809e
LAB_0013809e:
JMP 0x001380a0
LAB_001380a0:
JMP 0x001380a2
LAB_001380a2:
MOV RAX,qword ptr [RBP + -0x8]
MOV CL,byte ptr [RAX + 0x19]
ADD CL,0x1
MOV byte ptr [RAX + 0x19],CL
JMP 0x001380b1
LAB_001380b1:
POP RBP
RET
|
void used_buffs_register_unlock(long param_1)
{
*(char *)(param_1 + 0x19) = *(char *)(param_1 + 0x19) + '\x01';
return;
}
|
|
64,713 |
YAML::Node YAML::Node::operator[]<char [14]>(char const (&) [14])
|
aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/impl.h
|
inline Node Node::operator[](const Key& key) {
EnsureNodeExists();
detail::node& value = m_pNode->get(key, m_pMemory);
return Node(value, m_pMemory);
}
|
O0
|
c
|
YAML::Node YAML::Node::operator[]<char [14]>(char const (&) [14]):
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1e4a90
movq 0x20(%rsp), %rsi
movq 0x38(%rsi), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x28, %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x1e4c50
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x2bb8a0
movq %rax, 0x40(%rsp)
jmp 0x2bb6c7
leaq 0x68(%rsp), %rdi
callq 0x1e4c80
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rsi
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
addq $0x28, %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1e4c50
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1e4d10
jmp 0x2bb711
leaq 0x48(%rsp), %rdi
callq 0x1e4c80
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1e4c80
jmp 0x2bb75a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1e4c80
movq 0x60(%rsp), %rdi
callq 0x198ce0
nopw %cs:(%rax,%rax)
nop
|
_ZN4YAML4NodeixIA31_cEES0_RKT_:
sub rsp, 98h
mov [rsp+98h+var_88], rdi
mov rax, rdi
mov [rsp+98h+var_80], rax
mov [rsp+98h+var_8], rdi
mov [rsp+98h+var_10], rsi
mov [rsp+98h+var_18], rdx
mov rdi, [rsp+98h+var_10]; this
mov [rsp+98h+var_78], rdi
call _ZNK4YAML4Node16EnsureNodeExistsEv; YAML::Node::EnsureNodeExists(void)
mov rsi, [rsp+98h+var_78]
mov rax, [rsi+38h]
mov [rsp+98h+var_70], rax
mov rax, [rsp+98h+var_18]
mov [rsp+98h+var_68], rax
add rsi, 28h ; '('
lea rdi, [rsp+98h+var_30]
mov [rsp+98h+var_60], rdi
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEEC2ERKS3_; std::shared_ptr<YAML::detail::memory_holder>::shared_ptr(std::shared_ptr<YAML::detail::memory_holder> const&)
mov rdi, [rsp+98h+var_70]
mov rsi, [rsp+98h+var_68]
mov rdx, [rsp+98h+var_60]
call _ZN4YAML6detail4node3getIA31_cEERS1_RKT_St10shared_ptrINS0_13memory_holderEE; YAML::detail::node::get<char [31]>(char [31] const&,std::shared_ptr<YAML::detail::memory_holder>)
mov [rsp+98h+var_58], rax
jmp short $+2
loc_2BB6C7:
lea rdi, [rsp+98h+var_30]
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEED2Ev; std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr()
mov rax, [rsp+98h+var_58]
mov rsi, [rsp+98h+var_78]
mov [rsp+98h+var_20], rax
mov rax, [rsp+98h+var_20]
mov [rsp+98h+var_98], rax
add rsi, 28h ; '('
lea rdi, [rsp+98h+var_50]
mov [rsp+98h+var_90], rdi
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEEC2ERKS3_; std::shared_ptr<YAML::detail::memory_holder>::shared_ptr(std::shared_ptr<YAML::detail::memory_holder> const&)
mov rdi, [rsp+98h+var_88]
mov rsi, [rsp+98h+var_98]
mov rdx, [rsp+98h+var_90]
call _ZN4YAML4NodeC2ERNS_6detail4nodeESt10shared_ptrINS1_13memory_holderEE; YAML::Node::Node(YAML::detail::node &,std::shared_ptr<YAML::detail::memory_holder>)
jmp short $+2
loc_2BB711:
lea rdi, [rsp+98h+var_50]
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEED2Ev; std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr()
mov rax, [rsp+98h+var_80]
add rsp, 98h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_60]
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEED2Ev; std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr()
jmp short loc_2BB75A
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_40]
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEED2Ev; std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr()
loc_2BB75A:
mov rdi, [rsp+arg_58]
call __Unwind_Resume
|
long long YAML::Node::operator[]<char [31]>(long long a1, YAML::Node *a2, long long a3)
{
int v3; // ecx
int v4; // r8d
int v5; // r9d
long long v7; // [rsp+28h] [rbp-70h]
int v8; // [rsp+30h] [rbp-68h]
long long v9; // [rsp+40h] [rbp-58h]
_BYTE v10[32]; // [rsp+48h] [rbp-50h] BYREF
_BYTE v11[16]; // [rsp+68h] [rbp-30h] BYREF
long long v12; // [rsp+78h] [rbp-20h]
long long v13; // [rsp+80h] [rbp-18h]
YAML::Node *v14; // [rsp+88h] [rbp-10h]
long long v15; // [rsp+90h] [rbp-8h]
v15 = a1;
v14 = a2;
v13 = a3;
YAML::Node::EnsureNodeExists((YAML::detail::node **)a2);
v7 = *((_QWORD *)a2 + 7);
v8 = v13;
std::shared_ptr<YAML::detail::memory_holder>::shared_ptr((long long)v11, (long long)a2 + 40);
v9 = YAML::detail::node::get<char [31]>(v7, v8, (unsigned int)v11, v3, v4, v5);
std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr((long long)v11);
v12 = v9;
std::shared_ptr<YAML::detail::memory_holder>::shared_ptr((long long)v10, (long long)a2 + 40);
YAML::Node::Node(a1, v9, (long long)v10);
std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr((long long)v10);
return a1;
}
| |||
64,714 |
YAML::Node YAML::Node::operator[]<char [14]>(char const (&) [14])
|
aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/impl.h
|
inline Node Node::operator[](const Key& key) {
EnsureNodeExists();
detail::node& value = m_pNode->get(key, m_pMemory);
return Node(value, m_pMemory);
}
|
O3
|
c
|
YAML::Node YAML::Node::operator[]<char [14]>(char const (&) [14]):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x9d0a4
movq 0x28(%r15), %rax
movq 0x38(%r15), %rdi
movq %rax, (%rsp)
movq 0x30(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xa1c97
movq 0x1ff03f(%rip), %rcx # 0x2a0cc8
cmpb $0x0, (%rcx)
je 0xa1c93
incl 0x8(%rax)
jmp 0xa1c97
lock
incl 0x8(%rax)
movq %rsp, %rdx
movq %r14, %rsi
callq 0xa3866
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa1cb4
callq 0x81a00
movq 0x28(%r15), %rax
movq 0x30(%r15), %rdi
testq %rdi, %rdi
je 0xa1cf1
movq 0x1ff000(%rip), %rdx # 0x2a0cc8
leaq 0x18(%rbx), %rcx
cmpb $0x0, (%rdx)
je 0xa1d14
incl 0x8(%rdi)
movb $0x1, (%rbx)
movq %rcx, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movq %rax, 0x28(%rbx)
movq %rdi, 0x30(%rbx)
jmp 0xa1d38
movb $0x1, (%rbx)
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movq %rax, 0x28(%rbx)
movq %rcx, 0x30(%rbx)
movq %r14, 0x38(%rbx)
jmp 0xa1d44
lock
incl 0x8(%rdi)
cmpb $0x0, (%rdx)
movb $0x1, (%rbx)
movq %rcx, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movq %rax, 0x28(%rbx)
movq %rdi, 0x30(%rbx)
je 0xa1d51
incl 0x8(%rdi)
movq %r14, 0x38(%rbx)
callq 0x81a00
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
lock
incl 0x8(%rdi)
jmp 0xa1d3b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa1d69
callq 0x81a00
movq %rbx, %rdi
callq 0x83b70
nop
|
_ZN4YAML4NodeixIA20_cEES0_RKT_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdi, rsi; this
call _ZNK4YAML4Node16EnsureNodeExistsEv; YAML::Node::EnsureNodeExists(void)
mov rax, [r15+28h]
mov rdi, [r15+38h]; YAML::detail::node *
mov qword ptr [rsp+28h+var_28], rax; int
mov rax, [r15+30h]
mov [rsp+28h+var_20], rax; __int64
test rax, rax
jz short loc_A1C97
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_A1C93
inc dword ptr [rax+8]
jmp short loc_A1C97
loc_A1C93:
lock inc dword ptr [rax+8]
loc_A1C97:
mov rdx, rsp
mov rsi, r14
call _ZN4YAML6detail4node3getIA20_cEERS1_RKT_St10shared_ptrINS0_13memory_holderEE; YAML::detail::node::get<char [20]>(char [20] const&,std::shared_ptr<YAML::detail::memory_holder>)
mov r14, rax
mov rdi, [rsp+28h+var_20]
test rdi, rdi
jz short loc_A1CB4
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A1CB4:
mov rax, [r15+28h]
mov rdi, [r15+30h]
test rdi, rdi
jz short loc_A1CF1
mov rdx, cs:__libc_single_threaded_ptr
lea rcx, [rbx+18h]
cmp byte ptr [rdx], 0
jz short loc_A1D14
inc dword ptr [rdi+8]
mov byte ptr [rbx], 1
mov [rbx+8], rcx
mov qword ptr [rbx+10h], 0
mov byte ptr [rbx+18h], 0
mov [rbx+28h], rax
mov [rbx+30h], rdi
jmp short loc_A1D38
loc_A1CF1:
mov byte ptr [rbx], 1
lea rcx, [rbx+18h]
mov [rbx+8], rcx
xor ecx, ecx
mov [rbx+10h], rcx
mov byte ptr [rbx+18h], 0
mov [rbx+28h], rax
mov [rbx+30h], rcx
mov [rbx+38h], r14
jmp short loc_A1D44
loc_A1D14:
lock inc dword ptr [rdi+8]
cmp byte ptr [rdx], 0
mov byte ptr [rbx], 1
mov [rbx+8], rcx
mov qword ptr [rbx+10h], 0
mov byte ptr [rbx+18h], 0
mov [rbx+28h], rax
mov [rbx+30h], rdi
jz short loc_A1D51
loc_A1D38:
inc dword ptr [rdi+8]
loc_A1D3B:
mov [rbx+38h], r14
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A1D44:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_A1D51:
lock inc dword ptr [rdi+8]
jmp short loc_A1D3B
mov rbx, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_A1D69
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A1D69:
mov rdi, rbx
call __Unwind_Resume
|
long long YAML::Node::operator[]<char [20]>(long long a1, long long a2)
{
YAML::detail::node *v3; // rdi
long long v4; // rax
long long v5; // r14
long long v6; // rax
long long v7; // rdi
long long v8; // rcx
bool v9; // zf
int v11[2]; // [rsp+0h] [rbp-28h]
long long v12; // [rsp+8h] [rbp-20h]
YAML::Node::EnsureNodeExists((YAML::detail::memory ***)a2);
v3 = *(YAML::detail::node **)(a2 + 56);
*(_QWORD *)v11 = *(_QWORD *)(a2 + 40);
v4 = *(_QWORD *)(a2 + 48);
if ( v4 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v4 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v4 + 8));
}
v5 = YAML::detail::node::get<char [20]>(v3, v11[0], v4);
if ( v12 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v12);
v6 = *(_QWORD *)(a2 + 40);
v7 = *(_QWORD *)(a2 + 48);
if ( v7 )
{
v8 = a1 + 24;
if ( _libc_single_threaded )
{
++*(_DWORD *)(v7 + 8);
*(_BYTE *)a1 = 1;
*(_QWORD *)(a1 + 8) = v8;
*(_QWORD *)(a1 + 16) = 0LL;
*(_BYTE *)(a1 + 24) = 0;
*(_QWORD *)(a1 + 40) = v6;
*(_QWORD *)(a1 + 48) = v7;
}
else
{
_InterlockedIncrement((volatile signed __int32 *)(v7 + 8));
v9 = _libc_single_threaded == 0;
*(_BYTE *)a1 = 1;
*(_QWORD *)(a1 + 8) = v8;
*(_QWORD *)(a1 + 16) = 0LL;
*(_BYTE *)(a1 + 24) = 0;
*(_QWORD *)(a1 + 40) = v6;
*(_QWORD *)(a1 + 48) = v7;
if ( v9 )
{
_InterlockedIncrement((volatile signed __int32 *)(v7 + 8));
goto LABEL_13;
}
}
++*(_DWORD *)(v7 + 8);
LABEL_13:
*(_QWORD *)(a1 + 56) = v5;
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v7);
return a1;
}
*(_BYTE *)a1 = 1;
*(_QWORD *)(a1 + 8) = a1 + 24;
*(_QWORD *)(a1 + 16) = 0LL;
*(_BYTE *)(a1 + 24) = 0;
*(_QWORD *)(a1 + 40) = v6;
*(_QWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 56) = v5;
return a1;
}
|
operator[]<char[20]>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x0019d0a4
MOV RAX,qword ptr [R15 + 0x28]
MOV RDI,qword ptr [R15 + 0x38]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [R15 + 0x30]
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x001a1c97
MOV RCX,qword ptr [0x003a0cc8]
CMP byte ptr [RCX],0x0
JZ 0x001a1c93
INC dword ptr [RAX + 0x8]
JMP 0x001a1c97
LAB_001a1c93:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001a1c97:
MOV RDX,RSP
MOV RSI,R14
CALL 0x001a3866
LAB_001a1ca2:
MOV R14,RAX
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x001a1cb4
CALL 0x00181a00
LAB_001a1cb4:
MOV RAX,qword ptr [R15 + 0x28]
MOV RDI,qword ptr [R15 + 0x30]
TEST RDI,RDI
JZ 0x001a1cf1
MOV RDX,qword ptr [0x003a0cc8]
LEA RCX,[RBX + 0x18]
CMP byte ptr [RDX],0x0
JZ 0x001a1d14
INC dword ptr [RDI + 0x8]
MOV byte ptr [RBX],0x1
MOV qword ptr [RBX + 0x8],RCX
MOV qword ptr [RBX + 0x10],0x0
MOV byte ptr [RBX + 0x18],0x0
MOV qword ptr [RBX + 0x28],RAX
MOV qword ptr [RBX + 0x30],RDI
JMP 0x001a1d38
LAB_001a1cf1:
MOV byte ptr [RBX],0x1
LEA RCX,[RBX + 0x18]
MOV qword ptr [RBX + 0x8],RCX
XOR ECX,ECX
MOV qword ptr [RBX + 0x10],RCX
MOV byte ptr [RBX + 0x18],0x0
MOV qword ptr [RBX + 0x28],RAX
MOV qword ptr [RBX + 0x30],RCX
MOV qword ptr [RBX + 0x38],R14
JMP 0x001a1d44
LAB_001a1d14:
INC.LOCK dword ptr [RDI + 0x8]
CMP byte ptr [RDX],0x0
MOV byte ptr [RBX],0x1
MOV qword ptr [RBX + 0x8],RCX
MOV qword ptr [RBX + 0x10],0x0
MOV byte ptr [RBX + 0x18],0x0
MOV qword ptr [RBX + 0x28],RAX
MOV qword ptr [RBX + 0x30],RDI
JZ 0x001a1d51
LAB_001a1d38:
INC dword ptr [RDI + 0x8]
LAB_001a1d3b:
MOV qword ptr [RBX + 0x38],R14
CALL 0x00181a00
LAB_001a1d44:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
LAB_001a1d51:
INC.LOCK dword ptr [RDI + 0x8]
JMP 0x001a1d3b
|
/* YAML::Node YAML::Node::operator[]<char [20]>(char const (&) [20]) */
char * YAML::Node::operator[]<char[20]>(char *param_1)
{
char cVar1;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var2;
int8 uVar3;
int *puVar4;
node *pnVar5;
Node *in_RSI;
EnsureNodeExists(in_RSI);
pnVar5 = *(node **)(in_RSI + 0x38);
p_Var2 = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(in_RSI + 0x30);
if (p_Var2 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_003a0cc8 == '\0') {
LOCK();
*(int *)(p_Var2 + 8) = *(int *)(p_Var2 + 8) + 1;
UNLOCK();
}
else {
*(int *)(p_Var2 + 8) = *(int *)(p_Var2 + 8) + 1;
}
}
/* try { // try from 001a1c97 to 001a1ca1 has its CatchHandler @ 001a1d57 */
pnVar5 = detail::node::get<char[20]>(pnVar5);
if (p_Var2 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Var2);
}
puVar4 = PTR___libc_single_threaded_003a0cc8;
uVar3 = *(int8 *)(in_RSI + 0x28);
p_Var2 = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(in_RSI + 0x30);
if (p_Var2 == (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
*param_1 = '\x01';
*(char **)(param_1 + 8) = param_1 + 0x18;
param_1[0x10] = '\0';
param_1[0x11] = '\0';
param_1[0x12] = '\0';
param_1[0x13] = '\0';
param_1[0x14] = '\0';
param_1[0x15] = '\0';
param_1[0x16] = '\0';
param_1[0x17] = '\0';
param_1[0x18] = '\0';
*(int8 *)(param_1 + 0x28) = uVar3;
param_1[0x30] = '\0';
param_1[0x31] = '\0';
param_1[0x32] = '\0';
param_1[0x33] = '\0';
param_1[0x34] = '\0';
param_1[0x35] = '\0';
param_1[0x36] = '\0';
param_1[0x37] = '\0';
*(node **)(param_1 + 0x38) = pnVar5;
return param_1;
}
if (*PTR___libc_single_threaded_003a0cc8 == '\0') {
LOCK();
*(int *)(p_Var2 + 8) = *(int *)(p_Var2 + 8) + 1;
UNLOCK();
cVar1 = *puVar4;
*param_1 = '\x01';
*(char **)(param_1 + 8) = param_1 + 0x18;
param_1[0x10] = '\0';
param_1[0x11] = '\0';
param_1[0x12] = '\0';
param_1[0x13] = '\0';
param_1[0x14] = '\0';
param_1[0x15] = '\0';
param_1[0x16] = '\0';
param_1[0x17] = '\0';
param_1[0x18] = '\0';
*(int8 *)(param_1 + 0x28) = uVar3;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(param_1 + 0x30) = p_Var2;
if (cVar1 == '\0') {
LOCK();
*(int *)(p_Var2 + 8) = *(int *)(p_Var2 + 8) + 1;
UNLOCK();
goto LAB_001a1d3b;
}
}
else {
*(int *)(p_Var2 + 8) = *(int *)(p_Var2 + 8) + 1;
*param_1 = '\x01';
*(char **)(param_1 + 8) = param_1 + 0x18;
param_1[0x10] = '\0';
param_1[0x11] = '\0';
param_1[0x12] = '\0';
param_1[0x13] = '\0';
param_1[0x14] = '\0';
param_1[0x15] = '\0';
param_1[0x16] = '\0';
param_1[0x17] = '\0';
param_1[0x18] = '\0';
*(int8 *)(param_1 + 0x28) = uVar3;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(param_1 + 0x30) = p_Var2;
}
*(int *)(p_Var2 + 8) = *(int *)(p_Var2 + 8) + 1;
LAB_001a1d3b:
*(node **)(param_1 + 0x38) = pnVar5;
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Var2);
return param_1;
}
|
|
64,715 |
coro::context::start()
|
tinyCoroLab/src/context.cpp
|
auto context::start() noexcept -> void
{
// TODO[lab2b]: Add you codes
m_job = make_unique<jthread>(
[this](stop_token token)
{
this->init();
this->run(token);
this->deinit();
});
}
|
O0
|
cpp
|
coro::context::start():
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x69b90
jmp 0x69b59
movq 0x8(%rsp), %rdi
addq $0x20240, %rdi # imm = 0x20240
leaq 0x18(%rsp), %rsi
callq 0x6a350
leaq 0x18(%rsp), %rdi
callq 0xd020
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0xc1d0
nopw %cs:(%rax,%rax)
|
_ZN4coro7context5startEv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_20], rax; void *
mov qword ptr [rsp+28h+var_18], rax; int
lea rdi, [rsp+28h+var_10]; int
lea rsi, [rsp+28h+var_18]
call _ZSt11make_uniqueISt7jthreadJZN4coro7context5startEvE3$_0EENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<std::jthread,coro::context::start(void)::$_0>(coro::context::start(void)::$_0 &&)
jmp short $+2
loc_69B59:
mov rdi, [rsp+28h+var_20]
add rdi, 20240h
lea rsi, [rsp+28h+var_10]
call _ZNSt10unique_ptrISt7jthreadSt14default_deleteIS0_EEaSEOS3_; std::unique_ptr<std::jthread>::operator=(std::unique_ptr<std::jthread>&&)
lea rdi, [rsp+28h+var_10]
call _ZNSt10unique_ptrISt7jthreadSt14default_deleteIS0_EED2Ev; std::unique_ptr<std::jthread>::~unique_ptr()
add rsp, 28h
retn
mov rdi, rax
call __clang_call_terminate
|
_QWORD * coro::context::start(coro::context *this)
{
int v2; // [rsp+0h] [rbp-28h]
char *v3; // [rsp+8h] [rbp-20h]
long long v4[2]; // [rsp+18h] [rbp-10h] BYREF
v4[1] = (long long)this;
std::make_unique<std::jthread,coro::context::start(void)::$_0>((int)v4, v2, this, (int)this, v4[0]);
std::unique_ptr<std::jthread>::operator=(v3 + 131648, v4);
return std::unique_ptr<std::jthread>::~unique_ptr((long long)v4);
}
|
start:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RAX
LAB_00169b48:
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x10]
CALL 0x00169b90
JMP 0x00169b59
LAB_00169b59:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x20240
LEA RSI,[RSP + 0x18]
CALL 0x0016a350
LEA RDI,[RSP + 0x18]
CALL 0x0010d020
ADD RSP,0x28
RET
|
/* coro::context::start() */
void __thiscall coro::context::start(context *this)
{
__0 local_10 [8];
context *local_8;
/* try { // try from 00169b48 to 00169b56 has its CatchHandler @ 00169b7e */
local_8 = this;
std::make_unique<std::jthread,coro::context::start()::__0>(local_10);
std::unique_ptr<std::jthread,std::default_delete<std::jthread>>::operator=
((unique_ptr<std::jthread,std::default_delete<std::jthread>> *)(this + 0x20240),
(unique_ptr *)local_10);
std::unique_ptr<std::jthread,std::default_delete<std::jthread>>::~unique_ptr
((unique_ptr<std::jthread,std::default_delete<std::jthread>> *)local_10);
return;
}
|
|
64,716 |
my_mb_wc_eucjpms
|
eloqsql/strings/ctype-eucjpms.c
|
static int
my_mb_wc_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII code set: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
if (hi >= 0xA1 && hi <= 0xFE) /* JIS X 0208 code set: [A1..FE][A1..FE] */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
return (*pwc= jisx0208_eucjpms_to_unicode[(hi << 8) + s[1]]) ? 2 :
(s[1] < 0xA1 || s[1] > 0xFE) ? MY_CS_ILSEQ : -2;
}
/* JIS-X-0201 HALF WIDTH KATAKANA: [8E][A1..DF] -> [U+FF61..U+FF9F] */
if (hi == 0x8E)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (s[1] < 0xA1 || s[1] > 0xDF)
return MY_CS_ILSEQ;
*pwc= 0xFEC0 + s[1]; /* 0xFFC0 = 0xFF61 - 0xA1 */
return 2;
}
if (hi == 0x8F) /* JIS X 0212 code set: [8F][A1..FE][A1..FE] */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
return (*pwc= jisx0212_eucjpms_to_unicode[(((int) s[1]) << 8) + s[2]]) ?
3 :
(s[1] < 0xA1 || s[1] > 0xFE || s[2] < 0xA1 || s[2] > 0xFE) ?
MY_CS_ILSEQ : -3;
}
return MY_CS_ILSEQ;
}
|
O3
|
c
|
my_mb_wc_eucjpms:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xba1c6
movzbl (%rdx), %edi
testb %dil, %dil
js 0xba1c8
movq %rdi, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leal 0x5f(%rdi), %eax
cmpb $0x5d, %al
ja 0xba214
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xba1c6
movzbl 0x1(%rdx), %eax
shll $0x9, %edi
leal (%rdi,%rax,2), %eax
leaq 0xadc02(%rip), %rcx # 0x167df0
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0xba1c6
movb 0x1(%rdx), %al
incb %al
xorl %ecx, %ecx
cmpb $-0x5e, %al
setb %cl
leal -0x2(,%rcx,2), %eax
jmp 0xba1c6
cmpq $0x8f, %rdi
je 0xba258
cmpl $0x8e, %edi
jne 0xba29a
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0xba1c6
movzbl 0x1(%rdx), %ecx
leal 0x20(%rcx), %edx
movl $0x0, %eax
cmpb $-0x3f, %dl
jb 0xba1c6
addq $0xfec0, %rcx # imm = 0xFEC0
movq %rcx, (%rsi)
movl $0x2, %eax
jmp 0xba1c6
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0xba1c6
movzwl 0x1(%rdx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq 0xcdb74(%rip), %rcx # 0x187df0
movzwl (%rcx,%rax,2), %ecx
movq %rcx, (%rsi)
movl $0x3, %eax
testq %rcx, %rcx
jne 0xba1c6
movb 0x1(%rdx), %al
incb %al
cmpb $-0x5e, %al
jae 0xba2a1
xorl %eax, %eax
jmp 0xba1c6
movb 0x2(%rdx), %cl
movl $0x0, %eax
cmpb $-0x5f, %cl
jb 0xba1c6
xorl %eax, %eax
cmpb $-0x1, %cl
sete %al
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
jmp 0xba1c6
|
my_mb_wc_eucjpms:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_BA1C6
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_BA1C8
mov [rsi], rdi
mov eax, 1
loc_BA1C6:
pop rbp
retn
loc_BA1C8:
lea eax, [rdi+5Fh]
cmp al, 5Dh ; ']'
ja short loc_BA214
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_BA1C6
movzx eax, byte ptr [rdx+1]
shl edi, 9
lea eax, [rdi+rax*2]
lea rcx, jisx0208_eucjpms_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_BA1C6
mov al, [rdx+1]
inc al
xor ecx, ecx
cmp al, 0A2h
setb cl
lea eax, ds:0FFFFFFFFFFFFFFFEh[rcx*2]
jmp short loc_BA1C6
loc_BA214:
cmp rdi, 8Fh
jz short loc_BA258
cmp edi, 8Eh
jnz short loc_BA29A
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_BA1C6
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx+20h]
mov eax, 0
cmp dl, 0C1h
jb short loc_BA1C6
add rcx, 0FEC0h
mov [rsi], rcx
mov eax, 2
jmp loc_BA1C6
loc_BA258:
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_BA1C6
movzx eax, word ptr [rdx+1]
rol ax, 8
movzx eax, ax
lea rcx, jisx0212_eucjpms_to_unicode
movzx ecx, word ptr [rcx+rax*2]
mov [rsi], rcx
mov eax, 3
test rcx, rcx
jnz loc_BA1C6
mov al, [rdx+1]
inc al
cmp al, 0A2h
jnb short loc_BA2A1
loc_BA29A:
xor eax, eax
jmp loc_BA1C6
loc_BA2A1:
mov cl, [rdx+2]
mov eax, 0
cmp cl, 0A1h
jb loc_BA1C6
xor eax, eax
cmp cl, 0FFh
setz al
lea eax, [rax+rax*2]
add eax, 0FFFFFFFDh
jmp loc_BA1C6
|
long long my_mb_wc_eucjpms(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
long long v7; // rcx
long long v8; // rcx
unsigned __int8 v9; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x5Du )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = jisx0208_eucjpms_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
return 2 * (unsigned int)((unsigned __int8)(a3[1] + 1) < 0xA2u) - 2;
}
return result;
}
if ( v5 != 143 )
{
if ( (_DWORD)v5 == 142 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v7 = a3[1];
result = 0LL;
if ( (unsigned __int8)(v7 + 32) >= 0xC1u )
{
*a2 = v7 + 65216;
return 2LL;
}
}
return result;
}
return 0LL;
}
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) > a4 )
return result;
v8 = jisx0212_eucjpms_to_unicode[(unsigned __int16)__ROL2__(*(_WORD *)(a3 + 1), 8)];
*a2 = v8;
result = 3LL;
if ( v8 )
return result;
if ( (unsigned __int8)(a3[1] + 1) < 0xA2u )
return 0LL;
v9 = a3[2];
result = 0LL;
if ( v9 >= 0xA1u )
return 3 * (unsigned int)(v9 == 0xFF) - 3;
return result;
}
|
my_mb_wc_eucjpms:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001ba1c6
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x001ba1c8
MOV qword ptr [RSI],RDI
MOV EAX,0x1
LAB_001ba1c6:
POP RBP
RET
LAB_001ba1c8:
LEA EAX,[RDI + 0x5f]
CMP AL,0x5d
JA 0x001ba214
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001ba1c6
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EDI,0x9
LEA EAX,[RDI + RAX*0x2]
LEA RCX,[0x267df0]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x001ba1c6
MOV AL,byte ptr [RDX + 0x1]
INC AL
XOR ECX,ECX
CMP AL,0xa2
SETC CL
LEA EAX,[-0x2 + RCX*0x2]
JMP 0x001ba1c6
LAB_001ba214:
CMP RDI,0x8f
JZ 0x001ba258
CMP EDI,0x8e
JNZ 0x001ba29a
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001ba1c6
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + 0x20]
MOV EAX,0x0
CMP DL,0xc1
JC 0x001ba1c6
ADD RCX,0xfec0
MOV qword ptr [RSI],RCX
MOV EAX,0x2
JMP 0x001ba1c6
LAB_001ba258:
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x001ba1c6
MOVZX EAX,word ptr [RDX + 0x1]
ROL AX,0x8
MOVZX EAX,AX
LEA RCX,[0x287df0]
MOVZX ECX,word ptr [RCX + RAX*0x2]
MOV qword ptr [RSI],RCX
MOV EAX,0x3
TEST RCX,RCX
JNZ 0x001ba1c6
MOV AL,byte ptr [RDX + 0x1]
INC AL
CMP AL,0xa2
JNC 0x001ba2a1
LAB_001ba29a:
XOR EAX,EAX
JMP 0x001ba1c6
LAB_001ba2a1:
MOV CL,byte ptr [RDX + 0x2]
MOV EAX,0x0
CMP CL,0xa1
JC 0x001ba1c6
XOR EAX,EAX
CMP CL,0xff
SETZ AL
LEA EAX,[RAX + RAX*0x2]
ADD EAX,-0x3
JMP 0x001ba1c6
|
int my_mb_wc_eucjpms(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if ((byte)(bVar1 + 0x5f) < 0x5e) {
iVar3 = -0x66;
if (param_3 + 2 <= param_4) {
uVar2 = *(ushort *)
(jisx0208_eucjpms_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
iVar3 = 2;
if ((ulong)uVar2 == 0) {
iVar3 = (uint)((byte)(param_3[1] + 1) < 0xa2) * 2 + -2;
}
}
}
else {
if ((ulong)bVar1 == 0x8f) {
if (param_4 < param_3 + 3) {
return -0x67;
}
uVar2 = *(ushort *)
(&jisx0212_eucjpms_to_unicode +
(ulong)(ushort)(*(ushort *)(param_3 + 1) << 8 | *(ushort *)(param_3 + 1) >> 8) *
2);
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 3;
}
if (0xa1 < (byte)(param_3[1] + 1)) {
if (param_3[2] < 0xa1) {
return 0;
}
return (uint)(param_3[2] == 0xff) * 3 + -3;
}
}
else if (bVar1 == 0x8e) {
if (param_4 < param_3 + 2) {
return -0x66;
}
if ((byte)(param_3[1] + 0x20) < 0xc1) {
return 0;
}
*param_2 = (ulong)param_3[1] + 0xfec0;
return 2;
}
iVar3 = 0;
}
}
else {
*param_2 = (ulong)bVar1;
iVar3 = 1;
}
}
return iVar3;
}
|
|
64,717 |
my_caseup_utf8mb4
|
eloqsql/strings/ctype-utf8.c
|
static size_t
my_caseup_utf8mb4(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->caseup_multiply == 1);
while ((src < srcend) &&
(srcres= my_mb_wc_utf8mb4(cs, &wc,
(uchar *) src, (uchar*) srcend)) > 0)
{
my_toupper_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
}
|
O3
|
c
|
my_caseup_utf8mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x38(%rbp)
movq %rcx, %r13
movq %rcx, -0x30(%rbp)
testq %rdx, %rdx
jle 0xcbd39
movq %rdx, %r15
movq %rsi, %r12
addq %rsi, %r15
movq -0x30(%rbp), %r13
addq %r13, -0x38(%rbp)
movq 0x78(%rdi), %r14
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xcedca
testl %eax, %eax
jle 0xcbd39
movl %eax, %ebx
movq -0x40(%rbp), %rsi
cmpq (%r14), %rsi
ja 0xcbd1a
movq 0x8(%r14), %rax
movq %rsi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0xcbd1a
movzbl %sil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,4), %esi
movq %rsi, -0x40(%rbp)
movq %r13, %rdx
movq -0x38(%rbp), %rcx
callq 0xcbab9
testl %eax, %eax
jle 0xcbd39
movl %ebx, %ecx
addq %rcx, %r12
movl %eax, %eax
addq %rax, %r13
cmpq %r15, %r12
jb 0xcbcd9
subq -0x30(%rbp), %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_caseup_utf8mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_38], r8
mov r13, rcx
mov [rbp+var_30], rcx
test rdx, rdx
jle short loc_CBD39
mov r15, rdx
mov r12, rsi
add r15, rsi
mov r13, [rbp+var_30]
add [rbp+var_38], r13
mov r14, [rdi+78h]
loc_CBCD9:
lea rdi, [rbp+var_40]
mov rsi, r12
mov rdx, r15
call my_mb_wc_utf8mb4_quick_0
test eax, eax
jle short loc_CBD39
mov ebx, eax
mov rsi, [rbp+var_40]
cmp rsi, [r14]
ja short loc_CBD1A
mov rax, [r14+8]
mov rcx, rsi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_CBD1A
movzx ecx, sil
lea rcx, [rcx+rcx*2]
mov esi, [rax+rcx*4]
mov [rbp+var_40], rsi
loc_CBD1A:
mov rdx, r13
mov rcx, [rbp+var_38]
call my_wc_mb_utf8mb4
test eax, eax
jle short loc_CBD39
mov ecx, ebx
add r12, rcx
mov eax, eax
add r13, rax
cmp r12, r15
jb short loc_CBCD9
loc_CBD39:
sub r13, [rbp+var_30]
mov rax, r13
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_BYTE * my_caseup_utf8mb4(long long a1, unsigned long long a2, long long a3, _BYTE *a4, unsigned long long a5)
{
_BYTE *v5; // r13
unsigned long long v6; // r12
unsigned long long v7; // r15
unsigned long long *v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rsi
long long v12; // rax
int v13; // eax
unsigned long long v15; // [rsp+0h] [rbp-40h] BYREF
unsigned long long v16; // [rsp+8h] [rbp-38h]
_BYTE *v17; // [rsp+10h] [rbp-30h]
v16 = a5;
v5 = a4;
v17 = a4;
if ( a3 > 0 )
{
v6 = a2;
v7 = a2 + a3;
v5 = v17;
v16 += (unsigned long long)v17;
v8 = *(unsigned long long **)(a1 + 120);
do
{
v9 = my_mb_wc_utf8mb4_quick_0(&v15, v6, v7);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v15;
if ( v15 <= *v8 )
{
v12 = *(_QWORD *)(v8[1] + 8 * (v15 >> 8));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v15);
v15 = v11;
}
}
v13 = my_wc_mb_utf8mb4((long long)&v15, v11, v5, v16);
if ( v13 <= 0 )
break;
v6 += v10;
v5 += (unsigned int)v13;
}
while ( v6 < v7 );
}
return (_BYTE *)(v5 - v17);
}
|
my_caseup_utf8mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x38],R8
MOV R13,RCX
MOV qword ptr [RBP + -0x30],RCX
TEST RDX,RDX
JLE 0x001cbd39
MOV R15,RDX
MOV R12,RSI
ADD R15,RSI
MOV R13,qword ptr [RBP + -0x30]
ADD qword ptr [RBP + -0x38],R13
MOV R14,qword ptr [RDI + 0x78]
LAB_001cbcd9:
LEA RDI,[RBP + -0x40]
MOV RSI,R12
MOV RDX,R15
CALL 0x001cedca
TEST EAX,EAX
JLE 0x001cbd39
MOV EBX,EAX
MOV RSI,qword ptr [RBP + -0x40]
CMP RSI,qword ptr [R14]
JA 0x001cbd1a
MOV RAX,qword ptr [R14 + 0x8]
MOV RCX,RSI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x001cbd1a
MOVZX ECX,SIL
LEA RCX,[RCX + RCX*0x2]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV qword ptr [RBP + -0x40],RSI
LAB_001cbd1a:
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0x38]
CALL 0x001cbab9
TEST EAX,EAX
JLE 0x001cbd39
MOV ECX,EBX
ADD R12,RCX
MOV EAX,EAX
ADD R13,RAX
CMP R12,R15
JC 0x001cbcd9
LAB_001cbd39:
SUB R13,qword ptr [RBP + -0x30]
MOV RAX,R13
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_caseup_utf8mb4(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
ulong *puVar1;
long lVar2;
uint uVar3;
uint uVar4;
ulong uVar5;
ulong local_48;
long local_40;
long local_38;
local_38 = param_4;
if (0 < param_3) {
uVar5 = param_3 + param_2;
local_40 = param_5 + param_4;
puVar1 = *(ulong **)(param_1 + 0x78);
do {
uVar3 = my_mb_wc_utf8mb4_quick(&local_48,param_2,uVar5);
if ((int)uVar3 < 1) break;
if ((local_48 <= *puVar1) && (lVar2 = *(long *)(puVar1[1] + (local_48 >> 8) * 8), lVar2 != 0))
{
local_48 = (ulong)*(uint *)(lVar2 + (local_48 & 0xff) * 0xc);
}
uVar4 = my_wc_mb_utf8mb4();
if ((int)uVar4 < 1) break;
param_2 = param_2 + uVar3;
param_4 = param_4 + (ulong)uVar4;
} while (param_2 < uVar5);
}
return param_4 - local_38;
}
|
|
64,718 |
range_map<unsigned int>::get(unsigned int)
|
msxemulator/build_O3/_deps/picotool-src/main.cpp
|
pair<mapping, T> get(uint32_t p) {
auto f = m.upper_bound(p);
if (f == m.end()) {
if (m.empty())
throw not_mapped_exception();
} else if (f == m.begin()) {
throw not_mapped_exception();
}
f--;
assert(p >= f->first);
if (p >= f->second.first) {
throw not_mapped_exception();
}
return std::make_pair(mapping(p - f->first, f->second.first - f->first), f->second.second);
}
|
O3
|
cpp
|
range_map<unsigned int>::get(unsigned int):
pushq %rbx
movl %esi, %ebx
movq %rdi, %rax
movq 0x10(%rdi), %rdx
leaq 0x8(%rdi), %rcx
testq %rdx, %rdx
je 0x5264c
movq %rcx, %rdi
xorl %esi, %esi
cmpl %ebx, 0x20(%rdx)
cmovaq %rdx, %rdi
setbe %sil
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x52628
cmpq %rcx, %rdi
je 0x5264f
cmpq 0x18(%rax), %rdi
jne 0x52656
jmp 0x52678
movq %rcx, %rdi
cmpq $0x0, 0x28(%rax)
je 0x52678
callq 0xf4b0
movl 0x24(%rax), %ecx
cmpl %ebx, %ecx
jbe 0x52678
movl 0x20(%rax), %esi
movl 0x28(%rax), %edx
subl %esi, %ebx
subl %esi, %ecx
shlq $0x20, %rcx
orq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
movl $0x8, %edi
callq 0xf260
leaq 0x8e0cf(%rip), %rcx # 0xe0758
movq %rcx, (%rax)
leaq 0x8d2a5(%rip), %rsi # 0xdf938
movq 0x9293e(%rip), %rdx # 0xe4fd8
movq %rax, %rdi
callq 0xf790
|
_ZN9range_mapIjE3getEj:
push rbx
mov ebx, esi
mov rax, rdi
mov rdx, [rdi+10h]
lea rcx, [rdi+8]
test rdx, rdx
jz short loc_5264C
mov rdi, rcx
loc_52628:
xor esi, esi
cmp [rdx+20h], ebx
cmova rdi, rdx
setbe sil
mov rdx, [rdx+rsi*8+10h]
test rdx, rdx
jnz short loc_52628
cmp rdi, rcx
jz short loc_5264F
cmp rdi, [rax+18h]
jnz short loc_52656
jmp short loc_52678
loc_5264C:
mov rdi, rcx
loc_5264F:
cmp qword ptr [rax+28h], 0
jz short loc_52678
loc_52656:
call __ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base; std::_Rb_tree_decrement(std::_Rb_tree_node_base *)
mov ecx, [rax+24h]
cmp ecx, ebx
jbe short loc_52678
mov esi, [rax+20h]
mov edx, [rax+28h]
sub ebx, esi
sub ecx, esi
shl rcx, 20h
or rbx, rcx
mov rax, rbx
pop rbx
retn
loc_52678:
mov edi, 8; thrown_size
call ___cxa_allocate_exception
lea rcx, off_E0758
mov [rax], rcx
lea rsi, _ZTI20not_mapped_exception; lptinfo
mov rdx, cs:_ZNSt9exceptionD2Ev_ptr; void (*)(void *)
mov rdi, rax; void *
call ___cxa_throw
|
unsigned long long range_map<unsigned int>::get(_QWORD *a1, unsigned int a2)
{
long long v4; // rdx
_QWORD *v5; // rcx
_QWORD *v6; // rdi
long long v7; // rsi
long long v8; // rax
unsigned int v9; // ecx
_QWORD *exception; // rax
v4 = a1[2];
v5 = a1 + 1;
if ( !v4 )
{
v6 = a1 + 1;
goto LABEL_10;
}
v6 = a1 + 1;
do
{
v7 = 0LL;
if ( *(_DWORD *)(v4 + 32) > a2 )
v6 = (_QWORD *)v4;
LOBYTE(v7) = *(_DWORD *)(v4 + 32) <= a2;
v4 = *(_QWORD *)(v4 + 8 * v7 + 16);
}
while ( v4 );
if ( v6 == v5 )
{
LABEL_10:
if ( !a1[5] )
goto LABEL_13;
goto LABEL_11;
}
if ( v6 == (_QWORD *)a1[3] )
{
LABEL_13:
exception = __cxa_allocate_exception(8uLL);
*exception = off_E0758;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'not_mapped_exception,
(void (*)(void *))&std::exception::~exception);
}
LABEL_11:
v8 = std::_Rb_tree_decrement(v6);
v9 = *(_DWORD *)(v8 + 36);
if ( v9 <= a2 )
goto LABEL_13;
return ((unsigned long long)(v9 - *(_DWORD *)(v8 + 32)) << 32) | (a2 - *(_DWORD *)(v8 + 32));
}
|
get:
PUSH RBX
MOV EBX,ESI
MOV RAX,RDI
MOV RDX,qword ptr [RDI + 0x10]
LEA RCX,[RDI + 0x8]
TEST RDX,RDX
JZ 0x0015264c
MOV RDI,RCX
LAB_00152628:
XOR ESI,ESI
CMP dword ptr [RDX + 0x20],EBX
CMOVA RDI,RDX
SETBE SIL
MOV RDX,qword ptr [RDX + RSI*0x8 + 0x10]
TEST RDX,RDX
JNZ 0x00152628
CMP RDI,RCX
JZ 0x0015264f
CMP RDI,qword ptr [RAX + 0x18]
JNZ 0x00152656
JMP 0x00152678
LAB_0015264c:
MOV RDI,RCX
LAB_0015264f:
CMP qword ptr [RAX + 0x28],0x0
JZ 0x00152678
LAB_00152656:
CALL 0x0010f4b0
MOV ECX,dword ptr [RAX + 0x24]
CMP ECX,EBX
JBE 0x00152678
MOV ESI,dword ptr [RAX + 0x20]
MOV EDX,dword ptr [RAX + 0x28]
SUB EBX,ESI
SUB ECX,ESI
SHL RCX,0x20
OR RBX,RCX
MOV RAX,RBX
POP RBX
RET
LAB_00152678:
MOV EDI,0x8
CALL 0x0010f260
LEA RCX,[0x1e0758]
MOV qword ptr [RAX],RCX
LEA RSI,[0x1df938]
MOV RDX,qword ptr [0x001e4fd8]
MOV RDI,RAX
CALL 0x0010f790
|
/* range_map<unsigned int>::get(unsigned int) */
int1 [16] __thiscall range_map<unsigned_int>::get(range_map<unsigned_int> *this,uint param_1)
{
long lVar1;
int8 *puVar2;
range_map<unsigned_int> *prVar3;
range_map<unsigned_int> *prVar4;
range_map<unsigned_int> *prVar5;
bool bVar6;
int1 auVar7 [16];
prVar3 = *(range_map<unsigned_int> **)(this + 0x10);
prVar5 = this + 8;
prVar4 = prVar5;
if (prVar3 == (range_map<unsigned_int> *)0x0) {
LAB_0015264f:
if (*(long *)(this + 0x28) == 0) goto LAB_00152678;
}
else {
do {
if (param_1 < *(uint *)(prVar3 + 0x20)) {
prVar4 = prVar3;
}
prVar3 = *(range_map<unsigned_int> **)
(prVar3 + (ulong)(*(uint *)(prVar3 + 0x20) <= param_1) * 8 + 0x10);
} while (prVar3 != (range_map<unsigned_int> *)0x0);
bVar6 = prVar4 == prVar5;
prVar5 = prVar4;
if (bVar6) goto LAB_0015264f;
if (prVar4 == *(range_map<unsigned_int> **)(this + 0x18)) goto LAB_00152678;
}
lVar1 = std::_Rb_tree_decrement((_Rb_tree_node_base *)prVar5);
if (param_1 < *(uint *)(lVar1 + 0x24)) {
auVar7._4_4_ = *(uint *)(lVar1 + 0x24) - *(int *)(lVar1 + 0x20);
auVar7._0_4_ = param_1 - *(int *)(lVar1 + 0x20);
auVar7._8_4_ = *(int4 *)(lVar1 + 0x28);
auVar7._12_4_ = 0;
return auVar7;
}
LAB_00152678:
puVar2 = (int8 *)__cxa_allocate_exception(8);
*puVar2 = &PTR__exception_001e0758;
/* WARNING: Subroutine does not return */
__cxa_throw(puVar2,¬_mapped_exception::typeinfo,PTR__exception_001e4fd8);
}
|
|
64,719 |
google::protobuf::io::CodedInputStream::ReadLittleEndian32FromArray(unsigned char const*, unsigned int*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/coded_stream.h
|
inline const uint8_t* CodedInputStream::ReadLittleEndian32FromArray(
const uint8_t* buffer, uint32_t* value) {
#if defined(PROTOBUF_LITTLE_ENDIAN) && \
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
memcpy(value, buffer, sizeof(*value));
return buffer + sizeof(*value);
#else
*value = (static_cast<uint32_t>(buffer[0])) |
(static_cast<uint32_t>(buffer[1]) << 8) |
(static_cast<uint32_t>(buffer[2]) << 16) |
(static_cast<uint32_t>(buffer[3]) << 24);
return buffer + sizeof(*value);
#endif
}
|
O0
|
c
|
google::protobuf::io::CodedInputStream::ReadLittleEndian32FromArray(unsigned char const*, unsigned int*):
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
addq $0x4, %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN6google8protobuf2io16CodedInputStream27ReadLittleEndian32FromArrayEPKhPj:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
mov rax, [rsp+var_10]
mov rcx, [rsp+var_8]
mov ecx, [rcx]
mov [rax], ecx
mov rax, [rsp+var_8]
add rax, 4
retn
|
long long google::protobuf::io::CodedInputStream::ReadLittleEndian32FromArray(
google::protobuf::io::CodedInputStream *this,
unsigned __int8 *a2,
unsigned int *a3)
{
*(_DWORD *)a2 = *(_DWORD *)this;
return (long long)this + 4;
}
|
ReadLittleEndian32FromArray:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
MOV RAX,qword ptr [RSP + -0x10]
MOV RCX,qword ptr [RSP + -0x8]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RSP + -0x8]
ADD RAX,0x4
RET
|
/* google::protobuf::io::CodedInputStream::ReadLittleEndian32FromArray(unsigned char const*,
unsigned int*) */
uchar * google::protobuf::io::CodedInputStream::ReadLittleEndian32FromArray
(uchar *param_1,uint *param_2)
{
*param_2 = *(uint *)param_1;
return param_1 + 4;
}
|
|
64,720 |
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& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [11], 0>(char const (&) [11]) const
|
monkey531[P]llama/common/./json.hpp
|
const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return it->second;
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [11], 0>(char const (&) [11]) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xaa7d3
movq %rsi, %r15
movq 0x8(%r14), %rdi
callq 0x7e4d0
movq 0x8(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0xaa831
addq $0x20, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %rbx
movq %r14, %rdi
callq 0x434f0
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xc52d(%rip), %rsi # 0xb6d22
leaq 0x8(%rsp), %rdi
callq 0x7ddd5
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x63472
xorl %ebp, %ebp
leaq 0x53718(%rip), %rsi # 0xfdf38
leaq -0x6a7a7(%rip), %rdx # 0x40080
movq %rbx, %rdi
callq 0x24ee0
jmp 0xaa89b
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0x27852
leaq 0xc4fd(%rip), %rsi # 0xb6d52
leaq 0xc4fc(%rip), %rcx # 0xb6d58
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x7e3df
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0x7e84a
xorl %ebp, %ebp
leaq 0x5362c(%rip), %rsi # 0xfdeb8
leaq -0x6a813(%rip), %rdx # 0x40080
movq %rbx, %rdi
callq 0x24ee0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x251b8
jmp 0xaa8b0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
jmp 0xaa8c1
jmp 0xaa8cd
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x251b8
testb %bpl, %bpl
jne 0xaa8d0
jmp 0xaa8d8
movq %rax, %r14
movq %rbx, %rdi
callq 0x24670
movq %r14, %rdi
callq 0x24f60
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push rbx; int
sub rsp, 48h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_AA7D3
mov r15, rsi
mov rdi, [r14+8]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
mov rcx, [r14+8]
cmp rax, [rcx+8]
jz short loc_AA831
add rax, 20h ; ' '
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_AA7D3:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_40]
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_60]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_60]
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_AA89B
loc_AA831:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_61]
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_60]
lea rdx, [rsp+68h+var_40]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_60]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_AA89B:
mov r14, rax
lea rdi, [rsp+68h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_AA8B0
mov r14, rax
mov bpl, 1
loc_AA8B0:
lea rdi, [rsp+68h+var_40]
jmp short loc_AA8C1
jmp short loc_AA8CD
mov r14, rax
lea rdi, [rsp+68h+var_60]; void *
loc_AA8C1:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_AA8D0
jmp short loc_AA8D8
loc_AA8CD:
mov r14, rax
loc_AA8D0:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_AA8D8:
mov rdi, r14
call __Unwind_Resume
|
long long ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
long long a1,
long long a2)
{
long long v2; // rax
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::out_of_range *v5; // rbx
_BYTE v6[32]; // [rsp+8h] [rbp-60h] BYREF
_QWORD v7[8]; // [rsp+28h] [rbp-40h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v7[0] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
(long long)v6,
(long long)"cannot use at() with ",
v7);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
304,
(long long)v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v2 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(*(long long **)(a1 + 8));
if ( v2 == *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) )
{
v5 = (nlohmann::json_abi_v3_11_3::detail::out_of_range *)__cxa_allocate_exception(0x20uLL);
std::string::basic_string<std::allocator<char>>(v7, a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
(long long)v6,
(long long)"key '",
(long long)v7,
(long long)"' not found");
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v5,
403,
(long long)v6);
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return v2 + 32;
}
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x001aa7d3
MOV R15,RSI
MOV RDI,qword ptr [R14 + 0x8]
CALL 0x0017e4d0
MOV RCX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x001aa831
ADD RAX,0x20
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001aa7d3:
PUSH 0x20
POP RDI
CALL 0x00124460
MOV RBX,RAX
MOV RDI,R14
CALL 0x001434f0
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],RAX
LAB_001aa7ee:
LEA RSI,[0x1b6d22]
LEA RDI,[RSP + 0x8]
CALL 0x0017ddd5
MOV BPL,0x1
LAB_001aa802:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x00163472
XOR EBP,EBP
LEA RSI,[0x1fdf38]
LEA RDX,[0x140080]
MOV RDI,RBX
CALL 0x00124ee0
LAB_001aa831:
PUSH 0x20
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_001aa83c:
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x7]
MOV RSI,R15
CALL 0x00127852
LAB_001aa84e:
LEA RSI,[0x1b6d52]
LEA RCX,[0x1b6d58]
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x28]
CALL 0x0017e3df
MOV BPL,0x1
LAB_001aa86e:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x0017e84a
XOR EBP,EBP
LEA RSI,[0x1fdeb8]
LEA RDX,[0x140080]
MOV RDI,RBX
CALL 0x00124ee0
|
long _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2)
{
long lVar1;
int8 uVar2;
allocator local_61;
detail local_60 [32];
char *local_40 [4];
if (*param_1 !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
uVar2 = __cxa_allocate_exception(0x20);
local_40[0] = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_1);
/* try { // try from 001aa7ee to 001aa7fe has its CatchHandler @ 001aa8cd */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_60,"cannot use at() with ",local_40);
/* try { // try from 001aa802 to 001aa82e has its CatchHandler @ 001aa8b9 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar2,0x130,local_60,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
lVar1 = _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(*(int8 *)(param_1 + 8));
if (lVar1 != *(long *)(*(long *)(param_1 + 8) + 8)) {
return lVar1 + 0x20;
}
uVar2 = __cxa_allocate_exception(0x20);
/* try { // try from 001aa83c to 001aa84d has its CatchHandler @ 001aa8b7 */
std::__cxx11::string::string<std::allocator<char>>((string *)local_40,param_2,&local_61);
/* try { // try from 001aa84e to 001aa86a has its CatchHandler @ 001aa8aa */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_60,"key \'",(string *)local_40,"\' not found");
/* try { // try from 001aa86e to 001aa89a has its CatchHandler @ 001aa89b */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar2,0x193,local_60,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
|
|
64,721 |
writeMemRegs
|
serhmarch[P]ModbusBridge/modbus/src/Modbus.cpp
|
StatusCode writeMemRegs(uint32_t offset, uint32_t count, const void *values, void *memBuff, uint32_t memRegCount, uint32_t *outCount)
{
if (static_cast<uint32_t>(offset + count) > memRegCount)
{
if (outCount && (offset < memRegCount))
count = memRegCount - offset;
else
return Status_BadIllegalDataAddress;
}
uint16_t *mem = reinterpret_cast<uint16_t*>(memBuff);
memcpy(&mem[offset], values, count * MB_REGE_SZ_BYTES);
if (outCount)
*outCount = count;
return Status_Good;
}
|
O3
|
cpp
|
writeMemRegs:
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rbx
movl %esi, %r15d
leal (%r15,%rdi), %eax
cmpl %r8d, %eax
jbe 0x7b8f
movl %r8d, %r14d
testq %rbx, %rbx
sete %sil
subl %edi, %r14d
setbe %r8b
movl $0x1000002, %eax # imm = 0x1000002
orb %sil, %r8b
jne 0x7bae
movl %edi, %eax
leaq (%rcx,%rax,2), %rdi
leal (%r14,%r14), %eax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x52a0
movl %r14d, %r15d
jmp 0x7ba9
movl %edi, %eax
leaq (%rcx,%rax,2), %rdi
leal (%r15,%r15), %eax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x52a0
testq %rbx, %rbx
je 0x7bac
movl %r15d, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
|
writeMemRegs:
push r15
push r14
push rbx
mov rbx, r9
mov r15d, esi
lea eax, [r15+rdi]
cmp eax, r8d
jbe short loc_7B8F
mov r14d, r8d
test rbx, rbx
setz sil
sub r14d, edi
setbe r8b
mov eax, 1000002h
or r8b, sil
jnz short loc_7BAE
mov eax, edi
lea rdi, [rcx+rax*2]
lea eax, [r14+r14]
mov rsi, rdx
mov rdx, rax
call _memcpy
mov r15d, r14d
jmp short loc_7BA9
loc_7B8F:
mov eax, edi
lea rdi, [rcx+rax*2]
lea eax, [r15+r15]
mov rsi, rdx
mov rdx, rax
call _memcpy
test rbx, rbx
jz short loc_7BAC
loc_7BA9:
mov [rbx], r15d
loc_7BAC:
xor eax, eax
loc_7BAE:
pop rbx
pop r14
pop r15
retn
|
long long writeMemRegs(
unsigned int a1,
unsigned int a2,
long long a3,
long long a4,
unsigned int a5,
unsigned int *a6)
{
unsigned int v7; // r15d
unsigned int v8; // r14d
long long result; // rax
v7 = a2;
if ( a2 + a1 > a5 )
{
v8 = a5 - a1;
result = 16777218LL;
if ( a6 == 0LL || a5 <= a1 )
return result;
memcpy(a4 + 2LL * a1, a3, 2 * v8);
v7 = v8;
goto LABEL_5;
}
memcpy(a4 + 2LL * a1, a3, 2 * a2);
if ( a6 )
LABEL_5:
*a6 = v7;
return 0LL;
}
|
writeMemRegs:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,R9
MOV R15D,ESI
LEA EAX,[R15 + RDI*0x1]
CMP EAX,R8D
JBE 0x00107b8f
MOV R14D,R8D
TEST RBX,RBX
SETZ SIL
SUB R14D,EDI
SETBE R8B
MOV EAX,0x1000002
OR R8B,SIL
JNZ 0x00107bae
MOV EAX,EDI
LEA RDI,[RCX + RAX*0x2]
LEA EAX,[R14 + R14*0x1]
MOV RSI,RDX
MOV RDX,RAX
CALL 0x001052a0
MOV R15D,R14D
JMP 0x00107ba9
LAB_00107b8f:
MOV EAX,EDI
LEA RDI,[RCX + RAX*0x2]
LEA EAX,[R15 + R15*0x1]
MOV RSI,RDX
MOV RDX,RAX
CALL 0x001052a0
TEST RBX,RBX
JZ 0x00107bac
LAB_00107ba9:
MOV dword ptr [RBX],R15D
LAB_00107bac:
XOR EAX,EAX
LAB_00107bae:
POP RBX
POP R14
POP R15
RET
|
int8
writeMemRegs(uint param_1,int param_2,void *param_3,long param_4,uint param_5,int *param_6)
{
if (param_5 < param_2 + param_1) {
param_2 = param_5 - param_1;
if ((param_5 < param_1 || param_2 == 0) || param_6 == (int *)0x0) {
return 0x1000002;
}
memcpy((void *)(param_4 + (ulong)param_1 * 2),param_3,(ulong)(uint)(param_2 * 2));
}
else {
memcpy((void *)(param_4 + (ulong)param_1 * 2),param_3,(ulong)(uint)(param_2 * 2));
if (param_6 == (int *)0x0) {
return 0;
}
}
*param_6 = param_2;
return 0;
}
|
|
64,722 |
my_strcasecmp_utf8mb4
|
eloqsql/strings/ctype-utf8.c
|
static int
my_strcasecmp_utf8mb4(CHARSET_INFO *cs, const char *s, const char *t)
{
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
while (s[0] && t[0])
{
my_wc_t s_wc,t_wc;
if ((uchar) s[0] < 128)
{
/*
s[0] is between 0 and 127.
It represents a single byte character.
Convert it into weight according to collation.
*/
s_wc= my_unicase_default_page00[(uchar) s[0]].tolower;
s++;
}
else
{
int res= my_mb_wc_utf8mb4_no_range(cs, &s_wc, (const uchar*) s);
/*
In the case of wrong multibyte sequence we will
call strcmp() for byte-to-byte comparison.
*/
if (res <= 0)
return strcmp(s, t);
s+= res;
my_tolower_utf8mb4(uni_plane, &s_wc);
}
/* Do the same for the second string */
if ((uchar) t[0] < 128)
{
/* Convert single byte character into weight */
t_wc= my_unicase_default_page00[(uchar) t[0]].tolower;
t++;
}
else
{
int res= my_mb_wc_utf8mb4_no_range(cs, &t_wc, (const uchar*) t);
if (res <= 0)
return strcmp(s, t);
t+= res;
my_tolower_utf8mb4(uni_plane, &t_wc);
}
/* Now we have two weights, let's compare them */
if ( s_wc != t_wc )
return ((int) s_wc) - ((int) t_wc);
}
return ((int) (uchar) s[0]) - ((int) (uchar) t[0]);
}
|
O0
|
c
|
my_strcasecmp_utf8mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0xc83a1
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xc83ad
jmp 0xc84d6
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0xc83e7
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x303535(%rip), %rax # 0x3cb900
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc8434
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0xc7ae0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jg 0xc8416
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x284c0
movl %eax, -0x4(%rbp)
jmp 0xc84e9
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc7ed0
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0xc846e
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x3034ae(%rip), %rax # 0x3cb900
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc84b8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0xc7ae0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jg 0xc849a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x284c0
movl %eax, -0x4(%rbp)
jmp 0xc84e9
movl -0x40(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc7ed0
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0xc84d1
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xc84e9
jmp 0xc8380
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_strcasecmp_utf8mb4:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+78h]
mov [rbp+var_28], rax
loc_C8380:
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_41], al
jz short loc_C83A1
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 0
setnz al
mov [rbp+var_41], al
loc_C83A1:
mov al, [rbp+var_41]
test al, 1
jnz short loc_C83AD
jmp loc_C84D6
loc_C83AD:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 80h
jge short loc_C83E7
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, my_unicase_default_page00
imul rcx, 0Ch
add rax, rcx
mov eax, [rax+4]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_C8434
loc_C83E7:
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rsi, [rbp+var_30]
call my_mb_wc_utf8mb4_no_range
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jg short loc_C8416
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call _strcmp
mov [rbp+var_4], eax
jmp loc_C84E9
loc_C8416:
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_30]
call my_tolower_utf8mb4
loc_C8434:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, 80h
jge short loc_C846E
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, my_unicase_default_page00
imul rcx, 0Ch
add rax, rcx
mov eax, [rax+4]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_C84B8
loc_C846E:
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_20]
lea rsi, [rbp+var_38]
call my_mb_wc_utf8mb4_no_range
mov [rbp+var_40], eax
cmp [rbp+var_40], 0
jg short loc_C849A
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call _strcmp
mov [rbp+var_4], eax
jmp short loc_C84E9
loc_C849A:
mov ecx, [rbp+var_40]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_38]
call my_tolower_utf8mb4
loc_C84B8:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_C84D1
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub eax, ecx
mov [rbp+var_4], eax
jmp short loc_C84E9
loc_C84D1:
jmp loc_C8380
loc_C84D6:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx]
sub eax, ecx
mov [rbp+var_4], eax
loc_C84E9:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long my_strcasecmp_utf8mb4(long long a1, unsigned __int8 *a2, unsigned __int8 *a3)
{
bool v4; // [rsp+Fh] [rbp-41h]
int v5; // [rsp+10h] [rbp-40h]
int v6; // [rsp+14h] [rbp-3Ch]
unsigned long long v7; // [rsp+18h] [rbp-38h] BYREF
unsigned long long v8; // [rsp+20h] [rbp-30h] BYREF
_QWORD *v9; // [rsp+28h] [rbp-28h]
unsigned __int8 *v10; // [rsp+30h] [rbp-20h]
unsigned __int8 *v11; // [rsp+38h] [rbp-18h]
long long v12; // [rsp+40h] [rbp-10h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = *(_QWORD **)(a1 + 120);
while ( 1 )
{
v4 = 0;
if ( *v11 )
v4 = *v10 != 0;
if ( !v4 )
break;
if ( *v11 >= 0x80u )
{
v6 = my_mb_wc_utf8mb4_no_range(v12, &v8, v11);
if ( v6 <= 0 )
return (unsigned int)strcmp(v11, v10);
v11 += v6;
my_tolower_utf8mb4(v9, &v8);
}
else
{
v8 = my_unicase_default_page00[3 * *v11++ + 1];
}
if ( *v10 >= 0x80u )
{
v5 = my_mb_wc_utf8mb4_no_range(v12, &v7, v10);
if ( v5 <= 0 )
return (unsigned int)strcmp(v11, v10);
v10 += v5;
my_tolower_utf8mb4(v9, &v7);
}
else
{
v7 = my_unicase_default_page00[3 * *v10++ + 1];
}
if ( v8 != v7 )
return (unsigned int)(v8 - v7);
}
return (unsigned int)(*v11 - *v10);
}
|
my_strcasecmp_utf8mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x28],RAX
LAB_001c8380:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x41],AL
JZ 0x001c83a1
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_001c83a1:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x001c83ad
JMP 0x001c84d6
LAB_001c83ad:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x80
JGE 0x001c83e7
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x4cb900]
IMUL RCX,RCX,0xc
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001c8434
LAB_001c83e7:
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0x30]
CALL 0x001c7ae0
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JG 0x001c8416
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001284c0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001c84e9
LAB_001c8416:
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x30]
CALL 0x001c7ed0
LAB_001c8434:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x80
JGE 0x001c846e
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x4cb900]
IMUL RCX,RCX,0xc
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001c84b8
LAB_001c846e:
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x38]
CALL 0x001c7ae0
MOV dword ptr [RBP + -0x40],EAX
CMP dword ptr [RBP + -0x40],0x0
JG 0x001c849a
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001284c0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001c84e9
LAB_001c849a:
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x38]
CALL 0x001c7ed0
LAB_001c84b8:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x001c84d1
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001c84e9
LAB_001c84d1:
JMP 0x001c8380
LAB_001c84d6:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX]
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_001c84e9:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int my_strcasecmp_utf8mb4(long param_1,byte *param_2,byte *param_3)
{
int iVar1;
bool bVar2;
ulong local_40;
ulong local_38;
int8 local_30;
byte *local_28;
byte *local_20;
long local_18;
local_30 = *(int8 *)(param_1 + 0x78);
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
do {
bVar2 = false;
if (*local_20 != 0) {
bVar2 = *local_28 != 0;
}
if (!bVar2) {
return (uint)*local_20 - (uint)*local_28;
}
if (*local_20 < 0x80) {
local_38 = (ulong)*(uint *)(my_unicase_default_page00 + (ulong)*local_20 * 0xc + 4);
local_20 = local_20 + 1;
}
else {
iVar1 = my_mb_wc_utf8mb4_no_range(local_18,&local_38,local_20);
if (iVar1 < 1) {
iVar1 = strcmp((char *)local_20,(char *)local_28);
return iVar1;
}
local_20 = local_20 + iVar1;
my_tolower_utf8mb4(local_30,&local_38);
}
if (*local_28 < 0x80) {
local_40 = (ulong)*(uint *)(my_unicase_default_page00 + (ulong)*local_28 * 0xc + 4);
local_28 = local_28 + 1;
}
else {
iVar1 = my_mb_wc_utf8mb4_no_range(local_18,&local_40,local_28);
if (iVar1 < 1) {
iVar1 = strcmp((char *)local_20,(char *)local_28);
return iVar1;
}
local_28 = local_28 + iVar1;
my_tolower_utf8mb4(local_30,&local_40);
}
} while (local_38 == local_40);
return (int)local_38 - (int)local_40;
}
|
|
64,723 |
mi_bin_search
|
eloqsql/storage/myisam/mi_search.c
|
int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
uchar *buff __attribute__((unused)), my_bool *last_key)
{
reg4 int start,mid,end,save_end;
int UNINIT_VAR(flag);
uint totlength,nod_flag,not_used[2];
DBUG_ENTER("_mi_bin_search");
totlength=keyinfo->keylength+(nod_flag=mi_test_if_nod(page));
start=0; mid=1;
save_end=end=(int) ((mi_getint(page)-2-nod_flag)/totlength-1);
DBUG_PRINT("test",("mi_getint: %d end: %d",mi_getint(page),end));
page+=2+nod_flag;
while (start != end)
{
mid= (start+end)/2;
if ((flag=ha_key_cmp(keyinfo->seg,page+(uint) mid*totlength,key,key_len,
comp_flag, not_used))
>= 0)
end=mid;
else
start=mid+1;
}
if (mid != start)
flag=ha_key_cmp(keyinfo->seg,page+(uint) start*totlength,key,key_len,
comp_flag, not_used);
if (flag < 0)
start++; /* point at next, bigger key */
*ret_pos=page+(uint) start*totlength;
*last_key= end == save_end;
DBUG_PRINT("exit",("flag: %d keypos: %d",flag,start));
DBUG_RETURN(flag);
}
|
O3
|
c
|
mi_bin_search:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, -0x34(%rbp)
movl %r8d, -0x30(%rbp)
movq %rcx, -0x50(%rbp)
movq %rdx, %rcx
movq %rsi, -0x48(%rbp)
movzwl 0x12(%rsi), %r15d
movzbl (%rdx), %eax
xorl %r14d, %r14d
movl $0x0, %ebx
testb %al, %al
jns 0x3cb53
movq (%rdi), %rdx
movl 0x17c(%rdx), %ebx
movq 0x20(%rbp), %r12
movq 0x10(%rbp), %r13
addl %ebx, %r15d
movzbl 0x1(%rcx), %edx
andl $0x7f, %eax
shll $0x8, %eax
subl %ebx, %eax
addl %edx, %eax
addl $-0x2, %eax
xorl %edx, %edx
divl %r15d
addl $0x2, %ebx
addq %rcx, %rbx
decl %eax
movl %eax, -0x2c(%rbp)
je 0x3cbf2
movq %rbx, -0x40(%rbp)
movl %r15d, %ebx
xorl %r15d, %r15d
movl -0x2c(%rbp), %eax
movl %eax, %r12d
leal (%r15,%r12), %eax
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
movq -0x48(%rbp), %rax
movq 0x28(%rax), %rdi
movl %r13d, %esi
imull %ebx, %esi
addq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl -0x30(%rbp), %ecx
movl -0x34(%rbp), %r8d
leaq -0x58(%rbp), %r9
callq 0x59d82
movl %r13d, %r14d
testl %eax, %eax
jns 0x3cbd6
leal 0x1(%r13), %r15d
movl %r12d, %r14d
movl %r14d, %r12d
cmpl %r14d, %r15d
jne 0x3cb91
cmpl %r14d, %r13d
movl %ebx, %r15d
movq -0x40(%rbp), %rbx
movq 0x20(%rbp), %r12
movq 0x10(%rbp), %r13
je 0x3cc18
movq -0x48(%rbp), %rax
movq 0x28(%rax), %rdi
movl %r14d, %esi
imull %r15d, %esi
addq %rbx, %rsi
leaq -0x58(%rbp), %r9
movq -0x50(%rbp), %rdx
movl -0x30(%rbp), %ecx
movl -0x34(%rbp), %r8d
callq 0x59d82
movl %eax, %ecx
shrl $0x1f, %ecx
addl %r14d, %ecx
imull %r15d, %ecx
addq %rcx, %rbx
movq %rbx, (%r13)
cmpl -0x2c(%rbp), %r14d
sete (%r12)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_mi_bin_search:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_34], r9d
mov [rbp+var_30], r8d
mov [rbp+var_50], rcx
mov rcx, rdx
mov [rbp+var_48], rsi
movzx r15d, word ptr [rsi+12h]
movzx eax, byte ptr [rdx]
xor r14d, r14d
mov ebx, 0
test al, al
jns short loc_3CB53
mov rdx, [rdi]
mov ebx, [rdx+17Ch]
loc_3CB53:
mov r12, [rbp+arg_10]
mov r13, [rbp+arg_0]
add r15d, ebx
movzx edx, byte ptr [rcx+1]
and eax, 7Fh
shl eax, 8
sub eax, ebx
add eax, edx
add eax, 0FFFFFFFEh
xor edx, edx
div r15d
add ebx, 2
add rbx, rcx
dec eax
mov [rbp+var_2C], eax
jz short loc_3CBF2
mov [rbp+var_40], rbx
mov ebx, r15d
xor r15d, r15d
mov eax, [rbp+var_2C]
mov r12d, eax
loc_3CB91:
lea eax, [r15+r12]
mov r13d, eax
shr r13d, 1Fh
add r13d, eax
sar r13d, 1
mov rax, [rbp+var_48]
mov rdi, [rax+28h]
mov esi, r13d
imul esi, ebx
add rsi, [rbp+var_40]
mov rdx, [rbp+var_50]
mov ecx, [rbp+var_30]
mov r8d, [rbp+var_34]
lea r9, [rbp+var_58]
call ha_key_cmp
mov r14d, r13d
test eax, eax
jns short loc_3CBD6
lea r15d, [r13+1]
mov r14d, r12d
loc_3CBD6:
mov r12d, r14d
cmp r15d, r14d
jnz short loc_3CB91
cmp r13d, r14d
mov r15d, ebx
mov rbx, [rbp+var_40]
mov r12, [rbp+arg_10]
mov r13, [rbp+arg_0]
jz short loc_3CC18
loc_3CBF2:
mov rax, [rbp+var_48]
mov rdi, [rax+28h]
mov esi, r14d
imul esi, r15d
add rsi, rbx
lea r9, [rbp+var_58]
mov rdx, [rbp+var_50]
mov ecx, [rbp+var_30]
mov r8d, [rbp+var_34]
call ha_key_cmp
loc_3CC18:
mov ecx, eax
shr ecx, 1Fh
add ecx, r14d
imul ecx, r15d
add rbx, rcx
mov [r13+0], rbx
cmp r14d, [rbp+var_2C]
setz byte ptr [r12]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mi_bin_search(
long long a1,
long long a2,
long long a3,
long long a4,
unsigned int a5,
unsigned int a6,
_QWORD *a7,
int a8,
bool *a9)
{
int v9; // r14d
int v10; // ebx
bool *v11; // r12
_QWORD *v12; // r13
unsigned int v13; // r15d
int v14; // eax
long long v15; // rbx
unsigned int v16; // ebx
int v17; // r15d
int v18; // r12d
int v19; // r13d
long long result; // rax
bool v21; // zf
char v22[8]; // [rsp+8h] [rbp-58h] BYREF
long long v23; // [rsp+10h] [rbp-50h]
long long v24; // [rsp+18h] [rbp-48h]
long long v25; // [rsp+20h] [rbp-40h]
unsigned int v26; // [rsp+2Ch] [rbp-34h]
unsigned int v27; // [rsp+30h] [rbp-30h]
int v28; // [rsp+34h] [rbp-2Ch]
v26 = a6;
v27 = a5;
v23 = a4;
v24 = a2;
v9 = 0;
v10 = 0;
if ( *(char *)a3 < 0 )
v10 = *(_DWORD *)(*(_QWORD *)a1 + 380LL);
v11 = a9;
v12 = a7;
v13 = v10 + *(unsigned __int16 *)(a2 + 18);
v14 = (*(unsigned __int8 *)(a3 + 1) + ((unsigned __int8)(*(_BYTE *)a3 & 0x7F) << 8) - v10 - 2) / v13;
v15 = a3 + (unsigned int)(v10 + 2);
v28 = v14 - 1;
if ( v14 == 1 )
goto LABEL_9;
v25 = v15;
v16 = v13;
v17 = 0;
v18 = v28;
do
{
v19 = (v17 + v18) / 2;
result = ha_key_cmp(*(_QWORD *)(v24 + 40), v25 + v16 * v19, v23, v27, v26, v22);
v9 = v19;
if ( (int)result < 0 )
{
v17 = v19 + 1;
v9 = v18;
}
v18 = v9;
}
while ( v17 != v9 );
v21 = v19 == v9;
v13 = v16;
v15 = v25;
v11 = a9;
v12 = a7;
if ( !v21 )
LABEL_9:
result = ha_key_cmp(*(_QWORD *)(v24 + 40), v15 + v13 * v9, v23, v27, v26, v22);
*v12 = v13 * (v9 + ((unsigned int)result >> 31)) + v15;
*v11 = v9 == v28;
return result;
}
|
_mi_bin_search:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RBP + -0x34],R9D
MOV dword ptr [RBP + -0x30],R8D
MOV qword ptr [RBP + -0x50],RCX
MOV RCX,RDX
MOV qword ptr [RBP + -0x48],RSI
MOVZX R15D,word ptr [RSI + 0x12]
MOVZX EAX,byte ptr [RDX]
XOR R14D,R14D
MOV EBX,0x0
TEST AL,AL
JNS 0x0013cb53
MOV RDX,qword ptr [RDI]
MOV EBX,dword ptr [RDX + 0x17c]
LAB_0013cb53:
MOV R12,qword ptr [RBP + 0x20]
MOV R13,qword ptr [RBP + 0x10]
ADD R15D,EBX
MOVZX EDX,byte ptr [RCX + 0x1]
AND EAX,0x7f
SHL EAX,0x8
SUB EAX,EBX
ADD EAX,EDX
ADD EAX,-0x2
XOR EDX,EDX
DIV R15D
ADD EBX,0x2
ADD RBX,RCX
DEC EAX
MOV dword ptr [RBP + -0x2c],EAX
JZ 0x0013cbf2
MOV qword ptr [RBP + -0x40],RBX
MOV EBX,R15D
XOR R15D,R15D
MOV EAX,dword ptr [RBP + -0x2c]
MOV R12D,EAX
LAB_0013cb91:
LEA EAX,[R15 + R12*0x1]
MOV R13D,EAX
SHR R13D,0x1f
ADD R13D,EAX
SAR R13D,0x1
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RAX + 0x28]
MOV ESI,R13D
IMUL ESI,EBX
ADD RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x30]
MOV R8D,dword ptr [RBP + -0x34]
LEA R9,[RBP + -0x58]
CALL 0x00159d82
MOV R14D,R13D
TEST EAX,EAX
JNS 0x0013cbd6
LEA R15D,[R13 + 0x1]
MOV R14D,R12D
LAB_0013cbd6:
MOV R12D,R14D
CMP R15D,R14D
JNZ 0x0013cb91
CMP R13D,R14D
MOV R15D,EBX
MOV RBX,qword ptr [RBP + -0x40]
MOV R12,qword ptr [RBP + 0x20]
MOV R13,qword ptr [RBP + 0x10]
JZ 0x0013cc18
LAB_0013cbf2:
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RAX + 0x28]
MOV ESI,R14D
IMUL ESI,R15D
ADD RSI,RBX
LEA R9,[RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x30]
MOV R8D,dword ptr [RBP + -0x34]
CALL 0x00159d82
LAB_0013cc18:
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,R14D
IMUL ECX,R15D
ADD RBX,RCX
MOV qword ptr [R13],RBX
CMP R14D,dword ptr [RBP + -0x2c]
SETZ byte ptr [R12]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void _mi_bin_search(long *param_1,long param_2,byte *param_3,int8 param_4,int4 param_5,
int4 param_6,int8 *param_7,int8 param_8,int8 param_9)
{
int iVar1;
int iVar2;
int iVar3;
byte *pbVar4;
int iVar5;
uint uVar6;
int iVar7;
int1 local_60 [8];
int8 local_58;
long local_50;
byte *local_48;
int4 local_3c;
int4 local_38;
int local_34;
iVar3 = 0;
if ((char)*param_3 < '\0') {
iVar3 = *(int *)(*param_1 + 0x17c);
}
uVar6 = (uint)*(ushort *)(param_2 + 0x12) + iVar3;
iVar1 = ((((*param_3 & 0x7f) * 0x100 - iVar3) + (uint)param_3[1]) - 2) / uVar6 - 1;
pbVar4 = param_3 + (iVar3 + 2);
iVar7 = 0;
local_58 = param_4;
local_50 = param_2;
local_3c = param_6;
local_38 = param_5;
local_34 = iVar1;
if (iVar1 != 0) {
iVar7 = 0;
local_48 = param_3 + (iVar3 + 2);
do {
iVar5 = (iVar7 + iVar1) / 2;
iVar2 = ha_key_cmp(*(int8 *)(local_50 + 0x28),local_48 + iVar5 * uVar6,local_58,local_38
,local_3c,local_60);
iVar3 = iVar5;
if (iVar2 < 0) {
iVar7 = iVar5 + 1;
iVar3 = iVar1;
}
iVar1 = iVar3;
} while (iVar7 != iVar1);
pbVar4 = local_48;
iVar7 = iVar1;
if (iVar5 == iVar1) goto LAB_0013cc18;
}
iVar2 = ha_key_cmp(*(int8 *)(local_50 + 0x28),pbVar4 + iVar7 * uVar6,local_58,local_38,
local_3c,local_60);
LAB_0013cc18:
*param_7 = pbVar4 + (iVar7 - (iVar2 >> 0x1f)) * uVar6;
*(bool *)param_9 = iVar7 == local_34;
return;
}
|
|
64,724 |
mthd_my_send_cmd
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
int
mthd_my_send_cmd(MYSQL *mysql,enum enum_server_command command, const char *arg,
size_t length, my_bool skip_check, void *opt_arg)
{
NET *net= &mysql->net;
int result= -1;
if (mysql->net.pvio == 0)
{
/* Do reconnect if possible */
if (mariadb_reconnect(mysql))
return(1);
}
if (mysql->status != MYSQL_STATUS_READY ||
mysql->server_status & SERVER_MORE_RESULTS_EXIST)
{
SET_CLIENT_ERROR(mysql, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
goto end;
}
if (IS_CONNHDLR_ACTIVE(mysql))
{
result= mysql->extension->conn_hdlr->plugin->set_connection(mysql, command, arg, length, skip_check, opt_arg);
if (result== -1)
return(result);
}
CLEAR_CLIENT_ERROR(mysql);
if (command == COM_QUERY ||
command == COM_STMT_PREPARE)
{
if ((mysql->options.client_flag & CLIENT_LOCAL_FILES) &&
mysql->options.extension && mysql->extension->auto_local_infile == WAIT_FOR_QUERY &&
arg && (*arg == 'l' || *arg == 'L'))
{
if (strncasecmp(arg, "load", 4) == 0)
mysql->extension->auto_local_infile= ACCEPT_FILE_REQUEST;
}
}
mysql->info=0;
mysql->affected_rows= ~(unsigned long long) 0;
ma_net_clear(net); /* Clear receive buffer */
if (!arg)
arg="";
if (net->extension->multi_status== COM_MULTI_ENABLED)
{
return net_add_multi_command(net, command, (const uchar *)arg, length);
}
if (ma_net_write_command(net,(uchar) command,arg,
length ? length : (ulong) strlen(arg), 0))
{
if (net->last_errno == ER_NET_PACKET_TOO_LARGE)
{
my_set_error(mysql, CR_NET_PACKET_TOO_LARGE, SQLSTATE_UNKNOWN, 0);
goto end;
}
end_server(mysql);
if (mariadb_reconnect(mysql))
goto end;
if (ma_net_write_command(net,(uchar) command,arg,
length ? length : (ulong) strlen(arg), 0))
{
my_set_error(mysql, CR_SERVER_GONE_ERROR, SQLSTATE_UNKNOWN, 0);
goto end;
}
}
result=0;
if (net->extension->multi_status > COM_MULTI_OFF)
skip_check= 1;
if (!skip_check)
{
result= ((mysql->packet_length=ma_net_safe_read(mysql)) == packet_error ?
1 : 0);
}
end:
return(result);
}
|
O0
|
c
|
mthd_my_send_cmd:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1bfc8
movq -0x10(%rbp), %rdi
callq 0x1c390
cmpb $0x0, %al
je 0x1bfc6
movl $0x1, -0x4(%rbp)
jmp 0x1c381
jmp 0x1bfc8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x488(%rax)
jne 0x1bfe7
movq -0x10(%rbp), %rax
movl 0x380(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x1c051
jmp 0x1bfe9
movq -0x10(%rbp), %rax
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x4b237(%rip), %rax # 0x67240
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x10(%rbp), %rdi
addq $0x97, %rdi
leaq 0x4b21d(%rip), %rax # 0x67250
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x296(%rax)
jmp 0x1c37b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x1c0b8
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
cmpq $0x0, (%rax)
je 0x1c0b8
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb -0x29(%rbp), %r8b
movq -0x38(%rbp), %r9
movsbl %r8b, %r8d
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
jne 0x1c0b6
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c381
jmp 0x1c0b8
jmp 0x1c0ba
movq -0x10(%rbp), %rax
movl $0x0, 0x90(%rax)
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x36891(%rip), %rsi # 0x5296b
callq 0x133c0
movq -0x10(%rbp), %rax
movb $0x0, 0x97(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x1c10a
movq -0x10(%rbp), %rax
movq 0x2a0(%rax), %rax
movl $0x0, 0x4(%rax)
jmp 0x1c10c
cmpl $0x3, -0x14(%rbp)
je 0x1c11c
cmpl $0x16, -0x14(%rbp)
jne 0x1c1a1
movq -0x10(%rbp), %rax
movq 0x3a8(%rax), %rax
andq $0x80, %rax
cmpq $0x0, %rax
je 0x1c19f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x1c19f
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movsbl 0x78(%rax), %eax
cmpl $0x1, %eax
jne 0x1c19f
cmpq $0x0, -0x20(%rbp)
je 0x1c19f
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
je 0x1c174
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4c, %eax
jne 0x1c19f
movq -0x20(%rbp), %rdi
leaq 0x367f2(%rip), %rsi # 0x52971
movl $0x4, %edx
callq 0x13570
cmpl $0x0, %eax
jne 0x1c19d
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movb $0x2, 0x78(%rax)
jmp 0x1c19f
jmp 0x1c1a1
movq -0x10(%rbp), %rax
movq $0x0, 0x2e0(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x338(%rax)
movq -0x40(%rbp), %rdi
callq 0x4b5f0
cmpq $0x0, -0x20(%rbp)
jne 0x1c1da
leaq 0x35603(%rip), %rax # 0x517d9
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpl $0x2, (%rax)
jne 0x1c209
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movzbl %al, %esi
callq 0x4c640
movl %eax, -0x4(%rbp)
jmp 0x1c381
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x51(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1c230
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x1c23d
movq -0x20(%rbp), %rdi
callq 0x131a0
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rdx
movb -0x51(%rbp), %al
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rcx
xorl %r8d, %r8d
movzbl %al, %esi
callq 0x4bd90
cmpl $0x0, %eax
je 0x1c32c
movq -0x40(%rbp), %rax
cmpl $0x481, 0x90(%rax) # imm = 0x481
jne 0x1c293
movq -0x10(%rbp), %rdi
leaq 0x4afc5(%rip), %rax # 0x67240
movq (%rax), %rdx
movl $0x7e4, %esi # imm = 0x7E4
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x1bae0
jmp 0x1c37b
movq -0x10(%rbp), %rdi
callq 0x1ba90
movq -0x10(%rbp), %rdi
callq 0x1c390
cmpb $0x0, %al
je 0x1c2ae
jmp 0x1c37b
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x71(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1c2d8
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x1c2e8
movq -0x20(%rbp), %rdi
callq 0x131a0
movq %rax, -0x88(%rbp)
movq -0x70(%rbp), %rdx
movb -0x71(%rbp), %al
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rcx
xorl %r8d, %r8d
movzbl %al, %esi
callq 0x4bd90
cmpl $0x0, %eax
je 0x1c32a
movq -0x10(%rbp), %rdi
leaq 0x4af2b(%rip), %rax # 0x67240
movq (%rax), %rdx
movl $0x7d6, %esi # imm = 0x7D6
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x1bae0
jmp 0x1c37b
jmp 0x1c32c
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpl $0x0, (%rax)
jbe 0x1c347
movb $0x1, -0x29(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0x1c379
movq -0x10(%rbp), %rdi
callq 0x1b7d0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq %rdx, 0x358(%rax)
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, -0x44(%rbp)
jmp 0x1c37b
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
|
mthd_my_send_cmd:
push rbp
mov rbp, rsp
sub rsp, 90h
mov al, r8b
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_29], al
mov [rbp+var_38], r9
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
mov [rbp+var_44], 0FFFFFFFFh
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_1BFC8
mov rdi, [rbp+var_10]
call mariadb_reconnect
cmp al, 0
jz short loc_1BFC6
mov [rbp+var_4], 1
jmp loc_1C381
loc_1BFC6:
jmp short $+2
loc_1BFC8:
mov rax, [rbp+var_10]
cmp dword ptr [rax+488h], 0
jnz short loc_1BFE7
mov rax, [rbp+var_10]
mov eax, [rax+380h]
and eax, 8
cmp eax, 0
jz short loc_1C051
loc_1BFE7:
jmp short $+2
loc_1BFE9:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 7DEh
mov rdi, [rbp+var_10]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_10]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+296h], 0
jmp loc_1C37B
loc_1C051:
mov rax, [rbp+var_10]
cmp qword ptr [rax+4F0h], 0
jz short loc_1C0B8
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
cmp qword ptr [rax], 0
jz short loc_1C0B8
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
mov rax, [rax]
mov rax, [rax]
mov rax, [rax+70h]
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8b, [rbp+var_29]
mov r9, [rbp+var_38]
movsx r8d, r8b
call rax
mov [rbp+var_44], eax
cmp [rbp+var_44], 0FFFFFFFFh
jnz short loc_1C0B6
mov eax, [rbp+var_44]
mov [rbp+var_4], eax
jmp loc_1C381
loc_1C0B6:
jmp short $+2
loc_1C0B8:
jmp short $+2
loc_1C0BA:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 0
mov rdi, [rbp+var_10]
add rdi, 297h
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov byte ptr [rax+97h], 0
mov rax, [rbp+var_10]
cmp qword ptr [rax+2A0h], 0
jz short loc_1C10A
mov rax, [rbp+var_10]
mov rax, [rax+2A0h]
mov dword ptr [rax+4], 0
loc_1C10A:
jmp short $+2
loc_1C10C:
cmp [rbp+var_14], 3
jz short loc_1C11C
cmp [rbp+var_14], 16h
jnz loc_1C1A1
loc_1C11C:
mov rax, [rbp+var_10]
mov rax, [rax+3A8h]
and rax, 80h
cmp rax, 0
jz short loc_1C19F
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz short loc_1C19F
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
movsx eax, byte ptr [rax+78h]
cmp eax, 1
jnz short loc_1C19F
cmp [rbp+var_20], 0
jz short loc_1C19F
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 6Ch ; 'l'
jz short loc_1C174
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 4Ch ; 'L'
jnz short loc_1C19F
loc_1C174:
mov rdi, [rbp+var_20]
lea rsi, aLoad; "load"
mov edx, 4
call _strncasecmp
cmp eax, 0
jnz short loc_1C19D
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
mov byte ptr [rax+78h], 2
loc_1C19D:
jmp short $+2
loc_1C19F:
jmp short $+2
loc_1C1A1:
mov rax, [rbp+var_10]
mov qword ptr [rax+2E0h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+338h], 0FFFFFFFFFFFFFFFFh
mov rdi, [rbp+var_40]
call ma_net_clear
cmp [rbp+var_20], 0
jnz short loc_1C1DA
lea rax, aExecuteTestWit+29h; ""
mov [rbp+var_20], rax
loc_1C1DA:
mov rax, [rbp+var_40]
mov rax, [rax+2A0h]
cmp dword ptr [rax], 2
jnz short loc_1C209
mov rdi, [rbp+var_40]
mov eax, [rbp+var_14]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
movzx esi, al
call net_add_multi_command
mov [rbp+var_4], eax
jmp loc_1C381
loc_1C209:
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
mov eax, [rbp+var_14]
mov [rbp+var_51], al
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
cmp [rbp+var_28], 0
jz short loc_1C230
mov rax, [rbp+var_28]
mov [rbp+var_68], rax
jmp short loc_1C23D
loc_1C230:
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_68], rax
loc_1C23D:
mov rdx, [rbp+var_50]
mov al, [rbp+var_51]
mov rdi, [rbp+var_60]
mov rcx, [rbp+var_68]
xor r8d, r8d
movzx esi, al
call ma_net_write_command
cmp eax, 0
jz loc_1C32C
mov rax, [rbp+var_40]
cmp dword ptr [rax+90h], 481h
jnz short loc_1C293
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7E4h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
jmp loc_1C37B
loc_1C293:
mov rdi, [rbp+var_10]
call end_server
mov rdi, [rbp+var_10]
call mariadb_reconnect
cmp al, 0
jz short loc_1C2AE
jmp loc_1C37B
loc_1C2AE:
mov rax, [rbp+var_40]
mov [rbp+var_80], rax
mov eax, [rbp+var_14]
mov [rbp+var_71], al
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
cmp [rbp+var_28], 0
jz short loc_1C2D8
mov rax, [rbp+var_28]
mov [rbp+var_88], rax
jmp short loc_1C2E8
loc_1C2D8:
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_88], rax
loc_1C2E8:
mov rdx, [rbp+var_70]
mov al, [rbp+var_71]
mov rdi, [rbp+var_80]
mov rcx, [rbp+var_88]
xor r8d, r8d
movzx esi, al
call ma_net_write_command
cmp eax, 0
jz short loc_1C32A
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D6h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
jmp short loc_1C37B
loc_1C32A:
jmp short $+2
loc_1C32C:
mov [rbp+var_44], 0
mov rax, [rbp+var_40]
mov rax, [rax+2A0h]
cmp dword ptr [rax], 0
jbe short loc_1C347
mov [rbp+var_29], 1
loc_1C347:
cmp [rbp+var_29], 0
jnz short loc_1C379
mov rdi, [rbp+var_10]
call ma_net_safe_read
mov rdx, rax
mov rax, [rbp+var_10]
mov [rax+358h], rdx
mov esi, 0FFFFFFFFh
xor eax, eax
mov ecx, 1
cmp rdx, rsi
cmovz eax, ecx
mov [rbp+var_44], eax
loc_1C379:
jmp short $+2
loc_1C37B:
mov eax, [rbp+var_44]
mov [rbp+var_4], eax
loc_1C381:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
|
long long mthd_my_send_cmd(long long a1, long long a2, char *a3, long long a4, char a5, long long a6)
{
long long v6; // rdx
long long v7; // rcx
int v8; // r8d
int v9; // r9d
long long v10; // rdx
long long v12; // [rsp+8h] [rbp-88h]
long long v13; // [rsp+28h] [rbp-68h]
unsigned int v14; // [rsp+4Ch] [rbp-44h]
v14 = -1;
if ( *(_QWORD *)a1 || !(unsigned __int8)mariadb_reconnect(a1) )
{
if ( *(_DWORD *)(a1 + 1160) || (*(_DWORD *)(a1 + 896) & 8) != 0 )
{
*(_DWORD *)(a1 + 144) = 2014;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[14], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return v14;
}
if ( *(_QWORD *)(a1 + 1264) )
{
if ( **(_QWORD **)(a1 + 1264) )
{
v14 = (*(long long ( **)(long long, _QWORD, char *, long long, _QWORD, long long))(***(_QWORD ***)(a1 + 1264)
+ 112LL))(
a1,
(unsigned int)a2,
a3,
a4,
(unsigned int)a5,
a6);
if ( v14 == -1 )
return (unsigned int)-1;
}
}
*(_DWORD *)(a1 + 144) = 0;
strcpy(a1 + 663, "00000");
*(_BYTE *)(a1 + 151) = 0;
if ( *(_QWORD *)(a1 + 672) )
*(_DWORD *)(*(_QWORD *)(a1 + 672) + 4LL) = 0;
if ( ((_DWORD)a2 == 3 || (_DWORD)a2 == 22)
&& (*(_QWORD *)(a1 + 936) & 0x80LL) != 0
&& *(_QWORD *)(a1 + 1152)
&& *(_BYTE *)(*(_QWORD *)(a1 + 1264) + 120LL) == 1
&& a3
&& (*a3 == 108 || *a3 == 76)
&& !(unsigned int)strncasecmp(a3, "load", 4LL) )
{
*(_BYTE *)(*(_QWORD *)(a1 + 1264) + 120LL) = 2;
}
*(_QWORD *)(a1 + 736) = 0LL;
*(_QWORD *)(a1 + 824) = -1LL;
ma_net_clear(a1);
if ( !a3 )
a3 = "";
if ( **(_DWORD **)(a1 + 672) == 2 )
return (unsigned int)net_add_multi_command(a1, (unsigned __int8)a2, a3, a4);
if ( a4 )
v13 = a4;
else
v13 = strlen(a3);
a2 = (unsigned __int8)a2;
if ( (unsigned int)ma_net_write_command(a1, (unsigned __int8)a2, a3, v13, 0LL) )
{
if ( *(_DWORD *)(a1 + 144) == 1153 )
{
my_set_error(a1, 0x7E4u, (long long)SQLSTATE_UNKNOWN, 0LL);
return v14;
}
end_server((_QWORD *)a1);
if ( (unsigned __int8)mariadb_reconnect(a1) )
return v14;
if ( a4 )
v12 = a4;
else
v12 = strlen(a3);
a2 = (unsigned __int8)a2;
if ( (unsigned int)ma_net_write_command(a1, (unsigned __int8)a2, a3, v12, 0LL) )
{
my_set_error(a1, 0x7D6u, (long long)SQLSTATE_UNKNOWN, 0LL);
return v14;
}
}
v14 = 0;
if ( **(_DWORD **)(a1 + 672) )
a5 = 1;
if ( !a5 )
{
v10 = ma_net_safe_read(a1, a2, v6, v7, v8, v9);
*(_QWORD *)(a1 + 856) = v10;
return v10 == 0xFFFFFFFFLL;
}
return v14;
}
return 1;
}
|
mthd_my_send_cmd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV AL,R8B
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV byte ptr [RBP + -0x29],AL
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x44],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x0011bfc8
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011c390
CMP AL,0x0
JZ 0x0011bfc6
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0011c381
LAB_0011bfc6:
JMP 0x0011bfc8
LAB_0011bfc8:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x488],0x0
JNZ 0x0011bfe7
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x380]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0011c051
LAB_0011bfe7:
JMP 0x0011bfe9
LAB_0011bfe9:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x7de
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RAX,[0x167240]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x97
LEA RAX,[0x167250]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x296],0x0
JMP 0x0011c37b
LAB_0011c051:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x0011c0b8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
CMP qword ptr [RAX],0x0
JZ 0x0011c0b8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x70]
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8B,byte ptr [RBP + -0x29]
MOV R9,qword ptr [RBP + -0x38]
MOVSX R8D,R8B
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP dword ptr [RBP + -0x44],-0x1
JNZ 0x0011c0b6
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0011c381
LAB_0011c0b6:
JMP 0x0011c0b8
LAB_0011c0b8:
JMP 0x0011c0ba
LAB_0011c0ba:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RSI,[0x15296b]
CALL 0x001133c0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x0011c10a
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV dword ptr [RAX + 0x4],0x0
LAB_0011c10a:
JMP 0x0011c10c
LAB_0011c10c:
CMP dword ptr [RBP + -0x14],0x3
JZ 0x0011c11c
CMP dword ptr [RBP + -0x14],0x16
JNZ 0x0011c1a1
LAB_0011c11c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x3a8]
AND RAX,0x80
CMP RAX,0x0
JZ 0x0011c19f
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0011c19f
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOVSX EAX,byte ptr [RAX + 0x78]
CMP EAX,0x1
JNZ 0x0011c19f
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0011c19f
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x6c
JZ 0x0011c174
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x4c
JNZ 0x0011c19f
LAB_0011c174:
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[0x152971]
MOV EDX,0x4
CALL 0x00113570
CMP EAX,0x0
JNZ 0x0011c19d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV byte ptr [RAX + 0x78],0x2
LAB_0011c19d:
JMP 0x0011c19f
LAB_0011c19f:
JMP 0x0011c1a1
LAB_0011c1a1:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2e0],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x338],-0x1
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x0014b5f0
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0011c1da
LEA RAX,[0x1517d9]
MOV qword ptr [RBP + -0x20],RAX
LAB_0011c1da:
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP dword ptr [RAX],0x2
JNZ 0x0011c209
MOV RDI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ESI,AL
CALL 0x0014c640
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0011c381
LAB_0011c209:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0x51],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0011c230
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x0011c23d
LAB_0011c230:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001131a0
MOV qword ptr [RBP + -0x68],RAX
LAB_0011c23d:
MOV RDX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [RBP + -0x51]
MOV RDI,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x68]
XOR R8D,R8D
MOVZX ESI,AL
CALL 0x0014bd90
CMP EAX,0x0
JZ 0x0011c32c
MOV RAX,qword ptr [RBP + -0x40]
CMP dword ptr [RAX + 0x90],0x481
JNZ 0x0011c293
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x167240]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7e4
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x0011bae0
JMP 0x0011c37b
LAB_0011c293:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011ba90
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011c390
CMP AL,0x0
JZ 0x0011c2ae
JMP 0x0011c37b
LAB_0011c2ae:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0x71],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0011c2d8
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x88],RAX
JMP 0x0011c2e8
LAB_0011c2d8:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001131a0
MOV qword ptr [RBP + -0x88],RAX
LAB_0011c2e8:
MOV RDX,qword ptr [RBP + -0x70]
MOV AL,byte ptr [RBP + -0x71]
MOV RDI,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x88]
XOR R8D,R8D
MOVZX ESI,AL
CALL 0x0014bd90
CMP EAX,0x0
JZ 0x0011c32a
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x167240]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d6
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x0011bae0
JMP 0x0011c37b
LAB_0011c32a:
JMP 0x0011c32c
LAB_0011c32c:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP dword ptr [RAX],0x0
JBE 0x0011c347
MOV byte ptr [RBP + -0x29],0x1
LAB_0011c347:
CMP byte ptr [RBP + -0x29],0x0
JNZ 0x0011c379
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011b7d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x358],RDX
MOV ESI,0xffffffff
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,RSI
CMOVZ EAX,ECX
MOV dword ptr [RBP + -0x44],EAX
LAB_0011c379:
JMP 0x0011c37b
LAB_0011c37b:
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x4],EAX
LAB_0011c381:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
uint mthd_my_send_cmd(long *param_1,uint param_2,char *param_3,size_t param_4,char param_5,
int8 param_6)
{
char cVar1;
int iVar2;
uint uVar3;
long lVar4;
size_t local_90;
size_t local_70;
uint local_4c;
char local_31;
char *local_28;
local_4c = 0xffffffff;
if ((*param_1 == 0) && (cVar1 = mariadb_reconnect(param_1), cVar1 != '\0')) {
return 1;
}
if (((int)param_1[0x91] != 0) || ((*(uint *)(param_1 + 0x70) & 8) != 0)) {
*(int4 *)(param_1 + 0x12) = 0x7de;
strncpy((char *)((long)param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)((long)param_1 + 0x29c) = 0;
strncpy((char *)((long)param_1 + 0x97),PTR_s_Commands_out_of_sync__you_can_t_r_001672c0,0x1ff);
*(int1 *)((long)param_1 + 0x296) = 0;
return 0xffffffff;
}
if (((param_1[0x9e] != 0) && (*(long *)param_1[0x9e] != 0)) &&
(local_4c = (**(code **)(**(long **)param_1[0x9e] + 0x70))
(param_1,param_2,param_3,param_4,(int)param_5,param_6),
local_4c == 0xffffffff)) {
return 0xffffffff;
}
*(int4 *)(param_1 + 0x12) = 0;
strcpy((char *)((long)param_1 + 0x297),"00000");
*(int1 *)((long)param_1 + 0x97) = 0;
if (param_1[0x54] != 0) {
*(int4 *)(param_1[0x54] + 4) = 0;
}
if (((((param_2 == 3) || (param_2 == 0x16)) &&
(((param_1[0x75] & 0x80U) != 0 &&
((param_1[0x90] != 0 && (*(char *)(param_1[0x9e] + 0x78) == '\x01')))))) &&
(param_3 != (char *)0x0)) &&
(((*param_3 == 'l' || (*param_3 == 'L')) && (iVar2 = strncasecmp(param_3,"load",4), iVar2 == 0)
))) {
*(int1 *)(param_1[0x9e] + 0x78) = 2;
}
param_1[0x5c] = 0;
param_1[0x67] = -1;
ma_net_clear(param_1);
local_28 = param_3;
if (param_3 == (char *)0x0) {
local_28 = "";
}
if (*(int *)param_1[0x54] != 2) {
local_70 = param_4;
if (param_4 == 0) {
local_70 = strlen(local_28);
}
iVar2 = ma_net_write_command(param_1,(char)param_2,local_28,local_70,0);
if (iVar2 != 0) {
if ((int)param_1[0x12] == 0x481) {
my_set_error(param_1,0x7e4,SQLSTATE_UNKNOWN,0);
return local_4c;
}
end_server(param_1);
cVar1 = mariadb_reconnect(param_1);
if (cVar1 != '\0') {
return local_4c;
}
local_90 = param_4;
if (param_4 == 0) {
local_90 = strlen(local_28);
}
iVar2 = ma_net_write_command(param_1,(char)param_2,local_28,local_90,0);
if (iVar2 != 0) {
my_set_error(param_1,0x7d6,SQLSTATE_UNKNOWN,0);
return local_4c;
}
}
local_4c = 0;
local_31 = param_5;
if (*(int *)param_1[0x54] != 0) {
local_31 = '\x01';
}
if (local_31 == '\0') {
lVar4 = ma_net_safe_read(param_1);
param_1[0x6b] = lVar4;
local_4c = (uint)(lVar4 == 0xffffffff);
}
return local_4c;
}
uVar3 = net_add_multi_command(param_1,param_2 & 0xff,local_28,param_4);
return uVar3;
}
|
|
64,725 |
make_block_q4_0x8(block_q4_0*, unsigned int)
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp
|
static block_q4_0x8 make_block_q4_0x8(block_q4_0 * in, unsigned int blck_size_interleave) {
block_q4_0x8 out;
for (int i = 0; i < 8; i++) {
out.d[i] = in[i].d;
}
const int end = QK4_0 * 4 / blck_size_interleave;
const uint64_t xor_mask = 0x8888888888888888ULL;
for (int i = 0; i < end; ++i) {
int src_id = i % 8;
int src_offset = (i / 8) * blck_size_interleave;
int dst_offset = i * blck_size_interleave;
uint64_t elems;
memcpy(&elems, &in[src_id].qs[src_offset], sizeof(uint64_t));
elems ^= xor_mask;
memcpy(&out.qs[dst_offset], &elems, sizeof(uint64_t));
}
return out;
}
|
O0
|
cpp
|
make_block_q4_0x8(block_q4_0*, unsigned int):
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x4f469
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x12, %rdx, %rdx
addq %rdx, %rcx
movw (%rcx), %dx
movslq -0x10(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4f43a
movl $0x80, %eax
xorl %edx, %edx
divl -0xc(%rbp)
movl %eax, -0x14(%rbp)
movabsq $-0x7777777777777778, %rax # imm = 0x8888888888888888
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4f509
movl -0x24(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x48(%rbp), %rax
imull -0xc(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movl -0x24(%rbp), %ecx
imull -0xc(%rbp), %ecx
movl %ecx, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movslq -0x28(%rbp), %rdx
imulq $0x12, %rdx, %rdx
addq %rdx, %rcx
movslq -0x2c(%rbp), %rdx
movq 0x2(%rcx,%rdx), %rcx
movq %rcx, -0x38(%rbp)
movabsq $-0x7777777777777778, %rcx # imm = 0x8888888888888888
xorq -0x38(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movslq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq %rdx, 0x10(%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4f48b
movq -0x40(%rbp), %rax
popq %rbp
retq
nop
|
_ZL17make_block_q4_0x8P10block_q4_0j:
push rbp
mov rbp, rsp
mov [rbp+var_48], rdi
mov [rbp+var_40], rdi
mov [rbp+var_8], rsi
mov [rbp+var_C], edx
mov [rbp+var_10], 0
loc_4F43A:
cmp [rbp+var_10], 8
jge short loc_4F469
mov rax, [rbp+var_48]
mov rcx, [rbp+var_8]
movsxd rdx, [rbp+var_10]
imul rdx, 12h
add rcx, rdx
mov dx, [rcx]
movsxd rcx, [rbp+var_10]
mov [rax+rcx*2], dx
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp short loc_4F43A
loc_4F469:
mov eax, 80h
xor edx, edx
div [rbp+var_C]
mov [rbp+var_14], eax
mov rax, 8888888888888888h
mov [rbp+var_20], rax
mov [rbp+var_24], 0
loc_4F48B:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_14]
jge short loc_4F509
mov eax, [rbp+var_24]
mov ecx, 8
cdq
idiv ecx
mov [rbp+var_28], edx
mov eax, [rbp+var_24]
mov ecx, 8
cdq
idiv ecx
mov ecx, eax
mov rax, [rbp+var_48]
imul ecx, [rbp+var_C]
mov [rbp+var_2C], ecx
mov ecx, [rbp+var_24]
imul ecx, [rbp+var_C]
mov [rbp+var_30], ecx
mov rcx, [rbp+var_8]
movsxd rdx, [rbp+var_28]
imul rdx, 12h
add rcx, rdx
movsxd rdx, [rbp+var_2C]
mov rcx, [rcx+rdx+2]
mov [rbp+var_38], rcx
mov rcx, 8888888888888888h
xor rcx, [rbp+var_38]
mov [rbp+var_38], rcx
movsxd rcx, [rbp+var_30]
mov rdx, [rbp+var_38]
mov [rax+rcx+10h], rdx
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_4F48B
loc_4F509:
mov rax, [rbp+var_40]
pop rbp
retn
|
long long make_block_q4_0x8(long long a1, long long a2, unsigned int a3)
{
signed int j; // [rsp+24h] [rbp-24h]
int i; // [rsp+38h] [rbp-10h]
for ( i = 0; i < 8; ++i )
*(_WORD *)(a1 + 2LL * i) = *(_WORD *)(18LL * i + a2);
for ( j = 0; j < (int)(0x80 / a3); ++j )
*(_QWORD *)(a1 + (int)(a3 * j) + 16) = *(_QWORD *)(18LL * (j % 8) + a2 + (int)(a3 * (j / 8)) + 2) ^ 0x8888888888888888LL;
return a1;
}
|
make_block_q4_0x8:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x40],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV dword ptr [RBP + -0xc],EDX
MOV dword ptr [RBP + -0x10],0x0
LAB_0014f43a:
CMP dword ptr [RBP + -0x10],0x8
JGE 0x0014f469
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RDX,dword ptr [RBP + -0x10]
IMUL RDX,RDX,0x12
ADD RCX,RDX
MOV DX,word ptr [RCX]
MOVSXD RCX,dword ptr [RBP + -0x10]
MOV word ptr [RAX + RCX*0x2],DX
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0014f43a
LAB_0014f469:
MOV EAX,0x80
XOR EDX,EDX
DIV dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,-0x7777777777777778
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x24],0x0
LAB_0014f48b:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x0014f509
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,0x8
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x28],EDX
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,0x8
CDQ
IDIV ECX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x48]
IMUL ECX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x2c],ECX
MOV ECX,dword ptr [RBP + -0x24]
IMUL ECX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x30],ECX
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RDX,dword ptr [RBP + -0x28]
IMUL RDX,RDX,0x12
ADD RCX,RDX
MOVSXD RDX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RCX + RDX*0x1 + 0x2]
MOV qword ptr [RBP + -0x38],RCX
MOV RCX,-0x7777777777777778
XOR RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RCX
MOVSXD RCX,dword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + RCX*0x1 + 0x10],RDX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0014f48b
LAB_0014f509:
MOV RAX,qword ptr [RBP + -0x40]
POP RBP
RET
|
/* make_block_q4_0x8(block_q4_0*, unsigned int) */
int1 [16] make_block_q4_0x8(block_q4_0 *param_1,uint param_2)
{
ulong uVar1;
uint in_EDX;
int4 in_register_00000034;
int1 auVar2 [16];
int local_2c;
int local_18;
for (local_18 = 0; local_18 < 8; local_18 = local_18 + 1) {
*(int2 *)(param_1 + (long)local_18 * 2) =
*(int2 *)(CONCAT44(in_register_00000034,param_2) + (long)local_18 * 0x12);
}
uVar1 = 0x80 % (ulong)in_EDX;
for (local_2c = 0; local_2c < (int)(0x80 / (ulong)in_EDX); local_2c = local_2c + 1) {
uVar1 = *(ulong *)(CONCAT44(in_register_00000034,param_2) + (long)(local_2c % 8) * 0x12 + 2 +
(long)(int)((local_2c / 8) * in_EDX)) ^ 0x8888888888888888;
*(ulong *)(param_1 + (long)(int)(local_2c * in_EDX) + 0x10) = uVar1;
}
auVar2._8_8_ = uVar1;
auVar2._0_8_ = param_1;
return auVar2;
}
|
|
64,726 |
minja::Value& nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::operator[]<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
llama.cpp/common/json.hpp
|
T & operator[](KeyType && key)
{
return emplace(std::forward<KeyType>(key), T{}).first->second;
}
|
O3
|
cpp
|
minja::Value& nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::operator[]<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x40(%rsp), %r14
movq $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%r14)
movaps %xmm0, -0x30(%r14)
movaps %xmm0, -0x20(%r14)
movaps %xmm0, -0x10(%r14)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x732fc
movq %r14, %rdi
movl $0x1, %esi
callq 0x732fc
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x745c0
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x732fc
movq %r14, %rdi
callq 0x300e0
leaq 0x38(%rsp), %rdi
callq 0x34564
leaq 0x28(%rsp), %rdi
callq 0x34564
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x34564
movq -0x10(%r14), %rdi
testq %rdi, %rdi
je 0x7434a
movq 0x8bc6b(%rip), %rax # 0xfff90
cmpb $0x0, (%rax)
je 0x74335
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x7433f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x7434a
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6cc36
movq %rbx, %rdi
callq 0x1c7d0
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rsi
mov r15, rdi
lea r14, [rsp+68h+var_28]
mov qword ptr [r14+8], 0
xorps xmm0, xmm0
movaps xmmword ptr [r14-40h], xmm0
movaps xmmword ptr [r14-30h], xmm0
movaps xmmword ptr [r14-20h], xmm0
movaps xmmword ptr [r14-10h], xmm0
mov byte ptr [r14], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdx, rsp
mov rdi, r15
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_
mov rbx, rax
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+68h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea r14, [rsp+68h+var_50]
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [r14-10h]
test rdi, rdi
jz short loc_7434A
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_74335
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_7433F
loc_74335:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_7433F:
cmp eax, 1
jnz short loc_7434A
mov rax, [rdi]
call qword ptr [rax+18h]
loc_7434A:
add rbx, 10h
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_(
long long a1,
long long a2)
{
long long v2; // rbx
long long v3; // rdi
signed __int32 v4; // eax
__int128 v6; // [rsp+0h] [rbp-68h] BYREF
__int128 v7; // [rsp+10h] [rbp-58h] BYREF
__int128 v8; // [rsp+20h] [rbp-48h] BYREF
__int128 v9; // [rsp+30h] [rbp-38h] BYREF
char v10[8]; // [rsp+40h] [rbp-28h] BYREF
long long v11; // [rsp+48h] [rbp-20h]
v11 = 0LL;
v6 = 0LL;
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
v10[0] = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v10);
v2 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_(
a1,
a2,
&v6);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v10);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v9 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v8 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v7 + 1);
v3 = *((_QWORD *)&v6 + 1);
if ( *((_QWORD *)&v6 + 1) )
{
if ( _libc_single_threaded )
{
v4 = *(_DWORD *)(*((_QWORD *)&v6 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v6 + 1) + 12LL) = v4 - 1;
}
else
{
v4 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v6 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v4 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v3 + 24LL))(v3, 0LL);
}
return v2 + 16;
}
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RSI
MOV R15,RDI
LEA R14,[RSP + 0x40]
MOV qword ptr [R14 + 0x8],0x0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14 + -0x40],XMM0
MOVAPS xmmword ptr [R14 + -0x30],XMM0
MOVAPS xmmword ptr [R14 + -0x20],XMM0
MOVAPS xmmword ptr [R14 + -0x10],XMM0
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001732fc
MOV RDI,R14
MOV ESI,0x1
CALL 0x001732fc
LAB_001742d1:
MOV RDX,RSP
MOV RDI,R15
MOV RSI,RBX
CALL 0x001745c0
LAB_001742df:
MOV RBX,RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x001732fc
MOV RDI,R14
CALL 0x001300e0
LEA RDI,[RSP + 0x38]
CALL 0x00134564
LEA RDI,[RSP + 0x28]
CALL 0x00134564
LEA R14,[RSP + 0x18]
MOV RDI,R14
CALL 0x00134564
MOV RDI,qword ptr [R14 + -0x10]
TEST RDI,RDI
JZ 0x0017434a
MOV RAX,qword ptr [0x001fff90]
CMP byte ptr [RAX],0x0
JZ 0x00174335
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0017433f
LAB_00174335:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0017433f:
CMP EAX,0x1
JNZ 0x0017434a
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0017434a:
ADD RBX,0x10
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
long _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_
(int8 param_1,int8 param_2)
{
int *piVar1;
int iVar2;
long lVar3;
bool bVar4;
int8 local_68;
long *plStack_60;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
int8 uStack_30;
data local_28 [8];
int8 local_20;
local_20 = 0;
local_68 = 0;
plStack_60 = (long *)0x0;
local_58 = 0;
uStack_50 = 0;
local_48 = 0;
uStack_40 = 0;
local_38 = 0;
uStack_30 = 0;
local_28[0] = (data)0x0;
bVar4 = SUB81(local_28,0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar4);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar4);
/* try { // try from 001742d1 to 001742de has its CatchHandler @ 0017435b */
lVar3 = _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_
(param_1,param_2,&local_68);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar4);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_28);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_50);
if (plStack_60 != (long *)0x0) {
if (*PTR___libc_single_threaded_001fff90 == '\0') {
LOCK();
piVar1 = (int *)((long)plStack_60 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)plStack_60 + 0xc);
*(int *)((long)plStack_60 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*plStack_60 + 0x18))();
}
}
return lVar3 + 0x10;
}
|
|
64,727 |
my_caseup_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static size_t my_caseup_ucs2(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_ucs2_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
{
my_toupper_ucs2(uni_plane, &wc);
if (res != my_uni_ucs2(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O0
|
c
|
my_caseup_ucs2:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xad512
jmp 0xad514
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0xad544
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0xad430
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xad54d
jmp 0xad5a7
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb2360
movl -0x34(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xad460
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
je 0xad580
jmp 0xad5a7
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xad514
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_caseup_ucs2:
push rbp
mov rbp, rsp
sub rsp, 60h
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]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_50], rax
jmp short $+2
loc_AD512:
jmp short $+2
loc_AD514:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_51], al
jnb short loc_AD544
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_ucs2_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_51], al
loc_AD544:
mov al, [rbp+var_51]
test al, 1
jnz short loc_AD54D
jmp short loc_AD5A7
loc_AD54D:
mov rdi, [rbp+var_50]
lea rsi, [rbp+var_30]
call my_toupper_ucs2
mov eax, [rbp+var_34]
mov [rbp+var_58], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_uni_ucs2
mov ecx, eax
mov eax, [rbp+var_58]
cmp eax, ecx
jz short loc_AD580
jmp short loc_AD5A7
loc_AD580:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_AD514
loc_AD5A7:
mov rax, [rbp+var_18]
add rsp, 60h
pop rbp
retn
|
long long my_caseup_ucs2(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+Fh] [rbp-51h]
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v9; // [rsp+18h] [rbp-48h]
unsigned long long v10; // [rsp+20h] [rbp-40h]
int v11; // [rsp+2Ch] [rbp-34h]
unsigned long long v12[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v13; // [rsp+40h] [rbp-20h]
long long v14; // [rsp+48h] [rbp-18h]
unsigned long long v15; // [rsp+50h] [rbp-10h]
long long v16; // [rsp+58h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12[1] = a5;
v10 = a3 + a2;
v9 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v15 < v10 )
{
v11 = my_ucs2_uni(v16, (long long)v12, v15, v10, a5, a6);
v7 = v11 > 0;
}
if ( !v7 )
break;
my_toupper_ucs2(v8, v12);
if ( v11 != (unsigned int)my_uni_ucs2(v16, v12[0], v13, v9) )
break;
v15 += v11;
v13 += v11;
}
return v14;
}
|
my_caseup_ucs2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
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]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001ad512
LAB_001ad512:
JMP 0x001ad514
LAB_001ad514:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x51],AL
JNC 0x001ad544
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x001ad430
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x51],AL
LAB_001ad544:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x001ad54d
JMP 0x001ad5a7
LAB_001ad54d:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL 0x001b2360
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x58],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x001ad460
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x58]
CMP EAX,ECX
JZ 0x001ad580
JMP 0x001ad5a7
LAB_001ad580:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001ad514
LAB_001ad5a7:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x60
POP RBP
RET
|
long my_caseup_ucs2(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_ucs2_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_toupper_ucs2(uVar1,&local_38);
iVar3 = my_uni_ucs2(local_10,local_38,local_28,param_4 + param_5);
if (local_3c != iVar3) {
return local_20;
}
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + local_3c;
}
return local_20;
}
|
|
64,728 |
add_pc2line_info
|
bluesky950520[P]quickjs/quickjs.c
|
static void add_pc2line_info(JSFunctionDef *s, uint32_t pc,
int line_num, int col_num)
{
if (s->source_loc_slots == NULL)
return;
if (s->source_loc_count >= s->source_loc_size)
return;
if (pc < s->line_number_last_pc)
return;
if (line_num == s->line_number_last)
if (col_num == s->col_number_last)
return;
s->source_loc_slots[s->source_loc_count].pc = pc;
s->source_loc_slots[s->source_loc_count].line_num = line_num;
s->source_loc_slots[s->source_loc_count].col_num = col_num;
s->source_loc_count++;
s->line_number_last_pc = pc;
s->line_number_last = line_num;
s->col_number_last = col_num;
}
|
O1
|
c
|
add_pc2line_info:
movq 0x1b8(%rdi), %rax
testq %rax, %rax
je 0x6f5d6
movslq 0x1c4(%rdi), %r8
cmpl 0x1c0(%rdi), %r8d
jge 0x6f5d6
cmpl %esi, 0x1cc(%rdi)
ja 0x6f5d6
cmpl %edx, 0x1c8(%rdi)
jne 0x6f5a8
cmpl %ecx, 0x1d0(%rdi)
je 0x6f5d6
leaq (%r8,%r8,2), %r9
movl %esi, (%rax,%r9,4)
movl %edx, 0x4(%rax,%r9,4)
movl %ecx, 0x8(%rax,%r9,4)
leal 0x1(%r8), %eax
movl %eax, 0x1c4(%rdi)
movl %esi, 0x1cc(%rdi)
movl %edx, 0x1c8(%rdi)
movl %ecx, 0x1d0(%rdi)
retq
|
add_pc2line_info:
mov rax, [rdi+1B8h]
test rax, rax
jz short locret_6F5D6
movsxd r8, dword ptr [rdi+1C4h]
cmp r8d, [rdi+1C0h]
jge short locret_6F5D6
cmp [rdi+1CCh], esi
ja short locret_6F5D6
cmp [rdi+1C8h], edx
jnz short loc_6F5A8
cmp [rdi+1D0h], ecx
jz short locret_6F5D6
loc_6F5A8:
lea r9, [r8+r8*2]
mov [rax+r9*4], esi
mov [rax+r9*4+4], edx
mov [rax+r9*4+8], ecx
lea eax, [r8+1]
mov [rdi+1C4h], eax
mov [rdi+1CCh], esi
mov [rdi+1C8h], edx
mov [rdi+1D0h], ecx
locret_6F5D6:
retn
|
long long add_pc2line_info(long long a1, unsigned int a2, int a3, int a4)
{
long long result; // rax
long long v5; // r8
long long v6; // r9
result = *(_QWORD *)(a1 + 440);
if ( result )
{
v5 = *(int *)(a1 + 452);
if ( (int)v5 < *(_DWORD *)(a1 + 448)
&& *(_DWORD *)(a1 + 460) <= a2
&& (*(_DWORD *)(a1 + 456) != a3 || *(_DWORD *)(a1 + 464) != a4) )
{
v6 = 3 * v5;
*(_DWORD *)(result + 4 * v6) = a2;
*(_DWORD *)(result + 4 * v6 + 4) = a3;
*(_DWORD *)(result + 4 * v6 + 8) = a4;
result = (unsigned int)(v5 + 1);
*(_DWORD *)(a1 + 452) = result;
*(_DWORD *)(a1 + 460) = a2;
*(_DWORD *)(a1 + 456) = a3;
*(_DWORD *)(a1 + 464) = a4;
}
}
return result;
}
|
add_pc2line_info:
MOV RAX,qword ptr [RDI + 0x1b8]
TEST RAX,RAX
JZ 0x0016f5d6
MOVSXD R8,dword ptr [RDI + 0x1c4]
CMP R8D,dword ptr [RDI + 0x1c0]
JGE 0x0016f5d6
CMP dword ptr [RDI + 0x1cc],ESI
JA 0x0016f5d6
CMP dword ptr [RDI + 0x1c8],EDX
JNZ 0x0016f5a8
CMP dword ptr [RDI + 0x1d0],ECX
JZ 0x0016f5d6
LAB_0016f5a8:
LEA R9,[R8 + R8*0x2]
MOV dword ptr [RAX + R9*0x4],ESI
MOV dword ptr [RAX + R9*0x4 + 0x4],EDX
MOV dword ptr [RAX + R9*0x4 + 0x8],ECX
LEA EAX,[R8 + 0x1]
MOV dword ptr [RDI + 0x1c4],EAX
MOV dword ptr [RDI + 0x1cc],ESI
MOV dword ptr [RDI + 0x1c8],EDX
MOV dword ptr [RDI + 0x1d0],ECX
LAB_0016f5d6:
RET
|
void add_pc2line_info(long param_1,uint param_2,int param_3,int param_4)
{
int iVar1;
long lVar2;
long lVar3;
lVar2 = *(long *)(param_1 + 0x1b8);
if (lVar2 != 0) {
iVar1 = *(int *)(param_1 + 0x1c4);
lVar3 = (long)iVar1;
if (((iVar1 < *(int *)(param_1 + 0x1c0)) && (*(uint *)(param_1 + 0x1cc) <= param_2)) &&
((*(int *)(param_1 + 0x1c8) != param_3 || (*(int *)(param_1 + 0x1d0) != param_4)))) {
*(uint *)(lVar2 + lVar3 * 0xc) = param_2;
*(int *)(lVar2 + 4 + lVar3 * 0xc) = param_3;
*(int *)(lVar2 + 8 + lVar3 * 0xc) = param_4;
*(int *)(param_1 + 0x1c4) = iVar1 + 1;
*(uint *)(param_1 + 0x1cc) = param_2;
*(int *)(param_1 + 0x1c8) = param_3;
*(int *)(param_1 + 0x1d0) = param_4;
}
}
return;
}
|
|
64,729 |
list_delete
|
eloqsql/mysys/list.c
|
LIST *list_delete(LIST *root, LIST *element)
{
if (element->prev)
element->prev->next=element->next;
else
root=element->next;
if (element->next)
element->next->prev=element->prev;
return root;
}
|
O0
|
c
|
list_delete:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdf42b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0xdf437
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdf454
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
|
list_delete:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jz short loc_DF42B
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rax+8], rcx
jmp short loc_DF437
loc_DF42B:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_8], rax
loc_DF437:
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 0
jz short loc_DF454
mov rax, [rbp+var_10]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rax], rcx
loc_DF454:
mov rax, [rbp+var_8]
pop rbp
retn
|
long long list_delete(long long a1, _QWORD *a2)
{
if ( *a2 )
*(_QWORD *)(*a2 + 8LL) = a2[1];
else
a1 = a2[1];
if ( a2[1] )
*(_QWORD *)a2[1] = *a2;
return a1;
}
|
list_delete:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JZ 0x001df42b
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001df437
LAB_001df42b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
LAB_001df437:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x001df454
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX],RCX
LAB_001df454:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long list_delete(long param_1,long *param_2)
{
long local_10;
if (*param_2 == 0) {
local_10 = param_2[1];
}
else {
*(long *)(*param_2 + 8) = param_2[1];
local_10 = param_1;
}
if (param_2[1] != 0) {
*(long *)param_2[1] = *param_2;
}
return local_10;
}
|
|
64,730 |
list_delete
|
eloqsql/mysys/list.c
|
LIST *list_delete(LIST *root, LIST *element)
{
if (element->prev)
element->prev->next=element->next;
else
root=element->next;
if (element->next)
element->next->prev=element->prev;
return root;
}
|
O3
|
c
|
list_delete:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
movq %rcx, %rax
testq %rdx, %rdx
je 0x947d2
movq %rcx, 0x8(%rdx)
movq %rdi, %rax
testq %rcx, %rcx
je 0x947dd
movq (%rsi), %rdx
movq %rdx, (%rcx)
popq %rbp
retq
|
list_delete:
push rbp
mov rbp, rsp
mov rdx, [rsi]
mov rcx, [rsi+8]
mov rax, rcx
test rdx, rdx
jz short loc_947D2
mov [rdx+8], rcx
mov rax, rdi
loc_947D2:
test rcx, rcx
jz short loc_947DD
mov rdx, [rsi]
mov [rcx], rdx
loc_947DD:
pop rbp
retn
|
_QWORD * list_delete(_QWORD *a1, _QWORD *a2)
{
_QWORD *v2; // rcx
_QWORD *result; // rax
v2 = (_QWORD *)a2[1];
result = v2;
if ( *a2 )
{
*(_QWORD *)(*a2 + 8LL) = v2;
result = a1;
}
if ( v2 )
*v2 = *a2;
return result;
}
|
list_delete:
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
MOV RAX,RCX
TEST RDX,RDX
JZ 0x001947d2
MOV qword ptr [RDX + 0x8],RCX
MOV RAX,RDI
LAB_001947d2:
TEST RCX,RCX
JZ 0x001947dd
MOV RDX,qword ptr [RSI]
MOV qword ptr [RCX],RDX
LAB_001947dd:
POP RBP
RET
|
long * list_delete(long *param_1,long *param_2)
{
long *plVar1;
long *plVar2;
plVar1 = (long *)param_2[1];
plVar2 = plVar1;
if (*param_2 != 0) {
*(long **)(*param_2 + 8) = plVar1;
plVar2 = param_1;
}
if (plVar1 != (long *)0x0) {
*plVar1 = *param_2;
}
return plVar2;
}
|
|
64,731 |
Settings::getLastResult[abi:cxx11]() const
|
666mxvbee[P]BattleShip/lib/Settings/Settings.cpp
|
std::string Settings::getLastResult() const {
std::lock_guard<std::mutex> lock(settings_mutex);
return lastResult;
}
|
O1
|
cpp
|
Settings::getLastResult[abi:cxx11]() const:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5500
testl %eax, %eax
jne 0x7025
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq 0xd8(%rbx), %rsi
movq 0xe0(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x763e
movq %rbx, %rdi
callq 0x52d0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x5260
movq %rax, %r14
movq %rbx, %rdi
callq 0x52d0
movq %r14, %rdi
callq 0x55e0
nop
|
_ZNK8Settings13getLastResultB5cxx11Ev:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, rsi
call _pthread_mutex_lock
test eax, eax
jnz short loc_7025
lea rax, [r14+10h]
mov [r14], rax
mov rsi, [rbx+0D8h]
mov rdx, [rbx+0E0h]
add rdx, rsi
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rdi, rbx
call _pthread_mutex_unlock
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
loc_7025:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov r14, rax
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
|
_QWORD * Settings::getLastResult[abi:cxx11](_QWORD *a1, long long a2)
{
int v2; // eax
v2 = pthread_mutex_lock(a2);
if ( v2 )
std::__throw_system_error(v2);
*a1 = a1 + 2;
std::string::_M_construct<char *>(a1, *(_QWORD *)(a2 + 216), *(_QWORD *)(a2 + 216) + *(_QWORD *)(a2 + 224));
pthread_mutex_unlock(a2);
return a1;
}
|
getLastResult[abi:cxx11]:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
CALL 0x00105500
TEST EAX,EAX
JNZ 0x00107025
LEA RAX,[R14 + 0x10]
MOV qword ptr [R14],RAX
MOV RSI,qword ptr [RBX + 0xd8]
MOV RDX,qword ptr [RBX + 0xe0]
ADD RDX,RSI
LAB_0010700a:
MOV RDI,R14
CALL 0x0010763e
LAB_00107012:
MOV RDI,RBX
CALL 0x001052d0
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00107025:
MOV EDI,EAX
CALL 0x00105260
|
/* Settings::getLastResult[abi:cxx11]() const */
void Settings::getLastResult_abi_cxx11_(void)
{
int iVar1;
pthread_mutex_t *in_RSI;
long *in_RDI;
iVar1 = pthread_mutex_lock(in_RSI);
if (iVar1 == 0) {
*in_RDI = (long)(in_RDI + 2);
/* try { // try from 0010700a to 00107011 has its CatchHandler @ 0010702c */
std::__cxx11::string::_M_construct<char*>();
pthread_mutex_unlock(in_RSI);
return;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar1);
}
|
|
64,732 |
ggml_map_custom1_impl
|
ngxson[P]ggml-easy/ggml/src/ggml.c
|
static struct ggml_tensor * ggml_map_custom1_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
const ggml_custom1_op_t fun,
int n_tasks,
void * userdata,
bool inplace) {
GGML_ASSERT(n_tasks == GGML_N_TASKS_MAX || n_tasks > 0);
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
struct ggml_map_custom1_op_params params = {
/*.fun =*/ fun,
/*.n_tasks =*/ n_tasks,
/*.userdata =*/ userdata
};
ggml_set_op_params(result, ¶ms, sizeof(params));
result->op = GGML_OP_MAP_CUSTOM1;
result->src[0] = a;
return result;
}
|
O1
|
c
|
ggml_map_custom1_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
cmpl $-0x1, %ecx
sete %al
testl %ecx, %ecx
setg %cl
orb %al, %cl
je 0x1f8ab
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r14
testb %r9b, %r9b
je 0x1f86b
movq %r14, %rsi
callq 0x16260
jmp 0x1f882
movl (%r14), %esi
leaq 0x10(%r14), %rcx
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x19cd9
testq %rax, %rax
je 0x1f8c7
movq %r15, 0x54(%rax)
movl %ebp, 0x5c(%rax)
movq %rbx, 0x64(%rax)
movl $0x4b, 0x50(%rax)
movq %r14, 0x98(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ad5d(%rip), %rdi # 0x4a60f
leaq 0x2ada1(%rip), %rdx # 0x4a65a
leaq 0x2d18a(%rip), %rcx # 0x4ca4a
movl $0x1322, %esi # imm = 0x1322
jmp 0x1f8e1
leaq 0x2cf0a(%rip), %rdi # 0x4c7d8
leaq 0x2ad85(%rip), %rdx # 0x4a65a
leaq 0x2cf4c(%rip), %rcx # 0x4c828
movl $0x70, %esi
xorl %eax, %eax
callq 0x17c70
|
ggml_map_custom1_impl:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, ecx
cmp ecx, 0FFFFFFFFh
setz al
test ecx, ecx
setnle cl
or cl, al
jz short loc_1F8AB
mov rbx, r8
mov r15, rdx
mov r14, rsi
test r9b, r9b
jz short loc_1F86B
mov rsi, r14
call _ggml_view_tensor
jmp short loc_1F882
loc_1F86B:
mov esi, [r14]
lea rcx, [r14+10h]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_1F882:
test rax, rax
jz short loc_1F8C7
mov [rax+54h], r15
mov [rax+5Ch], ebp
mov [rax+64h], rbx
mov dword ptr [rax+50h], 4Bh ; 'K'
mov [rax+98h], r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_1F8AB:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNTasksGgmlNTas; "n_tasks == GGML_N_TASKS_MAX || n_tasks "...
mov esi, 1322h
jmp short loc_1F8E1
loc_1F8C7:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorNull; "tensor != NULL"
mov esi, 70h ; 'p'
loc_1F8E1:
xor eax, eax
call _ggml_abort
|
long long ggml_map_custom1_impl(long long a1, long long a2, long long a3, int a4, long long a5, char a6)
{
long long result; // rax
const char *v10; // rdi
const char *v11; // rcx
int v12; // esi
if ( a4 != -1 && a4 <= 0 )
{
v10 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
v11 = "n_tasks == GGML_N_TASKS_MAX || n_tasks > 0";
v12 = 4898;
goto LABEL_9;
}
if ( a6 )
result = ggml_view_tensor(a1, a2);
else
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, (_QWORD *)(a2 + 16), 0LL, 0LL);
if ( !result )
{
v10 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-impl.h";
v11 = "tensor != NULL";
v12 = 112;
LABEL_9:
ggml_abort((_DWORD)v10, v12, (unsigned int)"GGML_ASSERT(%s) failed", (_DWORD)v11, a5, a6);
}
*(_QWORD *)(result + 84) = a3;
*(_DWORD *)(result + 92) = a4;
*(_QWORD *)(result + 100) = a5;
*(_DWORD *)(result + 80) = 75;
*(_QWORD *)(result + 152) = a2;
return result;
}
|
ggml_map_custom1_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,ECX
CMP ECX,-0x1
SETZ AL
TEST ECX,ECX
SETG CL
OR CL,AL
JZ 0x0011f8ab
MOV RBX,R8
MOV R15,RDX
MOV R14,RSI
TEST R9B,R9B
JZ 0x0011f86b
MOV RSI,R14
CALL 0x00116260
JMP 0x0011f882
LAB_0011f86b:
MOV ESI,dword ptr [R14]
LEA RCX,[R14 + 0x10]
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00119cd9
LAB_0011f882:
TEST RAX,RAX
JZ 0x0011f8c7
MOV qword ptr [RAX + 0x54],R15
MOV dword ptr [RAX + 0x5c],EBP
MOV qword ptr [RAX + 0x64],RBX
MOV dword ptr [RAX + 0x50],0x4b
MOV qword ptr [RAX + 0x98],R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0011f8ab:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a65a]
LEA RCX,[0x14ca4a]
MOV ESI,0x1322
JMP 0x0011f8e1
LAB_0011f8c7:
LEA RDI,[0x14c7d8]
LEA RDX,[0x14a65a]
LEA RCX,[0x14c828]
MOV ESI,0x70
LAB_0011f8e1:
XOR EAX,EAX
CALL 0x00117c70
|
void ggml_map_custom1_impl
(int8 param_1,int4 *param_2,int8 param_3,int param_4,
int8 param_5,char param_6)
{
long lVar1;
char *pcVar2;
int8 uVar3;
char *pcVar4;
if (param_4 < 1 && param_4 != -1) {
pcVar4 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
pcVar2 = "n_tasks == GGML_N_TASKS_MAX || n_tasks > 0";
uVar3 = 0x1322;
}
else {
if (param_6 == '\0') {
lVar1 = ggml_new_tensor_impl(param_1,*param_2,4,param_2 + 4,0,0);
}
else {
lVar1 = ggml_view_tensor(param_1,param_2);
}
if (lVar1 != 0) {
*(int8 *)(lVar1 + 0x54) = param_3;
*(int *)(lVar1 + 0x5c) = param_4;
*(int8 *)(lVar1 + 100) = param_5;
*(int4 *)(lVar1 + 0x50) = 0x4b;
*(int4 **)(lVar1 + 0x98) = param_2;
return;
}
pcVar4 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-impl.h";
pcVar2 = "tensor != NULL";
uVar3 = 0x70;
}
/* WARNING: Subroutine does not return */
ggml_abort(pcVar4,uVar3,"GGML_ASSERT(%s) failed",pcVar2);
}
|
|
64,733 |
intx::internal::submul(unsigned long*, unsigned long const*, unsigned long const*, int, unsigned long)
|
corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp
|
inline uint64_t submul(
uint64_t r[], const uint64_t x[], const uint64_t y[], int len, uint64_t multiplier) noexcept
{
// OPT: Add MinLen template parameter and unroll first loop iterations.
INTX_REQUIRE(len >= 1);
uint64_t borrow = 0;
for (int i = 0; i < len; ++i)
{
const auto s = x[i] - borrow;
const auto p = umul(y[i], multiplier);
borrow = p[1] + (x[i] < s);
r[i] = s - p[0];
borrow += (s < r[i]);
}
return borrow;
}
|
O0
|
cpp
|
intx::internal::submul(unsigned long*, unsigned long const*, unsigned long const*, int, unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
jl 0x64373
jmp 0x64392
leaq 0x7b50c(%rip), %rdi # 0xdf886
leaq 0x7b327(%rip), %rsi # 0xdf6a8
movl $0x67d, %edx # imm = 0x67D
leaq 0x7b502(%rip), %rcx # 0xdf88f
callq 0x23120
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x64465
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
callq 0x61720
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0x618e0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq -0x40(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x618e0
movq -0x58(%rbp), %rdx
subq (%rax), %rdx
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x34(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x643a1
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
|
_ZN4intx8internal6submulEPmPKmS3_im:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
cmp [rbp+var_1C], 1
jl short loc_64373
jmp short loc_64392
loc_64373:
lea rdi, aLen1; "len >= 1"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
mov edx, 67Dh
lea rcx, aUint64TIntxInt_0; "uint64_t intx::internal::submul(uint64_"...
call ___assert_fail
loc_64392:
mov [rbp+var_30], 0
mov [rbp+var_34], 0
loc_643A1:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_1C]
jge loc_64465
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_34]
mov rax, [rax+rcx*8]
sub rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
movsxd rcx, [rbp+var_34]
mov rdi, [rax+rcx*8]; this
mov rsi, [rbp+var_28]; unsigned __int64
call _ZN4intx4umulEmm; intx::umul(ulong,ulong)
mov [rbp+var_50], rax
mov [rbp+var_48], rdx
lea rdi, [rbp+var_50]
mov esi, 1
call _ZNK4intx4uintILj128EEixEm; intx::uint<128u>::operator[](ulong)
mov rax, [rax]
mov rcx, [rbp+var_10]
movsxd rdx, [rbp+var_34]
mov rcx, [rcx+rdx*8]
cmp rcx, [rbp+var_40]
setb cl
and cl, 1
movzx ecx, cl
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_40]
mov [rbp+var_58], rax
lea rdi, [rbp+var_50]
xor eax, eax
mov esi, eax
call _ZNK4intx4uintILj128EEixEm; intx::uint<128u>::operator[](ulong)
mov rdx, [rbp+var_58]
sub rdx, [rax]
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_34]
mov [rax+rcx*8], rdx
mov rax, [rbp+var_40]
mov rcx, [rbp+var_8]
movsxd rdx, [rbp+var_34]
cmp rax, [rcx+rdx*8]
setb al
and al, 1
movzx eax, al
add rax, [rbp+var_30]
mov [rbp+var_30], rax
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
jmp loc_643A1
loc_64465:
mov rax, [rbp+var_30]
add rsp, 60h
pop rbp
retn
|
long long intx::internal::submul(
intx::internal *this,
unsigned long long *a2,
const unsigned long long *a3,
const unsigned long long *a4,
unsigned long long a5)
{
long long v5; // rdx
_QWORD *v6; // rax
_QWORD *v7; // rax
unsigned long long v9; // [rsp+8h] [rbp-58h]
_QWORD v10[2]; // [rsp+10h] [rbp-50h] BYREF
unsigned long long v11; // [rsp+20h] [rbp-40h]
int i; // [rsp+2Ch] [rbp-34h]
long long v13; // [rsp+30h] [rbp-30h]
unsigned long long v14; // [rsp+38h] [rbp-28h]
int v15; // [rsp+44h] [rbp-1Ch]
const unsigned long long *v16; // [rsp+48h] [rbp-18h]
unsigned long long *v17; // [rsp+50h] [rbp-10h]
intx::internal *v18; // [rsp+58h] [rbp-8h]
v18 = this;
v17 = a2;
v16 = a3;
v15 = (int)a4;
v14 = a5;
if ( (int)a4 < 1 )
__assert_fail(
"len >= 1",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp",
1661LL,
"uint64_t intx::internal::submul(uint64_t *, const uint64_t *, const uint64_t *, int, uint64_t)");
v13 = 0LL;
for ( i = 0; i < v15; ++i )
{
v11 = v17[i] - v13;
v10[0] = intx::umul(v16[i], v14);
v10[1] = v5;
v6 = (_QWORD *)intx::uint<128u>::operator[]((long long)v10, 1LL);
v13 = (v17[i] < v11) + *v6;
v9 = v11;
v7 = (_QWORD *)intx::uint<128u>::operator[]((long long)v10, 0LL);
*((_QWORD *)v18 + i) = v9 - *v7;
v13 += v11 < *((_QWORD *)v18 + i);
}
return v13;
}
|
submul:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
CMP dword ptr [RBP + -0x1c],0x1
JL 0x00164373
JMP 0x00164392
LAB_00164373:
LEA RDI,[0x1df886]
LEA RSI,[0x1df6a8]
MOV EDX,0x67d
LEA RCX,[0x1df88f]
CALL 0x00123120
LAB_00164392:
MOV qword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x34],0x0
LAB_001643a1:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x00164465
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RAX + RCX*0x8]
SUB RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,dword ptr [RBP + -0x34]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00161720
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x48],RDX
LEA RDI,[RBP + -0x50]
MOV ESI,0x1
CALL 0x001618e0
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
MOV RCX,qword ptr [RCX + RDX*0x8]
CMP RCX,qword ptr [RBP + -0x40]
SETC CL
AND CL,0x1
MOVZX ECX,CL
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x58],RAX
LEA RDI,[RBP + -0x50]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001618e0
MOV RDX,qword ptr [RBP + -0x58]
SUB RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x34]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RDX,dword ptr [RBP + -0x34]
CMP RAX,qword ptr [RCX + RDX*0x8]
SETC AL
AND AL,0x1
MOVZX EAX,AL
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x001643a1
LAB_00164465:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x60
POP RBP
RET
|
/* intx::internal::submul(unsigned long*, unsigned long const*, unsigned long const*, int, unsigned
long) */
long intx::internal::submul(ulong *param_1,ulong *param_2,ulong *param_3,int param_4,ulong param_5)
{
ulong uVar1;
long *plVar2;
int1 auVar3 [16];
int1 local_58 [16];
ulong local_48;
int local_3c;
long local_38;
ulong local_30;
int local_24;
ulong *local_20;
ulong *local_18;
ulong *local_10;
local_30 = param_5;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if (0 < param_4) {
local_38 = 0;
for (local_3c = 0; local_3c < local_24; local_3c = local_3c + 1) {
local_48 = local_18[local_3c] - local_38;
auVar3 = umul(local_20[local_3c],local_30);
local_58 = auVar3;
plVar2 = (long *)uint<128u>::operator[]((uint<128u> *)local_58,1);
uVar1 = local_48;
local_38 = *plVar2 + (ulong)(local_18[local_3c] < local_48);
plVar2 = (long *)uint<128u>::operator[]((uint<128u> *)local_58,0);
local_10[local_3c] = uVar1 - *plVar2;
local_38 = (ulong)(local_48 < local_10[local_3c]) + local_38;
}
return local_38;
}
/* WARNING: Subroutine does not return */
__assert_fail("len >= 1",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp"
,0x67d,
"uint64_t intx::internal::submul(uint64_t *, const uint64_t *, const uint64_t *, int, uint64_t)"
);
}
|
|
64,734 |
minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const
|
monkey531[P]llama/common/minja.hpp
|
Value call(const std::shared_ptr<Context> & context, ArgumentsValue & args) const {
if (!callable_) throw std::runtime_error("Value is not callable: " + dump());
return (*callable_)(context, args);
}
|
O0
|
cpp
|
minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x30, %rdi
callq 0xa16e0
testb $0x1, %al
jne 0xdb70d
movb $0x1, 0x2b(%rsp)
movl $0x10, %edi
callq 0x50540
movq 0x20(%rsp), %rsi
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xa15d0
jmp 0xdb66b
leaq 0xde9d9(%rip), %rsi # 0x1ba04b
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x63980
jmp 0xdb683
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x50390
jmp 0xdb694
movq 0x8(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
movq 0x15b90b(%rip), %rsi # 0x236fb0
movq 0x15b8cc(%rip), %rdx # 0x236f78
callq 0x50900
jmp 0xdb74c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xdb6f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xdb6ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x510e0
leaq 0x38(%rsp), %rdi
callq 0x510e0
testb $0x1, 0x2b(%rsp)
jne 0xdb701
jmp 0xdb70b
movq 0x8(%rsp), %rdi
callq 0x50c50
jmp 0xdb742
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
callq 0xdf200
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x80(%rsp), %rdx
movq 0x78(%rsp), %rcx
callq 0xdf230
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x50950
nopl (%rax)
|
_ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE:
sub rsp, 98h
mov [rsp+98h+var_88], rdi
mov rax, rdi
mov [rsp+98h+var_80], rax
mov [rsp+98h+var_8], rdi
mov [rsp+98h+var_10], rsi
mov [rsp+98h+var_18], rdx
mov [rsp+98h+var_20], rcx
mov rdi, [rsp+98h+var_10]
mov [rsp+98h+var_78], rdi
add rdi, 30h ; '0'
call _ZNKSt12__shared_ptrISt8functionIFN5minja5ValueERKSt10shared_ptrINS1_7ContextEERNS1_14ArgumentsValueEEELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz loc_DB70D
mov [rsp+98h+var_6D], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+98h+var_78]
mov [rsp+98h+var_90], rax
lea rdi, [rsp+98h+var_60]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_DB66B:
lea rsi, aValueIsNotCall; "Value is not callable: "
lea rdi, [rsp+98h+var_40]
lea rdx, [rsp+98h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_DB683:
mov rdi, [rsp+98h+var_90]
lea rsi, [rsp+98h+var_40]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_DB694:
mov rdi, [rsp+98h+var_90]; void *
mov [rsp+98h+var_6D], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_DB74C
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_DB6F8
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_DB6EE
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_DB6EE:
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_DB6F8:
test [rsp+arg_23], 1
jnz short loc_DB701
jmp short loc_DB70B
loc_DB701:
mov rdi, [rsp+arg_0]; void *
call ___cxa_free_exception
loc_DB70B:
jmp short loc_DB742
loc_DB70D:
mov rdi, [rsp+98h+var_78]
add rdi, 30h ; '0'
call _ZNKSt19__shared_ptr_accessISt8functionIFN5minja5ValueERKSt10shared_ptrINS1_7ContextEERNS1_14ArgumentsValueEEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEdeEv; std::__shared_ptr_access<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2,false,false>::operator*(void)
mov rdi, [rsp+98h+var_88]
mov rsi, rax
mov rdx, [rsp+98h+var_18]
mov rcx, [rsp+98h+var_20]
call _ZNKSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEEclES6_S8_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::operator()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
mov rax, [rsp+98h+var_80]
add rsp, 98h
retn
loc_DB742:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
loc_DB74C:
nop dword ptr [rax+00h]
|
long long minja::Value::call(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
void *exception; // [rsp+8h] [rbp-90h]
_BYTE v7[32]; // [rsp+38h] [rbp-60h] BYREF
_BYTE v8[32]; // [rsp+58h] [rbp-40h] BYREF
long long v9; // [rsp+78h] [rbp-20h]
long long v10; // [rsp+80h] [rbp-18h]
long long v11; // [rsp+88h] [rbp-10h]
long long v12; // [rsp+90h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
if ( !std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)(a2 + 48)) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v7, a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v8, (long long)"Value is not callable: ", (long long)v7);
std::runtime_error::runtime_error(exception, v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4 = std::__shared_ptr_access<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2,false,false>::operator*(a2 + 48);
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::operator()(
a1,
v4,
v10,
v9);
return a1;
}
|
call:
SUB RSP,0x98
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x90],RDI
MOV qword ptr [RSP + 0x88],RSI
MOV qword ptr [RSP + 0x80],RDX
MOV qword ptr [RSP + 0x78],RCX
MOV RDI,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x20],RDI
ADD RDI,0x30
CALL 0x001a16e0
TEST AL,0x1
JNZ 0x001db70d
MOV byte ptr [RSP + 0x2b],0x1
MOV EDI,0x10
CALL 0x00150540
MOV RSI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
LAB_001db658:
LEA RDI,[RSP + 0x38]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001a15d0
JMP 0x001db66b
LAB_001db66b:
LEA RSI,[0x2ba04b]
LEA RDI,[RSP + 0x58]
LEA RDX,[RSP + 0x38]
CALL 0x00163980
JMP 0x001db683
LAB_001db683:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x58]
CALL 0x00150390
JMP 0x001db694
LAB_001db694:
MOV RDI,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + 0x2b],0x0
MOV RSI,qword ptr [0x00336fb0]
MOV RDX,qword ptr [0x00336f78]
CALL 0x00150900
LAB_001db70d:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x30
CALL 0x001df200
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x80]
MOV RCX,qword ptr [RSP + 0x78]
CALL 0x001df230
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x98
RET
|
/* minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const */
shared_ptr * minja::Value::call(shared_ptr *param_1,ArgumentsValue *param_2)
{
bool bVar1;
runtime_error *this;
ArgumentsValue *pAVar2;
int1 local_60 [32];
string local_40 [48];
ArgumentsValue *local_10;
shared_ptr *local_8;
local_10 = param_2;
local_8 = param_1;
bVar1 = std::__shared_ptr::operator_cast_to_bool((__shared_ptr *)(param_2 + 0x30));
if (!bVar1) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001db658 to 001db668 has its CatchHandler @ 001db6b6 */
dump_abi_cxx11_((int)local_60,SUB81(param_2,0));
/* try { // try from 001db66b to 001db680 has its CatchHandler @ 001db6c6 */
std::operator+((char *)local_40,(string *)"Value is not callable: ");
/* try { // try from 001db683 to 001db6b0 has its CatchHandler @ 001db6d6 */
std::runtime_error::runtime_error(this,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00336fb0,PTR__runtime_error_00336f78);
}
pAVar2 = (ArgumentsValue *)
std::
__shared_ptr_access<std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator*((__shared_ptr_access<std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(param_2 + 0x30));
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>::
operator()(param_1,pAVar2);
return param_1;
}
|
|
64,735 |
ImPlot3D::SetupAxis(int, char const*, int)
|
zkingston[P]unknot/build_O1/_deps/implot3d-src/implot3d.cpp
|
void SetupAxis(ImAxis3D idx, const char* label, ImPlot3DAxisFlags flags) {
ImPlot3DContext& gp = *GImPlot3D;
IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
"SetupAxis() needs to be called after BeginPlot() and before any setup locking functions (e.g. PlotX)!");
// Get plot and axis
ImPlot3DPlot& plot = *gp.CurrentPlot;
ImPlot3DAxis& axis = plot.Axes[idx];
if (axis.PreviousFlags != flags)
axis.Flags = flags;
axis.PreviousFlags = flags;
axis.SetLabel(label);
}
|
O1
|
cpp
|
ImPlot3D::SetupAxis(int, char const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movl %edi, %r14d
movq 0x2e5c39(%rip), %r15 # 0x336c98
movq 0x28(%r15), %rax
testq %rax, %rax
je 0x51071
cmpb $0x1, 0x1e8(%rax)
jne 0x5107d
leaq 0x243dfc(%rip), %rdi # 0x294e74
callq 0x2161f4
movq 0x28(%r15), %rax
movslq %r14d, %rcx
imulq $0x70, %rcx, %rcx
leaq (%rax,%rcx), %r14
addq $0x78, %r14
cmpl %ebp, 0x4(%r14)
je 0x51099
movl %ebp, (%r14)
movl %ebp, 0x4(%r14)
movl $0x0, 0x18(%r14)
testq %rbx, %rbx
je 0x510e1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x216924
cmpq %rbx, %rax
je 0x510e1
addq $0x18, %r14
movq %rbx, %rdi
callq 0xf490
leaq (%rbx,%rax), %rdx
incq %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x214c8a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
_ZN8ImPlot3D9SetupAxisEiPKci:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, edx
mov rbx, rsi
mov r14d, edi
mov r15, cs:_ZN8ImPlot3D9GImPlot3DE; ImPlot3D::GImPlot3D
mov rax, [r15+28h]
test rax, rax
jz short loc_51071
cmp byte ptr [rax+1E8h], 1
jnz short loc_5107D
loc_51071:
lea rdi, aSetupaxisNeeds; "SetupAxis() needs to be called after Be"...
call _ZN5ImGui8ErrorLogEPKc; ImGui::ErrorLog(char const*)
loc_5107D:
mov rax, [r15+28h]
movsxd rcx, r14d
imul rcx, 70h ; 'p'
lea r14, [rax+rcx]
add r14, 78h ; 'x'
cmp [r14+4], ebp
jz short loc_51099
mov [r14], ebp
loc_51099:
mov [r14+4], ebp
mov dword ptr [r14+18h], 0
test rbx, rbx
jz short loc_510E1
mov rdi, rbx; this
xor esi, esi; char *
call _ZN5ImGui19FindRenderedTextEndEPKcS1_; ImGui::FindRenderedTextEnd(char const*,char const*)
cmp rax, rbx
jz short loc_510E1
add r14, 18h
mov rdi, rbx
call _strlen
lea rdx, [rbx+rax]
inc rdx; char *
mov rdi, r14; this
mov rsi, rbx; char *
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _ZN15ImGuiTextBuffer6appendEPKcS1_; ImGuiTextBuffer::append(char const*,char const*)
loc_510E1:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long ImPlot3D::SetupAxis(ImPlot3D *this, char *a2, const char *a3)
{
int v3; // ebp
ImGui *v4; // r15
long long v5; // rax
long long result; // rax
long long v7; // rcx
_DWORD *v8; // r14
long long v9; // rax
v3 = (int)a3;
v4 = ImPlot3D::GImPlot3D;
v5 = *((_QWORD *)ImPlot3D::GImPlot3D + 5);
if ( !v5 || *(_BYTE *)(v5 + 488) == 1 )
ImGui::ErrorLog(
(ImGui *)"SetupAxis() needs to be called after BeginPlot() and before any setup locking functions (e.g. PlotX)!",
a2);
result = *((_QWORD *)v4 + 5);
v7 = 112LL * (int)this;
v8 = (_DWORD *)(result + v7 + 120);
if ( *(_DWORD *)(result + v7 + 124) != v3 )
*v8 = v3;
*(_DWORD *)(result + v7 + 124) = v3;
*(_DWORD *)(result + v7 + 144) = 0;
if ( a2 )
{
result = ImGui::FindRenderedTextEnd((ImGui *)a2, 0LL, a3);
if ( (char *)result != a2 )
{
v9 = strlen(a2);
return ImGuiTextBuffer::append((ImGuiTextBuffer *)(v8 + 6), a2, &a2[v9 + 1]);
}
}
return result;
}
|
SetupAxis:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV RBX,RSI
MOV R14D,EDI
MOV R15,qword ptr [0x00436c98]
MOV RAX,qword ptr [R15 + 0x28]
TEST RAX,RAX
JZ 0x00151071
CMP byte ptr [RAX + 0x1e8],0x1
JNZ 0x0015107d
LAB_00151071:
LEA RDI,[0x394e74]
CALL 0x003161f4
LAB_0015107d:
MOV RAX,qword ptr [R15 + 0x28]
MOVSXD RCX,R14D
IMUL RCX,RCX,0x70
LEA R14,[RAX + RCX*0x1]
ADD R14,0x78
CMP dword ptr [R14 + 0x4],EBP
JZ 0x00151099
MOV dword ptr [R14],EBP
LAB_00151099:
MOV dword ptr [R14 + 0x4],EBP
MOV dword ptr [R14 + 0x18],0x0
TEST RBX,RBX
JZ 0x001510e1
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00316924
CMP RAX,RBX
JZ 0x001510e1
ADD R14,0x18
MOV RDI,RBX
CALL 0x0010f490
LEA RDX,[RBX + RAX*0x1]
INC RDX
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00314c8a
LAB_001510e1:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* ImPlot3D::SetupAxis(int, char const*, int) */
void ImPlot3D::SetupAxis(int param_1,char *param_2,int param_3)
{
long lVar1;
char *pcVar2;
size_t sVar3;
lVar1 = GImPlot3D;
if ((*(long *)(GImPlot3D + 0x28) == 0) ||
(*(char *)(*(long *)(GImPlot3D + 0x28) + 0x1e8) == '\x01')) {
ImGui::ErrorLog(
"SetupAxis() needs to be called after BeginPlot() and before any setup locking functions (e.g. PlotX)!"
);
}
lVar1 = *(long *)(lVar1 + 0x28) + (long)param_1 * 0x70;
if (*(int *)(lVar1 + 0x7c) != param_3) {
*(int *)(lVar1 + 0x78) = param_3;
}
*(int *)(lVar1 + 0x7c) = param_3;
*(int4 *)(lVar1 + 0x90) = 0;
if (param_2 != (char *)0x0) {
pcVar2 = (char *)ImGui::FindRenderedTextEnd(param_2,(char *)0x0);
if (pcVar2 != param_2) {
sVar3 = strlen(param_2);
ImGuiTextBuffer::append((ImGuiTextBuffer *)(lVar1 + 0x90),param_2,param_2 + sVar3 + 1);
return;
}
}
return;
}
|
|
64,736 |
ma_stmt_execute_generate_bulk_request
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
unsigned char* ma_stmt_execute_generate_bulk_request(MYSQL_STMT *stmt, size_t *request_len)
{
/* execute packet has the following format:
Offset Length Description
-----------------------------------------
0 4 Statement id
4 2 Flags (cursor type):
STMT_BULK_FLAG_CLIENT_SEND_TYPES = 128
STMT_BULK_FLAG_INSERT_ID_REQUEST = 64
-----------------------------------------
if (stmt->send_types_to_server):
for (i=0; i < param_count; i++)
1st byte: parameter type
2nd byte flag:
unsigned flag (32768)
------------------------------------------
for (i=0; i < param_count; i++)
1 indicator variable
STMT_INDICATOR_NONE 0
STMT_INDICATOR_NULL 1
STMT_INDICATOR_DEFAULT 2
STMT_INDICATOR_IGNORE 3
STMT_INDICATOR_SKIP_SET 4
n data from bind buffer
*/
size_t length= 1024;
size_t free_bytes= 0;
ushort flags= 0;
uint i, j;
uchar *start= NULL, *p;
if (!MARIADB_STMT_BULK_SUPPORTED(stmt))
{
stmt_set_error(stmt, CR_FUNCTION_NOT_SUPPORTED, "IM001",
CER(CR_FUNCTION_NOT_SUPPORTED), "Bulk operation");
return NULL;
}
if (!stmt->param_count)
{
stmt_set_error(stmt, CR_BULK_WITHOUT_PARAMETERS, "IM001",
CER(CR_BULK_WITHOUT_PARAMETERS));
return NULL;
}
/* preallocate length bytes */
if (!(start= p= (uchar *)malloc(length)))
goto mem_error;
int4store(p, stmt->stmt_id);
p += STMT_ID_LENGTH;
/* todo: request to return auto generated ids */
if (stmt->send_types_to_server)
flags|= STMT_BULK_FLAG_CLIENT_SEND_TYPES;
int2store(p, flags);
p+=2;
/* When using mariadb_stmt_execute_direct stmt->paran_count is
not known, so we need to assign prebind_params, which was previously
set by mysql_stmt_attr_set
*/
if (!stmt->param_count && stmt->prebind_params)
stmt->param_count= stmt->prebind_params;
if (stmt->param_count)
{
free_bytes= length - (p - start);
/* Store type information:
2 bytes per type
*/
if (stmt->send_types_to_server)
{
if (free_bytes < stmt->param_count * 2 + 20)
{
size_t offset= p - start;
length= offset + stmt->param_count * 2 + 20;
if (!(start= (uchar *)realloc(start, length)))
goto mem_error;
p= start + offset;
}
for (i = 0; i < stmt->param_count; i++)
{
/* this differs from mysqlnd, c api supports unsigned !! */
uint buffer_type= stmt->params[i].buffer_type | (stmt->params[i].is_unsigned ? 32768 : 0);
int2store(p, buffer_type);
p+= 2;
}
}
/* calculate data size */
for (j=0; j < stmt->array_size; j++)
{
/* If callback for parameters was specified, we need to
update bind information for new row */
if (stmt->param_callback)
stmt->param_callback(stmt->user_data, stmt->params, j);
if (mysql_stmt_skip_paramset(stmt, j))
continue;
for (i=0; i < stmt->param_count; i++)
{
size_t size= 0;
my_bool has_data= TRUE;
signed char indicator= ma_get_indicator(stmt, i, j);
/* check if we need to send data */
if (indicator > 0)
has_data= FALSE;
size= 1;
/* Please note that mysql_stmt_send_long_data is not supported
current when performing bulk execute */
if (has_data)
{
switch (stmt->params[i].buffer_type) {
case MYSQL_TYPE_NULL:
has_data= FALSE;
indicator= STMT_INDICATOR_NULL;
break;
case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_BLOB:
case MYSQL_TYPE_VARCHAR:
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_JSON:
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
case MYSQL_TYPE_GEOMETRY:
case MYSQL_TYPE_NEWDATE:
case MYSQL_TYPE_ENUM:
case MYSQL_TYPE_BIT:
case MYSQL_TYPE_SET:
size+= 5; /* max 8 bytes for size */
if (!stmt->param_callback)
{
if (indicator == STMT_INDICATOR_NTS ||
(!stmt->row_size && ma_get_length(stmt,i,j) == -1))
{
size+= strlen(ma_get_buffer_offset(stmt,
stmt->params[i].buffer_type,
stmt->params[i].buffer,j));
}
else
size+= (size_t)ma_get_length(stmt, i, j);
}
else {
size+= stmt->params[i].buffer_length;
}
break;
default:
size+= mysql_ps_fetch_functions[stmt->params[i].buffer_type].pack_len;
break;
}
}
free_bytes= length - (p - start);
if (free_bytes < size + 20)
{
size_t offset= p - start;
length= MAX(2 * length, offset + size + 20);
if (!(start= (uchar *)realloc(start, length)))
goto mem_error;
p= start + offset;
}
int1store(p, indicator > 0 ? indicator : 0);
p++;
if (has_data) {
store_param(stmt, i, &p, (stmt->param_callback) ? 0 : j);
}
}
}
}
stmt->send_types_to_server= 0;
*request_len = (size_t)(p - start);
return start;
mem_error:
SET_CLIENT_STMT_ERROR(stmt, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
free(start);
*request_len= 0;
return NULL;
}
|
O3
|
c
|
ma_stmt_execute_generate_bulk_request:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x7cc66
testb $0x1, 0x370(%rax)
jne 0x7cc66
movq 0x4f0(%rax), %rax
testb $0x4, 0x70(%rax)
jne 0x7cc9f
leaq 0x3684c3(%rip), %rax # 0x3e5130
movq 0x18(%rax), %rcx
leaq 0x92987(%rip), %rdx # 0x10f5ff
leaq 0x92986(%rip), %r8 # 0x10f605
movl $0x138b, %esi # imm = 0x138B
xorl %eax, %eax
callq 0x7b8d8
xorl %edi, %edi
movq %rdi, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x64(%rdi), %r13d
testq %r13, %r13
je 0x7cd75
movq %rsi, -0x58(%rbp)
movq %rdi, -0x48(%rbp)
movl $0x400, %edi # imm = 0x400
callq 0x5faf0
testq %rax, %rax
je 0x7d029
movq %rax, %rdi
movq -0x48(%rbp), %rbx
movl 0x40(%rbx), %eax
movl %eax, (%rdi)
movb 0x68(%rbx), %cl
testb %cl, %cl
setne %dl
shlb $0x7, %dl
movq %rdi, %rax
addq $0x6, %rax
movb %dl, 0x4(%rdi)
movb $0x0, 0x5(%rdi)
movq %rax, -0x50(%rbp)
testb %cl, %cl
je 0x7cd98
leal -0x3e7(,%r13,2), %ecx
movl $0x400, %r8d # imm = 0x400
cmpl $0xfffffc04, %ecx # imm = 0xFFFFFC04
ja 0x7cd3b
leal (,%r13,2), %eax
movl %eax, %esi
addq $0x1a, %rsi
movq %rsi, %r14
callq 0x5f0f0
testq %rax, %rax
je 0x7d029
movq %rax, %rdi
addq $0x6, %rax
movq -0x48(%rbp), %rbx
movq %r14, %r8
movq 0x70(%rbx), %rcx
addq $0x65, %rcx
xorl %edx, %edx
movl -0x5(%rcx), %esi
xorl %ebx, %ebx
cmpb $0x0, (%rcx)
setne %bl
shll $0xf, %ebx
orl %esi, %ebx
movb %sil, (%rax)
movb %bh, 0x1(%rax)
addq $0x2, %rax
incq %rdx
addq $0x70, %rcx
cmpq %r13, %rdx
jb 0x7cd45
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rbx
jmp 0x7cd9e
leaq 0x3683b4(%rip), %rax # 0x3e5130
movq 0x30(%rax), %rcx
leaq 0x92878(%rip), %rdx # 0x10f5ff
movl $0x138e, %esi # imm = 0x138E
xorl %eax, %eax
callq 0x7b8d8
jmp 0x7cc8b
movl $0x400, %r8d # imm = 0x400
cmpl $0x0, 0x368(%rbx)
je 0x7d016
xorl %r12d, %r12d
movq %r8, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq 0x390(%rbx), %rax
testq %rax, %rax
je 0x7cdd6
movq 0x380(%rbx), %rdi
movq 0x70(%rbx), %rsi
movl %r12d, %edx
callq *%rax
movl 0x64(%rbx), %r13d
testl %r13d, %r13d
je 0x7cdfc
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %rdx
callq 0x7c852
cmpb $0x4, %al
je 0x7cff8
incl %r14d
cmpl %r14d, %r13d
jne 0x7cdde
testl %r13d, %r13d
je 0x7cff5
xorl %r15d, %r15d
xorl %r14d, %r14d
movq %r12, -0x30(%rbp)
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %rdx
callq 0x7c852
movl %eax, %r12d
movq %rbx, %rcx
movb $0x1, %bl
movl $0x1, %eax
testb %r12b, %r12b
jle 0x7ce3c
movl %r12d, %r13d
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %r9
jmp 0x7ceb0
movq 0x70(%rcx), %rdx
movslq 0x60(%rdx,%r15), %rcx
cmpq $0xf4, %rcx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %r9
jle 0x7ce63
leal -0xf5(%rcx), %eax
cmpl $0xa, %eax
jbe 0x7ce90
jmp 0x7ce79
leal -0xe(%rcx), %esi
cmpl $0x3, %esi
jb 0x7ce90
testl %ecx, %ecx
je 0x7ce90
movb $0x1, %bl
movb $0x1, %r13b
cmpl $0x6, %ecx
je 0x7ceb0
movl %ecx, %eax
leaq (%rax,%rax,2), %rax
leaq 0x3e17fa(%rip), %rcx # 0x45e680
movslq 0x8(%rcx,%rax,8), %rax
incq %rax
jmp 0x7ceab
movq -0x48(%rbp), %r8
cmpq $0x0, 0x390(%r8)
je 0x7cf54
movq 0x40(%rdx,%r15), %rax
addq $0x6, %rax
xorl %ebx, %ebx
movl %r12d, %r13d
movq -0x50(%rbp), %rcx
movq %rcx, %r12
subq %rdi, %r12
movq %r9, %rdx
subq %r12, %rdx
addq $0x14, %rax
cmpq %rax, %rdx
jae 0x7cef8
movq %r9, %rcx
addq %r9, %rcx
addq %r12, %rax
cmpq %rax, %rcx
movq %rax, %rsi
cmovaq %rcx, %rsi
movq %rsi, -0x40(%rbp)
callq 0x5f0f0
testq %rax, %rax
je 0x7d029
movq %rax, -0x38(%rbp)
addq %rax, %r12
movq %r12, %rcx
movzbl %r13b, %eax
testb %al, %al
movl $0x0, %edx
cmovlel %edx, %eax
movb %al, (%rcx)
incq %rcx
movq %rcx, -0x50(%rbp)
testb %bl, %bl
movq -0x48(%rbp), %rbx
movq -0x30(%rbp), %r12
jne 0x7cf3b
cmpq $0x0, 0x390(%rbx)
movl $0x0, %ecx
cmoveq %r12, %rcx
movq %rbx, %rdi
movl %r14d, %esi
leaq -0x50(%rbp), %rdx
callq 0x7c415
incq %r14
movl 0x64(%rbx), %r13d
addq $0x70, %r15
cmpq %r13, %r14
jb 0x7ce0f
jmp 0x7cff8
cmpb $-0x1, %r12b
je 0x7cf99
movq 0x370(%r8), %rsi
movq (%rdx,%r15), %rax
testq %rsi, %rsi
je 0x7cf79
testq %rax, %rax
je 0x7cfe1
imulq -0x30(%rbp), %rsi
addq %rsi, %rax
jmp 0x7cf91
testq %rax, %rax
je 0x7cfe1
movq -0x30(%rbp), %rsi
cmpq $-0x1, (%rax,%rsi,8)
je 0x7cf99
movq -0x30(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq (%rax), %rax
jmp 0x7cea7
movq 0x10(%rdx,%r15), %rdi
cmpl $0x0, 0x368(%r8)
je 0x7cfd1
movq 0x370(%r8), %rax
testq %rax, %rax
jne 0x7cfc9
leaq (%rcx,%rcx,2), %rax
leaq 0x3e16c1(%rip), %rcx # 0x45e680
movslq 0x8(%rcx,%rax,8), %rax
testq %rax, %rax
jle 0x7cfeb
imulq -0x30(%rbp), %rax
addq %rax, %rdi
callq 0x5f480
addq $0x6, %rax
xorl %ebx, %ebx
jmp 0x7ce2f
movl $0x6, %eax
jmp 0x7ceab
movq -0x30(%rbp), %rax
movq (%rdi,%rax,8), %rdi
jmp 0x7cfd1
xorl %r13d, %r13d
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %r8
incq %r12
movl 0x368(%rbx), %eax
cmpq %rax, %r12
jb 0x7cdae
movq -0x50(%rbp), %rax
movb $0x0, 0x68(%rbx)
subq %rdi, %rax
movq -0x58(%rbp), %rcx
movq %rax, (%rcx)
jmp 0x7cc8d
movq -0x48(%rbp), %rbx
movl $0x7d8, 0x108(%rbx) # imm = 0x7D8
leaq 0x30d(%rbx), %rdi
leaq 0x367edb(%rip), %rax # 0x3e4f20
movq (%rax), %rsi
movl $0x5, %edx
callq 0x5f180
xorl %eax, %eax
movb %al, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x367ec8(%rip), %rax # 0x3e4f30
movq 0x40(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x5f180
xorl %edi, %edi
movb %dil, 0x30b(%rbx)
movq -0x58(%rbp), %rax
movq $0x0, (%rax)
jmp 0x7cc8d
|
ma_stmt_execute_generate_bulk_request:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rax, [rdi+38h]
test rax, rax
jz short loc_7CC66
test byte ptr [rax+370h], 1
jnz short loc_7CC66
mov rax, [rax+4F0h]
test byte ptr [rax+70h], 4
jnz short loc_7CC9F
loc_7CC66:
lea rax, mariadb_client_errors
mov rcx, [rax+18h]
lea rdx, aIm001; "IM001"
lea r8, aBulkOperation; "Bulk operation"
mov esi, 138Bh
xor eax, eax
call stmt_set_error
loc_7CC8B:
xor edi, edi
loc_7CC8D:
mov rax, rdi
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7CC9F:
mov r13d, [rdi+64h]
test r13, r13
jz loc_7CD75
mov [rbp+var_58], rsi
mov [rbp+var_48], rdi
mov edi, 400h
call _malloc
test rax, rax
jz loc_7D029
mov rdi, rax
mov rbx, [rbp+var_48]
mov eax, [rbx+40h]
mov [rdi], eax
mov cl, [rbx+68h]
test cl, cl
setnz dl
shl dl, 7
mov rax, rdi
add rax, 6
mov [rdi+4], dl
mov byte ptr [rdi+5], 0
mov [rbp+var_50], rax
test cl, cl
jz loc_7CD98
lea ecx, ds:0FFFFFFFFFFFFFC19h[r13*2]
mov r8d, 400h
cmp ecx, 0FFFFFC04h
ja short loc_7CD3B
lea eax, ds:0[r13*2]
mov esi, eax
add rsi, 1Ah
mov r14, rsi
call _realloc
test rax, rax
jz loc_7D029
mov rdi, rax
add rax, 6
mov rbx, [rbp+var_48]
mov r8, r14
loc_7CD3B:
mov rcx, [rbx+70h]
add rcx, 65h ; 'e'
xor edx, edx
loc_7CD45:
mov esi, [rcx-5]
xor ebx, ebx
cmp byte ptr [rcx], 0
setnz bl
shl ebx, 0Fh
or ebx, esi
mov [rax], sil
mov [rax+1], bh
add rax, 2
inc rdx
add rcx, 70h ; 'p'
cmp rdx, r13
jb short loc_7CD45
mov [rbp+var_50], rax
mov rbx, [rbp+var_48]
jmp short loc_7CD9E
loc_7CD75:
lea rax, mariadb_client_errors
mov rcx, [rax+30h]
lea rdx, aIm001; "IM001"
mov esi, 138Eh
xor eax, eax
call stmt_set_error
jmp loc_7CC8B
loc_7CD98:
mov r8d, 400h
loc_7CD9E:
cmp dword ptr [rbx+368h], 0
jz loc_7D016
xor r12d, r12d
loc_7CDAE:
mov [rbp+var_40], r8
mov [rbp+var_38], rdi
mov rax, [rbx+390h]
test rax, rax
jz short loc_7CDD6
mov rdi, [rbx+380h]
mov rsi, [rbx+70h]
mov edx, r12d
call rax
mov r13d, [rbx+64h]
loc_7CDD6:
test r13d, r13d
jz short loc_7CDFC
xor r14d, r14d
loc_7CDDE:
mov rdi, rbx
mov esi, r14d
mov rdx, r12
call ma_get_indicator
cmp al, 4
jz loc_7CFF8
inc r14d
cmp r13d, r14d
jnz short loc_7CDDE
loc_7CDFC:
test r13d, r13d
jz loc_7CFF5
xor r15d, r15d
xor r14d, r14d
mov [rbp+var_30], r12
loc_7CE0F:
mov rdi, rbx
mov esi, r14d
mov rdx, r12
call ma_get_indicator
mov r12d, eax
mov rcx, rbx
mov bl, 1
mov eax, 1
test r12b, r12b
jle short loc_7CE3C
loc_7CE2F:
mov r13d, r12d
mov rdi, [rbp+var_38]
mov r9, [rbp+var_40]
jmp short loc_7CEB0
loc_7CE3C:
mov rdx, [rcx+70h]
movsxd rcx, dword ptr [rdx+r15+60h]
cmp rcx, 0F4h
mov rdi, [rbp+var_38]
mov r9, [rbp+var_40]
jle short loc_7CE63
lea eax, [rcx-0F5h]
cmp eax, 0Ah
jbe short loc_7CE90
jmp short loc_7CE79
loc_7CE63:
lea esi, [rcx-0Eh]
cmp esi, 3
jb short loc_7CE90
test ecx, ecx
jz short loc_7CE90
mov bl, 1
mov r13b, 1
cmp ecx, 6
jz short loc_7CEB0
loc_7CE79:
mov eax, ecx
lea rax, [rax+rax*2]
lea rcx, mysql_ps_fetch_functions
movsxd rax, dword ptr [rcx+rax*8+8]
inc rax
jmp short loc_7CEAB
loc_7CE90:
mov r8, [rbp+var_48]
cmp qword ptr [r8+390h], 0
jz loc_7CF54
mov rax, [rdx+r15+40h]
loc_7CEA7:
add rax, 6
loc_7CEAB:
xor ebx, ebx
mov r13d, r12d
loc_7CEB0:
mov rcx, [rbp+var_50]
mov r12, rcx
sub r12, rdi
mov rdx, r9
sub rdx, r12
add rax, 14h
cmp rdx, rax
jnb short loc_7CEF8
mov rcx, r9
add rcx, r9
add rax, r12
cmp rcx, rax
mov rsi, rax
cmova rsi, rcx
mov [rbp+var_40], rsi
call _realloc
test rax, rax
jz loc_7D029
mov [rbp+var_38], rax
add r12, rax
mov rcx, r12
loc_7CEF8:
movzx eax, r13b
test al, al
mov edx, 0
cmovle eax, edx
mov [rcx], al
inc rcx
mov [rbp+var_50], rcx
test bl, bl
mov rbx, [rbp+var_48]
mov r12, [rbp+var_30]
jnz short loc_7CF3B
cmp qword ptr [rbx+390h], 0
mov ecx, 0
cmovz rcx, r12
mov rdi, rbx
mov esi, r14d
lea rdx, [rbp+var_50]
call store_param
loc_7CF3B:
inc r14
mov r13d, [rbx+64h]
add r15, 70h ; 'p'
cmp r14, r13
jb loc_7CE0F
jmp loc_7CFF8
loc_7CF54:
cmp r12b, 0FFh
jz short loc_7CF99
mov rsi, [r8+370h]
mov rax, [rdx+r15]
test rsi, rsi
jz short loc_7CF79
test rax, rax
jz short loc_7CFE1
imul rsi, [rbp+var_30]
add rax, rsi
jmp short loc_7CF91
loc_7CF79:
test rax, rax
jz short loc_7CFE1
mov rsi, [rbp+var_30]
cmp qword ptr [rax+rsi*8], 0FFFFFFFFFFFFFFFFh
jz short loc_7CF99
mov rcx, [rbp+var_30]
lea rax, [rax+rcx*8]
loc_7CF91:
mov rax, [rax]
jmp loc_7CEA7
loc_7CF99:
mov rdi, [rdx+r15+10h]
cmp dword ptr [r8+368h], 0
jz short loc_7CFD1
mov rax, [r8+370h]
test rax, rax
jnz short loc_7CFC9
lea rax, [rcx+rcx*2]
lea rcx, mysql_ps_fetch_functions
movsxd rax, dword ptr [rcx+rax*8+8]
test rax, rax
jle short loc_7CFEB
loc_7CFC9:
imul rax, [rbp+var_30]
add rdi, rax
loc_7CFD1:
call _strlen
add rax, 6
xor ebx, ebx
jmp loc_7CE2F
loc_7CFE1:
mov eax, 6
jmp loc_7CEAB
loc_7CFEB:
mov rax, [rbp+var_30]
mov rdi, [rdi+rax*8]
jmp short loc_7CFD1
loc_7CFF5:
xor r13d, r13d
loc_7CFF8:
mov rdi, [rbp+var_38]
mov r8, [rbp+var_40]
inc r12
mov eax, [rbx+368h]
cmp r12, rax
jb loc_7CDAE
mov rax, [rbp+var_50]
loc_7D016:
mov byte ptr [rbx+68h], 0
sub rax, rdi
mov rcx, [rbp+var_58]
mov [rcx], rax
jmp loc_7CC8D
loc_7D029:
mov rbx, [rbp+var_48]
mov dword ptr [rbx+108h], 7D8h
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor eax, eax
mov [rbx+312h], al
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 200h
call _strncpy
xor edi, edi
mov [rbx+30Bh], dil
mov rax, [rbp+var_58]
mov qword ptr [rax], 0
jmp loc_7CC8D
|
long long ma_stmt_execute_generate_bulk_request(long long a1, _QWORD *a2)
{
long long v2; // rax
long long v3; // rdi
unsigned long long v5; // r13
_DWORD *v6; // rax
char *v7; // rcx
long long v8; // rbx
char *v9; // rax
long long v10; // r8
long long v11; // rax
unsigned long long v12; // rdx
int v13; // esi
__int16 v14; // bx
unsigned long long v15; // r12
void ( *v16)(_QWORD, _QWORD, _QWORD, char *); // rax
unsigned int v17; // r14d
long long v18; // r15
unsigned long long v19; // r14
char indicator; // r12
long long v21; // rcx
char v22; // bl
long long v23; // rax
char v24; // r13
long long v25; // rdi
long long v26; // r9
long long v27; // rdx
long long v28; // rcx
long long v29; // rax
char *v30; // rcx
char *v31; // r12
unsigned long long v32; // rax
long long v33; // rsi
long long v34; // rax
char v35; // al
bool v36; // zf
long long v37; // rcx
long long v38; // rsi
long long v39; // rax
long long *v40; // rax
long long v41; // rdi
long long v42; // rax
long long v43; // rbx
char *v45; // [rsp+10h] [rbp-50h] BYREF
long long v46; // [rsp+18h] [rbp-48h]
long long v47; // [rsp+20h] [rbp-40h]
long long v48; // [rsp+28h] [rbp-38h]
unsigned long long v49; // [rsp+30h] [rbp-30h]
v2 = *(_QWORD *)(a1 + 56);
if ( !v2 || (*(_BYTE *)(v2 + 880) & 1) != 0 || (*(_BYTE *)(*(_QWORD *)(v2 + 1264) + 112LL) & 4) == 0 )
{
stmt_set_error(a1, 5003, (long long)"IM001", mariadb_client_errors[3], "Bulk operation");
return 0LL;
}
v5 = *(unsigned int *)(a1 + 100);
if ( !*(_DWORD *)(a1 + 100) )
{
stmt_set_error(a1, 5006, (long long)"IM001", mariadb_client_errors[6]);
return 0LL;
}
v46 = a1;
v6 = (_DWORD *)malloc(1024LL);
if ( !v6 )
goto LABEL_73;
v3 = (long long)v6;
v8 = v46;
*v6 = *(_DWORD *)(v46 + 64);
LOBYTE(v7) = *(_BYTE *)(v8 + 104);
v9 = (char *)v6 + 6;
*(_BYTE *)(v3 + 4) = ((_BYTE)v7 != 0) << 7;
*(_BYTE *)(v3 + 5) = 0;
v45 = v9;
if ( (_BYTE)v7 )
{
v10 = 1024LL;
if ( (unsigned int)(2 * v5 - 999) > 0xFFFFFC04 )
goto LABEL_13;
v11 = realloc(v3, (unsigned int)(2 * v5) + 26LL);
if ( v11 )
{
v3 = v11;
v9 = (char *)(v11 + 6);
v8 = v46;
v10 = (unsigned int)(2 * v5) + 26LL;
LABEL_13:
v7 = (char *)(*(_QWORD *)(v8 + 112) + 101LL);
v12 = 0LL;
do
{
v13 = *(_DWORD *)(v7 - 5);
v14 = v13 | ((*v7 != 0) << 15);
*v9 = v13;
v9[1] = HIBYTE(v14);
v9 += 2;
++v12;
v7 += 112;
}
while ( v12 < v5 );
v45 = v9;
v8 = v46;
goto LABEL_18;
}
LABEL_73:
v43 = v46;
*(_DWORD *)(v46 + 264) = 2008;
strncpy(v43 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v43 + 786) = 0;
strncpy(v43 + 268, client_errors[8], 512LL);
v3 = 0LL;
*(_BYTE *)(v43 + 779) = 0;
*a2 = 0LL;
return v3;
}
v10 = 1024LL;
LABEL_18:
if ( !*(_DWORD *)(v8 + 872) )
goto LABEL_72;
v15 = 0LL;
do
{
v47 = v10;
v48 = v3;
v16 = *(void ( **)(_QWORD, _QWORD, _QWORD, char *))(v8 + 912);
if ( v16 )
{
v16(*(_QWORD *)(v8 + 896), *(_QWORD *)(v8 + 112), (unsigned int)v15, v7);
LODWORD(v5) = *(_DWORD *)(v8 + 100);
}
if ( !(_DWORD)v5 )
{
LABEL_26:
if ( !(_DWORD)v5 )
{
LODWORD(v5) = 0;
goto LABEL_70;
}
v18 = 0LL;
v19 = 0LL;
v49 = v15;
while ( 1 )
{
indicator = ma_get_indicator(v8, v19, v15);
v21 = v8;
v22 = 1;
v23 = 1LL;
if ( indicator > 0 )
goto LABEL_29;
v27 = *(_QWORD *)(v21 + 112);
v28 = *(int *)(v27 + v18 + 96);
v25 = v48;
v26 = v47;
if ( v28 <= 244 )
{
if ( (unsigned int)(v28 - 14) >= 3 && (_DWORD)v28 )
{
v22 = 1;
v24 = 1;
if ( (_DWORD)v28 == 6 )
goto LABEL_41;
LABEL_36:
v23 = mysql_ps_fetch_functions[6 * (unsigned int)v28 + 2] + 1LL;
goto LABEL_40;
}
}
else if ( (unsigned int)(v28 - 245) > 0xA )
{
goto LABEL_36;
}
if ( *(_QWORD *)(v46 + 912) )
{
v29 = *(_QWORD *)(v27 + v18 + 64);
}
else
{
if ( indicator == -1 )
goto LABEL_62;
v38 = *(_QWORD *)(v46 + 880);
v39 = *(_QWORD *)(v27 + v18);
if ( v38 )
{
if ( !v39 )
goto LABEL_67;
v40 = (long long *)(v49 * v38 + v39);
}
else
{
if ( !v39 )
{
LABEL_67:
v23 = 6LL;
goto LABEL_40;
}
if ( *(_QWORD *)(v39 + 8 * v49) == -1LL )
{
LABEL_62:
v41 = *(_QWORD *)(v27 + v18 + 16);
if ( *(_DWORD *)(v46 + 872) )
{
v42 = *(_QWORD *)(v46 + 880);
if ( v42 || (v42 = mysql_ps_fetch_functions[6 * v28 + 2], v42 > 0) )
v41 += v49 * v42;
else
v41 = *(_QWORD *)(v41 + 8 * v49);
}
v23 = strlen(v41) + 6;
v22 = 0;
LABEL_29:
v24 = indicator;
v25 = v48;
v26 = v47;
goto LABEL_41;
}
v40 = (long long *)(v39 + 8 * v49);
}
v29 = *v40;
}
v23 = v29 + 6;
LABEL_40:
v22 = 0;
v24 = indicator;
LABEL_41:
v30 = v45;
v31 = &v45[-v25];
v32 = v23 + 20;
if ( v26 - (long long)&v45[-v25] < v32 )
{
v33 = (long long)&v31[v32];
if ( 2 * v26 > (unsigned long long)&v31[v32] )
v33 = 2 * v26;
v47 = v33;
v34 = realloc(v25, v33);
if ( !v34 )
goto LABEL_73;
v48 = v34;
v30 = &v31[v34];
}
v35 = v24;
if ( v24 <= 0 )
v35 = 0;
*v30 = v35;
v7 = v30 + 1;
v45 = v7;
v36 = v22 == 0;
v8 = v46;
v15 = v49;
if ( v36 )
{
v37 = 0LL;
if ( !*(_QWORD *)(v46 + 912) )
v37 = v49;
store_param(v46, v19, &v45, v37);
}
++v19;
v5 = *(unsigned int *)(v8 + 100);
v18 += 112LL;
if ( v19 >= v5 )
goto LABEL_70;
}
}
v17 = 0;
while ( ma_get_indicator(v8, v17, v15) != 4 )
{
if ( (_DWORD)v5 == ++v17 )
goto LABEL_26;
}
LABEL_70:
v3 = v48;
v10 = v47;
++v15;
}
while ( v15 < *(unsigned int *)(v8 + 872) );
v9 = v45;
LABEL_72:
*(_BYTE *)(v8 + 104) = 0;
*a2 = &v9[-v3];
return v3;
}
|
ma_stmt_execute_generate_bulk_request:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr [RDI + 0x38]
TEST RAX,RAX
JZ 0x0017cc66
TEST byte ptr [RAX + 0x370],0x1
JNZ 0x0017cc66
MOV RAX,qword ptr [RAX + 0x4f0]
TEST byte ptr [RAX + 0x70],0x4
JNZ 0x0017cc9f
LAB_0017cc66:
LEA RAX,[0x4e5130]
MOV RCX,qword ptr [RAX + 0x18]
LEA RDX,[0x20f5ff]
LEA R8,[0x20f605]
MOV ESI,0x138b
XOR EAX,EAX
CALL 0x0017b8d8
LAB_0017cc8b:
XOR EDI,EDI
LAB_0017cc8d:
MOV RAX,RDI
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017cc9f:
MOV R13D,dword ptr [RDI + 0x64]
TEST R13,R13
JZ 0x0017cd75
MOV qword ptr [RBP + -0x58],RSI
MOV qword ptr [RBP + -0x48],RDI
MOV EDI,0x400
CALL 0x0015faf0
TEST RAX,RAX
JZ 0x0017d029
MOV RDI,RAX
MOV RBX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RBX + 0x40]
MOV dword ptr [RDI],EAX
MOV CL,byte ptr [RBX + 0x68]
TEST CL,CL
SETNZ DL
SHL DL,0x7
MOV RAX,RDI
ADD RAX,0x6
MOV byte ptr [RDI + 0x4],DL
MOV byte ptr [RDI + 0x5],0x0
MOV qword ptr [RBP + -0x50],RAX
TEST CL,CL
JZ 0x0017cd98
LEA ECX,[-0x3e7 + R13*0x2]
MOV R8D,0x400
CMP ECX,0xfffffc04
JA 0x0017cd3b
LEA EAX,[R13*0x2]
MOV ESI,EAX
ADD RSI,0x1a
MOV R14,RSI
CALL 0x0015f0f0
TEST RAX,RAX
JZ 0x0017d029
MOV RDI,RAX
ADD RAX,0x6
MOV RBX,qword ptr [RBP + -0x48]
MOV R8,R14
LAB_0017cd3b:
MOV RCX,qword ptr [RBX + 0x70]
ADD RCX,0x65
XOR EDX,EDX
LAB_0017cd45:
MOV ESI,dword ptr [RCX + -0x5]
XOR EBX,EBX
CMP byte ptr [RCX],0x0
SETNZ BL
SHL EBX,0xf
OR EBX,ESI
MOV byte ptr [RAX],SIL
MOV byte ptr [RAX + 0x1],BH
ADD RAX,0x2
INC RDX
ADD RCX,0x70
CMP RDX,R13
JC 0x0017cd45
MOV qword ptr [RBP + -0x50],RAX
MOV RBX,qword ptr [RBP + -0x48]
JMP 0x0017cd9e
LAB_0017cd75:
LEA RAX,[0x4e5130]
MOV RCX,qword ptr [RAX + 0x30]
LEA RDX,[0x20f5ff]
MOV ESI,0x138e
XOR EAX,EAX
CALL 0x0017b8d8
JMP 0x0017cc8b
LAB_0017cd98:
MOV R8D,0x400
LAB_0017cd9e:
CMP dword ptr [RBX + 0x368],0x0
JZ 0x0017d016
XOR R12D,R12D
LAB_0017cdae:
MOV qword ptr [RBP + -0x40],R8
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr [RBX + 0x390]
TEST RAX,RAX
JZ 0x0017cdd6
MOV RDI,qword ptr [RBX + 0x380]
MOV RSI,qword ptr [RBX + 0x70]
MOV EDX,R12D
CALL RAX
MOV R13D,dword ptr [RBX + 0x64]
LAB_0017cdd6:
TEST R13D,R13D
JZ 0x0017cdfc
XOR R14D,R14D
LAB_0017cdde:
MOV RDI,RBX
MOV ESI,R14D
MOV RDX,R12
CALL 0x0017c852
CMP AL,0x4
JZ 0x0017cff8
INC R14D
CMP R13D,R14D
JNZ 0x0017cdde
LAB_0017cdfc:
TEST R13D,R13D
JZ 0x0017cff5
XOR R15D,R15D
XOR R14D,R14D
MOV qword ptr [RBP + -0x30],R12
LAB_0017ce0f:
MOV RDI,RBX
MOV ESI,R14D
MOV RDX,R12
CALL 0x0017c852
MOV R12D,EAX
MOV RCX,RBX
MOV BL,0x1
MOV EAX,0x1
TEST R12B,R12B
JLE 0x0017ce3c
LAB_0017ce2f:
MOV R13D,R12D
MOV RDI,qword ptr [RBP + -0x38]
MOV R9,qword ptr [RBP + -0x40]
JMP 0x0017ceb0
LAB_0017ce3c:
MOV RDX,qword ptr [RCX + 0x70]
MOVSXD RCX,dword ptr [RDX + R15*0x1 + 0x60]
CMP RCX,0xf4
MOV RDI,qword ptr [RBP + -0x38]
MOV R9,qword ptr [RBP + -0x40]
JLE 0x0017ce63
LEA EAX,[RCX + -0xf5]
CMP EAX,0xa
JBE 0x0017ce90
JMP 0x0017ce79
LAB_0017ce63:
LEA ESI,[RCX + -0xe]
CMP ESI,0x3
JC 0x0017ce90
TEST ECX,ECX
JZ 0x0017ce90
MOV BL,0x1
MOV R13B,0x1
CMP ECX,0x6
JZ 0x0017ceb0
LAB_0017ce79:
MOV EAX,ECX
LEA RAX,[RAX + RAX*0x2]
LEA RCX,[0x55e680]
MOVSXD RAX,dword ptr [RCX + RAX*0x8 + 0x8]
INC RAX
JMP 0x0017ceab
LAB_0017ce90:
MOV R8,qword ptr [RBP + -0x48]
CMP qword ptr [R8 + 0x390],0x0
JZ 0x0017cf54
MOV RAX,qword ptr [RDX + R15*0x1 + 0x40]
LAB_0017cea7:
ADD RAX,0x6
LAB_0017ceab:
XOR EBX,EBX
MOV R13D,R12D
LAB_0017ceb0:
MOV RCX,qword ptr [RBP + -0x50]
MOV R12,RCX
SUB R12,RDI
MOV RDX,R9
SUB RDX,R12
ADD RAX,0x14
CMP RDX,RAX
JNC 0x0017cef8
MOV RCX,R9
ADD RCX,R9
ADD RAX,R12
CMP RCX,RAX
MOV RSI,RAX
CMOVA RSI,RCX
MOV qword ptr [RBP + -0x40],RSI
CALL 0x0015f0f0
TEST RAX,RAX
JZ 0x0017d029
MOV qword ptr [RBP + -0x38],RAX
ADD R12,RAX
MOV RCX,R12
LAB_0017cef8:
MOVZX EAX,R13B
TEST AL,AL
MOV EDX,0x0
CMOVLE EAX,EDX
MOV byte ptr [RCX],AL
INC RCX
MOV qword ptr [RBP + -0x50],RCX
TEST BL,BL
MOV RBX,qword ptr [RBP + -0x48]
MOV R12,qword ptr [RBP + -0x30]
JNZ 0x0017cf3b
CMP qword ptr [RBX + 0x390],0x0
MOV ECX,0x0
CMOVZ RCX,R12
MOV RDI,RBX
MOV ESI,R14D
LEA RDX,[RBP + -0x50]
CALL 0x0017c415
LAB_0017cf3b:
INC R14
MOV R13D,dword ptr [RBX + 0x64]
ADD R15,0x70
CMP R14,R13
JC 0x0017ce0f
JMP 0x0017cff8
LAB_0017cf54:
CMP R12B,0xff
JZ 0x0017cf99
MOV RSI,qword ptr [R8 + 0x370]
MOV RAX,qword ptr [RDX + R15*0x1]
TEST RSI,RSI
JZ 0x0017cf79
TEST RAX,RAX
JZ 0x0017cfe1
IMUL RSI,qword ptr [RBP + -0x30]
ADD RAX,RSI
JMP 0x0017cf91
LAB_0017cf79:
TEST RAX,RAX
JZ 0x0017cfe1
MOV RSI,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + RSI*0x8],-0x1
JZ 0x0017cf99
MOV RCX,qword ptr [RBP + -0x30]
LEA RAX,[RAX + RCX*0x8]
LAB_0017cf91:
MOV RAX,qword ptr [RAX]
JMP 0x0017cea7
LAB_0017cf99:
MOV RDI,qword ptr [RDX + R15*0x1 + 0x10]
CMP dword ptr [R8 + 0x368],0x0
JZ 0x0017cfd1
MOV RAX,qword ptr [R8 + 0x370]
TEST RAX,RAX
JNZ 0x0017cfc9
LEA RAX,[RCX + RCX*0x2]
LEA RCX,[0x55e680]
MOVSXD RAX,dword ptr [RCX + RAX*0x8 + 0x8]
TEST RAX,RAX
JLE 0x0017cfeb
LAB_0017cfc9:
IMUL RAX,qword ptr [RBP + -0x30]
ADD RDI,RAX
LAB_0017cfd1:
CALL 0x0015f480
ADD RAX,0x6
XOR EBX,EBX
JMP 0x0017ce2f
LAB_0017cfe1:
MOV EAX,0x6
JMP 0x0017ceab
LAB_0017cfeb:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RDI + RAX*0x8]
JMP 0x0017cfd1
LAB_0017cff5:
XOR R13D,R13D
LAB_0017cff8:
MOV RDI,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x40]
INC R12
MOV EAX,dword ptr [RBX + 0x368]
CMP R12,RAX
JC 0x0017cdae
MOV RAX,qword ptr [RBP + -0x50]
LAB_0017d016:
MOV byte ptr [RBX + 0x68],0x0
SUB RAX,RDI
MOV RCX,qword ptr [RBP + -0x58]
MOV qword ptr [RCX],RAX
JMP 0x0017cc8d
LAB_0017d029:
MOV RBX,qword ptr [RBP + -0x48]
MOV dword ptr [RBX + 0x108],0x7d8
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x4e4f20]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x0015f180
XOR EAX,EAX
MOV byte ptr [RBX + 0x312],AL
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x4e4f30]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x200
CALL 0x0015f180
XOR EDI,EDI
MOV byte ptr [RBX + 0x30b],DIL
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX],0x0
JMP 0x0017cc8d
|
int4 * ma_stmt_execute_generate_bulk_request(long param_1,long *param_2)
{
uint uVar1;
int4 uVar2;
bool bVar3;
char cVar4;
char cVar5;
int4 *puVar6;
long lVar7;
char *pcVar8;
ulong uVar9;
ulong uVar10;
size_t sVar11;
long lVar12;
int iVar13;
int iVar14;
ulong uVar15;
long lVar16;
char *local_58;
long local_50;
size_t local_48;
int4 *local_40;
ulong local_38;
lVar12 = *(long *)(param_1 + 0x38);
if (((lVar12 == 0) || ((*(byte *)(lVar12 + 0x370) & 1) != 0)) ||
((*(byte *)(*(long *)(lVar12 + 0x4f0) + 0x70) & 4) == 0)) {
stmt_set_error(param_1,0x138b,"IM001",mariadb_client_errors._24_8_,"Bulk operation");
}
else {
uVar1 = *(uint *)(param_1 + 100);
uVar9 = (ulong)uVar1;
if (uVar9 != 0) {
local_50 = param_1;
puVar6 = (int4 *)malloc(0x400);
if (puVar6 != (int4 *)0x0) {
*puVar6 = *(int4 *)(local_50 + 0x40);
cVar4 = *(char *)(local_50 + 0x68);
local_58 = (char *)((long)puVar6 + 6);
*(char *)(puVar6 + 1) = (cVar4 != '\0') << 7;
*(int1 *)((long)puVar6 + 5) = 0;
if (cVar4 == '\0') {
local_40 = puVar6;
local_48 = 0x400;
}
else {
sVar11 = 0x400;
if (uVar1 * 2 - 999 < 0xfffffc05) {
sVar11 = (ulong)(uVar1 * 2) + 0x1a;
puVar6 = (int4 *)realloc(puVar6,sVar11);
if (puVar6 == (int4 *)0x0) goto LAB_0017d029;
local_58 = (char *)((long)puVar6 + 6);
}
pcVar8 = (char *)(*(long *)(local_50 + 0x70) + 0x65);
uVar10 = 0;
do {
uVar2 = *(int4 *)(pcVar8 + -5);
cVar4 = *pcVar8;
*local_58 = (char)uVar2;
local_58[1] = (byte)(((uint)(cVar4 != '\0') << 0xf) >> 8) | (byte)((uint)uVar2 >> 8);
local_58 = local_58 + 2;
uVar10 = uVar10 + 1;
pcVar8 = pcVar8 + 0x70;
local_40 = puVar6;
local_48 = sVar11;
} while (uVar10 < uVar9);
}
lVar12 = local_50;
if (*(int *)(local_50 + 0x368) != 0) {
uVar10 = 0;
do {
if (*(code **)(lVar12 + 0x390) != (code *)0x0) {
(**(code **)(lVar12 + 0x390))
(*(int8 *)(lVar12 + 0x380),*(int8 *)(lVar12 + 0x70),
uVar10 & 0xffffffff);
uVar9 = (ulong)*(uint *)(lVar12 + 100);
}
iVar13 = (int)uVar9;
if (iVar13 != 0) {
iVar14 = 0;
do {
cVar4 = ma_get_indicator(lVar12,iVar14,uVar10);
if (cVar4 == '\x04') goto LAB_0017cff8;
iVar14 = iVar14 + 1;
} while (iVar13 != iVar14);
}
if (iVar13 == 0) {
uVar9 = 0;
}
else {
lVar16 = 0;
uVar15 = 0;
local_38 = uVar10;
do {
cVar5 = ma_get_indicator(lVar12,uVar15 & 0xffffffff,uVar10);
bVar3 = true;
lVar7 = 1;
cVar4 = cVar5;
if (cVar5 < '\x01') {
lVar12 = *(long *)(lVar12 + 0x70);
uVar1 = *(uint *)(lVar12 + 0x60 + lVar16);
if ((long)(int)uVar1 < 0xf5) {
if ((uVar1 - 0xe < 3) || (uVar1 == 0)) goto LAB_0017ce90;
bVar3 = true;
cVar4 = '\x01';
if (uVar1 != 6) goto LAB_0017ce79;
}
else {
if (uVar1 - 0xf5 < 0xb) {
LAB_0017ce90:
if (*(long *)(local_50 + 0x390) == 0) {
if (cVar5 == -1) {
LAB_0017cf99:
pcVar8 = *(char **)(lVar12 + 0x10 + lVar16);
if (*(int *)(local_50 + 0x368) != 0) {
lVar12 = *(long *)(local_50 + 0x370);
if ((lVar12 == 0) &&
(lVar12 = (long)(int)(&DAT_0055e688)[(long)(int)uVar1 * 6],
lVar12 < 1)) {
pcVar8 = *(char **)(pcVar8 + local_38 * 8);
}
else {
pcVar8 = pcVar8 + lVar12 * local_38;
}
}
sVar11 = strlen(pcVar8);
lVar7 = sVar11 + 6;
bVar3 = false;
goto LAB_0017ceb0;
}
lVar7 = *(long *)(lVar12 + lVar16);
if (*(long *)(local_50 + 0x370) == 0) {
if (lVar7 == 0) goto LAB_0017cfe1;
if (*(long *)(lVar7 + local_38 * 8) == -1) goto LAB_0017cf99;
lVar12 = local_38 * 8;
}
else {
if (lVar7 == 0) {
LAB_0017cfe1:
lVar7 = 6;
goto LAB_0017ceab;
}
lVar12 = *(long *)(local_50 + 0x370) * local_38;
}
lVar7 = *(long *)(lVar7 + lVar12);
}
else {
lVar7 = *(long *)(lVar12 + 0x40 + lVar16);
}
lVar7 = lVar7 + 6;
}
else {
LAB_0017ce79:
lVar7 = (long)(int)(&DAT_0055e688)[(ulong)uVar1 * 6] + 1;
}
LAB_0017ceab:
bVar3 = false;
cVar4 = cVar5;
}
}
LAB_0017ceb0:
lVar12 = (long)local_58 - (long)local_40;
if (local_48 - lVar12 < lVar7 + 0x14U) {
uVar9 = local_48 * 2;
local_48 = lVar7 + 0x14U + lVar12;
if (local_48 < uVar9) {
local_48 = uVar9;
}
puVar6 = (int4 *)realloc(local_40,local_48);
if (puVar6 == (int4 *)0x0) goto LAB_0017d029;
local_58 = (char *)(lVar12 + (long)puVar6);
local_40 = puVar6;
}
uVar10 = local_38;
lVar12 = local_50;
if (cVar4 < '\x01') {
cVar4 = '\0';
}
*local_58 = cVar4;
local_58 = local_58 + 1;
if (!bVar3) {
uVar9 = 0;
if (*(long *)(local_50 + 0x390) == 0) {
uVar9 = local_38;
}
store_param(local_50,uVar15 & 0xffffffff,&local_58,uVar9);
}
uVar15 = uVar15 + 1;
uVar9 = (ulong)*(uint *)(lVar12 + 100);
lVar16 = lVar16 + 0x70;
} while (uVar15 < uVar9);
}
LAB_0017cff8:
uVar10 = uVar10 + 1;
} while (uVar10 < *(uint *)(lVar12 + 0x368));
}
*(int1 *)(lVar12 + 0x68) = 0;
*param_2 = (long)local_58 - (long)local_40;
return local_40;
}
LAB_0017d029:
lVar12 = local_50;
*(int4 *)(local_50 + 0x108) = 0x7d8;
strncpy((char *)(local_50 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(lVar12 + 0x312) = 0;
strncpy((char *)(lVar12 + 0x10c),PTR_s_Client_run_out_of_memory_004e4f70,0x200);
*(int1 *)(lVar12 + 0x30b) = 0;
*param_2 = 0;
return (int4 *)0x0;
}
stmt_set_error(param_1,0x138e,"IM001",mariadb_client_errors._48_8_);
}
return (int4 *)0x0;
}
|
|
64,737 |
init_state_maps
|
eloqsql/mysys/charset.c
|
static my_bool init_state_maps(struct charset_info_st *cs)
{
uint i;
uchar *state_map;
uchar *ident_map;
if (!(cs->state_map= state_map= (uchar*) my_once_alloc(256*2, MYF(MY_WME))))
return 1;
cs->ident_map= ident_map= state_map + 256;
/* Fill state_map with states to get a faster parser */
for (i=0; i < 256 ; i++)
{
if (my_isalpha(cs,i))
state_map[i]=(uchar) MY_LEX_IDENT;
else if (my_isdigit(cs,i))
state_map[i]=(uchar) MY_LEX_NUMBER_IDENT;
else if (is_multi_byte_ident(cs, i))
state_map[i]=(uchar) MY_LEX_IDENT;
else if (my_isspace(cs,i))
state_map[i]=(uchar) MY_LEX_SKIP;
else
state_map[i]=(uchar) MY_LEX_CHAR;
}
state_map[(uchar)'_']=state_map[(uchar)'$']=(uchar) MY_LEX_IDENT;
state_map[(uchar)'\'']=(uchar) MY_LEX_STRING;
state_map[(uchar)'.']=(uchar) MY_LEX_REAL_OR_POINT;
state_map[(uchar)'>']=state_map[(uchar)'=']=state_map[(uchar)'!']= (uchar) MY_LEX_CMP_OP;
state_map[(uchar)'<']= (uchar) MY_LEX_LONG_CMP_OP;
state_map[(uchar)'&']=state_map[(uchar)'|']=(uchar) MY_LEX_BOOL;
state_map[(uchar)'#']=(uchar) MY_LEX_COMMENT;
state_map[(uchar)';']=(uchar) MY_LEX_SEMICOLON;
state_map[(uchar)':']=(uchar) MY_LEX_SET_VAR;
state_map[0]=(uchar) MY_LEX_EOL;
state_map[(uchar)'\\']= (uchar) MY_LEX_ESCAPE;
state_map[(uchar)'/']= (uchar) MY_LEX_LONG_COMMENT;
state_map[(uchar)'*']= (uchar) MY_LEX_END_LONG_COMMENT;
state_map[(uchar)'@']= (uchar) MY_LEX_USER_END;
state_map[(uchar) '`']= (uchar) MY_LEX_USER_VARIABLE_DELIMITER;
state_map[(uchar)'"']= (uchar) MY_LEX_STRING_OR_DELIMITER;
state_map[(uchar)'-']= (uchar) MY_LEX_MINUS_OR_COMMENT;
state_map[(uchar)',']= (uchar) MY_LEX_COMMA;
state_map[(uchar)'?']= (uchar) MY_LEX_PLACEHOLDER;
/*
Create a second map to make it faster to find identifiers
*/
for (i=0; i < 256 ; i++)
{
ident_map[i]= (uchar) (state_map[i] == MY_LEX_IDENT ||
state_map[i] == MY_LEX_NUMBER_IDENT);
}
/* Special handling of hex and binary strings */
state_map[(uchar)'x']= state_map[(uchar)'X']= (uchar) MY_LEX_IDENT_OR_HEX;
state_map[(uchar)'b']= state_map[(uchar)'B']= (uchar) MY_LEX_IDENT_OR_BIN;
state_map[(uchar)'n']= state_map[(uchar)'N']= (uchar) MY_LEX_IDENT_OR_NCHAR;
return 0;
}
|
O0
|
c
|
init_state_maps:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x200, %edi # imm = 0x200
movl $0x10, %esi
callq 0x2aaf0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rax, 0x80(%rcx)
cmpq $0x0, %rax
jne 0x2f939
movb $0x1, -0x1(%rbp)
jmp 0x2fb66
movq -0x20(%rbp), %rcx
addq $0x100, %rcx # imm = 0x100
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp) # imm = 0x100
jae 0x2fa23
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl %cl, %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x2f992
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x2, (%rax,%rcx)
jmp 0x2fa13
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl %cl, %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2f9ba
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0xe, (%rax,%rcx)
jmp 0x2fa11
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x2fc40
cmpb $0x0, %al
je 0x2f9da
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x2, (%rax,%rcx)
jmp 0x2fa0f
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl %cl, %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x2fa02
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x1a, (%rax,%rcx)
jmp 0x2fa0d
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x1, (%rax,%rcx)
jmp 0x2fa0f
jmp 0x2fa11
jmp 0x2fa13
jmp 0x2fa15
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f95a
movq -0x20(%rbp), %rax
movb $0x2, 0x24(%rax)
movq -0x20(%rbp), %rax
movb $0x2, 0x5f(%rax)
movq -0x20(%rbp), %rax
movb $0xa, 0x27(%rax)
movq -0x20(%rbp), %rax
movb $0x10, 0x2e(%rax)
movq -0x20(%rbp), %rax
movb $0x8, 0x21(%rax)
movq -0x20(%rbp), %rax
movb $0x8, 0x3d(%rax)
movq -0x20(%rbp), %rax
movb $0x8, 0x3e(%rax)
movq -0x20(%rbp), %rax
movb $0x9, 0x3c(%rax)
movq -0x20(%rbp), %rax
movb $0x11, 0x7c(%rax)
movq -0x20(%rbp), %rax
movb $0x11, 0x26(%rax)
movq -0x20(%rbp), %rax
movb $0xb, 0x23(%rax)
movq -0x20(%rbp), %rax
movb $0x16, 0x3b(%rax)
movq -0x20(%rbp), %rax
movb $0x17, 0x3a(%rax)
movq -0x20(%rbp), %rax
movb $0x12, (%rax)
movq -0x20(%rbp), %rax
movb $0x13, 0x5c(%rax)
movq -0x20(%rbp), %rax
movb $0x14, 0x2f(%rax)
movq -0x20(%rbp), %rax
movb $0x15, 0x2a(%rax)
movq -0x20(%rbp), %rax
movb $0x18, 0x40(%rax)
movq -0x20(%rbp), %rax
movb $0x1b, 0x60(%rax)
movq -0x20(%rbp), %rax
movb $0x21, 0x22(%rax)
movq -0x20(%rbp), %rax
movb $0x22, 0x2d(%rax)
movq -0x20(%rbp), %rax
movb $0x24, 0x2c(%rax)
movq -0x20(%rbp), %rax
movb $0x23, 0x3f(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp) # imm = 0x100
jae 0x2fb32
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x2, %ecx
movb %al, -0x29(%rbp)
je 0x2fb13
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0xe, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2fae1
movq -0x20(%rbp), %rax
movb $0x1e, 0x58(%rax)
movq -0x20(%rbp), %rax
movb $0x1e, 0x78(%rax)
movq -0x20(%rbp), %rax
movb $0x1f, 0x42(%rax)
movq -0x20(%rbp), %rax
movb $0x1f, 0x62(%rax)
movq -0x20(%rbp), %rax
movb $0x20, 0x4e(%rax)
movq -0x20(%rbp), %rax
movb $0x20, 0x6e(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
|
init_state_maps:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov edi, 200h
mov esi, 10h
call my_once_alloc
mov [rbp+var_20], rax
mov rcx, [rbp+var_10]
mov [rcx+80h], rax
cmp rax, 0
jnz short loc_2F939
mov [rbp+var_1], 1
jmp loc_2FB66
loc_2F939:
mov rcx, [rbp+var_20]
add rcx, 100h
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov [rax+88h], rcx
mov [rbp+var_14], 0
loc_2F95A:
cmp [rbp+var_14], 100h
jnb loc_2FA23
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov ecx, [rbp+var_14]
movzx ecx, cl
movzx eax, byte ptr [rax+rcx+1]
and eax, 3
cmp eax, 0
jz short loc_2F992
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
mov byte ptr [rax+rcx], 2
jmp loc_2FA13
loc_2F992:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov ecx, [rbp+var_14]
movzx ecx, cl
movzx eax, byte ptr [rax+rcx+1]
and eax, 4
cmp eax, 0
jz short loc_2F9BA
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
mov byte ptr [rax+rcx], 0Eh
jmp short loc_2FA11
loc_2F9BA:
mov rdi, [rbp+var_10]
mov eax, [rbp+var_14]
movzx esi, al
call is_multi_byte_ident
cmp al, 0
jz short loc_2F9DA
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
mov byte ptr [rax+rcx], 2
jmp short loc_2FA0F
loc_2F9DA:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov ecx, [rbp+var_14]
movzx ecx, cl
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_2FA02
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
mov byte ptr [rax+rcx], 1Ah
jmp short loc_2FA0D
loc_2FA02:
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
mov byte ptr [rax+rcx], 1
loc_2FA0D:
jmp short $+2
loc_2FA0F:
jmp short $+2
loc_2FA11:
jmp short $+2
loc_2FA13:
jmp short $+2
loc_2FA15:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_2F95A
loc_2FA23:
mov rax, [rbp+var_20]
mov byte ptr [rax+24h], 2
mov rax, [rbp+var_20]
mov byte ptr [rax+5Fh], 2
mov rax, [rbp+var_20]
mov byte ptr [rax+27h], 0Ah
mov rax, [rbp+var_20]
mov byte ptr [rax+2Eh], 10h
mov rax, [rbp+var_20]
mov byte ptr [rax+21h], 8
mov rax, [rbp+var_20]
mov byte ptr [rax+3Dh], 8
mov rax, [rbp+var_20]
mov byte ptr [rax+3Eh], 8
mov rax, [rbp+var_20]
mov byte ptr [rax+3Ch], 9
mov rax, [rbp+var_20]
mov byte ptr [rax+7Ch], 11h
mov rax, [rbp+var_20]
mov byte ptr [rax+26h], 11h
mov rax, [rbp+var_20]
mov byte ptr [rax+23h], 0Bh
mov rax, [rbp+var_20]
mov byte ptr [rax+3Bh], 16h
mov rax, [rbp+var_20]
mov byte ptr [rax+3Ah], 17h
mov rax, [rbp+var_20]
mov byte ptr [rax], 12h
mov rax, [rbp+var_20]
mov byte ptr [rax+5Ch], 13h
mov rax, [rbp+var_20]
mov byte ptr [rax+2Fh], 14h
mov rax, [rbp+var_20]
mov byte ptr [rax+2Ah], 15h
mov rax, [rbp+var_20]
mov byte ptr [rax+40h], 18h
mov rax, [rbp+var_20]
mov byte ptr [rax+60h], 1Bh
mov rax, [rbp+var_20]
mov byte ptr [rax+22h], 21h ; '!'
mov rax, [rbp+var_20]
mov byte ptr [rax+2Dh], 22h ; '"'
mov rax, [rbp+var_20]
mov byte ptr [rax+2Ch], 24h ; '$'
mov rax, [rbp+var_20]
mov byte ptr [rax+3Fh], 23h ; '#'
mov [rbp+var_14], 0
loc_2FAE1:
cmp [rbp+var_14], 100h
jnb short loc_2FB32
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
movzx ecx, byte ptr [rax+rcx]
mov al, 1
cmp ecx, 2
mov [rbp+var_29], al
jz short loc_2FB13
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
movzx eax, byte ptr [rax+rcx]
cmp eax, 0Eh
setz al
mov [rbp+var_29], al
loc_2FB13:
mov al, [rbp+var_29]
and al, 1
movzx eax, al
mov dl, al
mov rax, [rbp+var_28]
mov ecx, [rbp+var_14]
mov [rax+rcx], dl
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_2FAE1
loc_2FB32:
mov rax, [rbp+var_20]
mov byte ptr [rax+58h], 1Eh
mov rax, [rbp+var_20]
mov byte ptr [rax+78h], 1Eh
mov rax, [rbp+var_20]
mov byte ptr [rax+42h], 1Fh
mov rax, [rbp+var_20]
mov byte ptr [rax+62h], 1Fh
mov rax, [rbp+var_20]
mov byte ptr [rax+4Eh], 20h ; ' '
mov rax, [rbp+var_20]
mov byte ptr [rax+6Eh], 20h ; ' '
mov [rbp+var_1], 0
loc_2FB66:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char init_state_maps(_QWORD *a1)
{
bool v2; // [rsp+7h] [rbp-29h]
char *v3; // [rsp+10h] [rbp-20h]
unsigned int i; // [rsp+1Ch] [rbp-14h]
unsigned int j; // [rsp+1Ch] [rbp-14h]
v3 = my_once_alloc(512LL, 16);
a1[16] = v3;
if ( !v3 )
return 1;
a1[17] = v3 + 256;
for ( i = 0; i < 0x100; ++i )
{
if ( (*(_BYTE *)(a1[8] + (unsigned __int8)i + 1LL) & 3) != 0 )
{
v3[i] = 2;
}
else if ( (*(_BYTE *)(a1[8] + (unsigned __int8)i + 1LL) & 4) != 0 )
{
v3[i] = 14;
}
else if ( (unsigned __int8)is_multi_byte_ident(a1, (unsigned __int8)i) )
{
v3[i] = 2;
}
else if ( (*(_BYTE *)(a1[8] + (unsigned __int8)i + 1LL) & 8) != 0 )
{
v3[i] = 26;
}
else
{
v3[i] = 1;
}
}
v3[36] = 2;
v3[95] = 2;
v3[39] = 10;
v3[46] = 16;
v3[33] = 8;
v3[61] = 8;
v3[62] = 8;
v3[60] = 9;
v3[124] = 17;
v3[38] = 17;
v3[35] = 11;
v3[59] = 22;
v3[58] = 23;
*v3 = 18;
v3[92] = 19;
v3[47] = 20;
v3[42] = 21;
v3[64] = 24;
v3[96] = 27;
v3[34] = 33;
v3[45] = 34;
v3[44] = 36;
v3[63] = 35;
for ( j = 0; j < 0x100; ++j )
{
v2 = 1;
if ( v3[j] != 2 )
v2 = v3[j] == 14;
v3[j + 256] = v2;
}
v3[88] = 30;
v3[120] = 30;
v3[66] = 31;
v3[98] = 31;
v3[78] = 32;
v3[110] = 32;
return 0;
}
|
init_state_maps:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV EDI,0x200
MOV ESI,0x10
CALL 0x0012aaf0
MOV qword ptr [RBP + -0x20],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x80],RAX
CMP RAX,0x0
JNZ 0x0012f939
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012fb66
LAB_0012f939:
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x100
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x88],RCX
MOV dword ptr [RBP + -0x14],0x0
LAB_0012f95a:
CMP dword ptr [RBP + -0x14],0x100
JNC 0x0012fa23
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX ECX,CL
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x3
CMP EAX,0x0
JZ 0x0012f992
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],0x2
JMP 0x0012fa13
LAB_0012f992:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX ECX,CL
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x4
CMP EAX,0x0
JZ 0x0012f9ba
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],0xe
JMP 0x0012fa11
LAB_0012f9ba:
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOVZX ESI,AL
CALL 0x0012fc40
CMP AL,0x0
JZ 0x0012f9da
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],0x2
JMP 0x0012fa0f
LAB_0012f9da:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX ECX,CL
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0012fa02
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],0x1a
JMP 0x0012fa0d
LAB_0012fa02:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],0x1
LAB_0012fa0d:
JMP 0x0012fa0f
LAB_0012fa0f:
JMP 0x0012fa11
LAB_0012fa11:
JMP 0x0012fa13
LAB_0012fa13:
JMP 0x0012fa15
LAB_0012fa15:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0012f95a
LAB_0012fa23:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x24],0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x5f],0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x27],0xa
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2e],0x10
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x21],0x8
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3d],0x8
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3e],0x8
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3c],0x9
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x7c],0x11
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x26],0x11
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x23],0xb
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3b],0x16
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3a],0x17
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],0x12
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x5c],0x13
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2f],0x14
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2a],0x15
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x40],0x18
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x60],0x1b
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x22],0x21
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2d],0x22
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2c],0x24
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3f],0x23
MOV dword ptr [RBP + -0x14],0x0
LAB_0012fae1:
CMP dword ptr [RBP + -0x14],0x100
JNC 0x0012fb32
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX ECX,byte ptr [RAX + RCX*0x1]
MOV AL,0x1
CMP ECX,0x2
MOV byte ptr [RBP + -0x29],AL
JZ 0x0012fb13
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0xe
SETZ AL
MOV byte ptr [RBP + -0x29],AL
LAB_0012fb13:
MOV AL,byte ptr [RBP + -0x29]
AND AL,0x1
MOVZX EAX,AL
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0012fae1
LAB_0012fb32:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x58],0x1e
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x78],0x1e
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x42],0x1f
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x62],0x1f
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x4e],0x20
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x6e],0x20
MOV byte ptr [RBP + -0x1],0x0
LAB_0012fb66:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 init_state_maps(long param_1)
{
char cVar1;
int1 *puVar2;
bool local_31;
uint local_1c;
int1 local_9;
puVar2 = (int1 *)my_once_alloc(0x200,0x10);
*(int1 **)(param_1 + 0x80) = puVar2;
if (puVar2 == (int1 *)0x0) {
local_9 = 1;
}
else {
*(int1 **)(param_1 + 0x88) = puVar2 + 0x100;
for (local_1c = 0; local_1c < 0x100; local_1c = local_1c + 1) {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)(local_1c & 0xff)) & 3) == 0) {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)(local_1c & 0xff)) & 4) == 0) {
cVar1 = is_multi_byte_ident(param_1,local_1c & 0xff);
if (cVar1 == '\0') {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)(local_1c & 0xff)) & 8) == 0) {
puVar2[local_1c] = 1;
}
else {
puVar2[local_1c] = 0x1a;
}
}
else {
puVar2[local_1c] = 2;
}
}
else {
puVar2[local_1c] = 0xe;
}
}
else {
puVar2[local_1c] = 2;
}
}
puVar2[0x24] = 2;
puVar2[0x5f] = 2;
puVar2[0x27] = 10;
puVar2[0x2e] = 0x10;
puVar2[0x21] = 8;
puVar2[0x3d] = 8;
puVar2[0x3e] = 8;
puVar2[0x3c] = 9;
puVar2[0x7c] = 0x11;
puVar2[0x26] = 0x11;
puVar2[0x23] = 0xb;
puVar2[0x3b] = 0x16;
puVar2[0x3a] = 0x17;
*puVar2 = 0x12;
puVar2[0x5c] = 0x13;
puVar2[0x2f] = 0x14;
puVar2[0x2a] = 0x15;
puVar2[0x40] = 0x18;
puVar2[0x60] = 0x1b;
puVar2[0x22] = 0x21;
puVar2[0x2d] = 0x22;
puVar2[0x2c] = 0x24;
puVar2[0x3f] = 0x23;
for (local_1c = 0; local_1c < 0x100; local_1c = local_1c + 1) {
local_31 = true;
if (puVar2[local_1c] != '\x02') {
local_31 = puVar2[local_1c] == '\x0e';
}
(puVar2 + 0x100)[local_1c] = local_31;
}
puVar2[0x58] = 0x1e;
puVar2[0x78] = 0x1e;
puVar2[0x42] = 0x1f;
puVar2[0x62] = 0x1f;
puVar2[0x4e] = 0x20;
puVar2[0x6e] = 0x20;
local_9 = 0;
}
return local_9;
}
|
|
64,738 |
js_os_symlink
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_os_symlink(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *target, *linkpath;
int err;
target = JS_ToCString(ctx, argv[0]);
if (!target)
return JS_EXCEPTION;
linkpath = JS_ToCString(ctx, argv[1]);
if (!linkpath) {
JS_FreeCString(ctx, target);
return JS_EXCEPTION;
}
err = js_get_errno(symlink(target, linkpath));
JS_FreeCString(ctx, target);
JS_FreeCString(ctx, linkpath);
return JS_NewInt32(ctx, err);
}
|
O0
|
c
|
js_os_symlink:
subq $0x78, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x147e0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1b575
movl $0x0, 0x48(%rsp)
movq $0x6, 0x50(%rsp)
jmp 0x1b62b
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x147e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1b5bb
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x29e50
movl $0x0, 0x48(%rsp)
movq $0x6, 0x50(%rsp)
jmp 0x1b62b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe2b0
movslq %eax, %rdi
callq 0x13a50
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x29e50
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x29e50
movq 0x30(%rsp), %rcx
movl 0xc(%rsp), %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x68(%rsp)
movq $0x0, 0x70(%rsp)
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x78, %rsp
retq
nopw (%rax,%rax)
|
js_os_symlink:
sub rsp, 78h
mov [rsp+78h+var_40], rsi
mov [rsp+78h+var_38], rdx
mov [rsp+78h+var_48], rdi
mov [rsp+78h+var_4C], ecx
mov [rsp+78h+var_58], r8
mov rdi, [rsp+78h+var_48]
mov rax, [rsp+78h+var_58]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToCString
mov [rsp+78h+var_60], rax
cmp [rsp+78h+var_60], 0
jnz short loc_1B575
mov dword ptr [rsp+78h+var_30], 0
mov [rsp+78h+var_28], 6
jmp loc_1B62B
loc_1B575:
mov rdi, [rsp+78h+var_48]
mov rax, [rsp+78h+var_58]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
call JS_ToCString
mov [rsp+78h+var_68], rax
cmp [rsp+78h+var_68], 0
jnz short loc_1B5BB
mov rdi, [rsp+78h+var_48]
mov rsi, [rsp+78h+var_60]
call JS_FreeCString
mov dword ptr [rsp+78h+var_30], 0
mov [rsp+78h+var_28], 6
jmp short loc_1B62B
loc_1B5BB:
mov rdi, [rsp+78h+var_60]
mov rsi, [rsp+78h+var_68]
call _symlink
movsxd rdi, eax
call js_get_errno
mov [rsp+78h+var_6C], eax
mov rdi, [rsp+78h+var_48]
mov rsi, [rsp+78h+var_60]
call JS_FreeCString
mov rdi, [rsp+78h+var_48]
mov rsi, [rsp+78h+var_68]
call JS_FreeCString
mov rcx, [rsp+78h+var_48]
mov eax, [rsp+78h+var_6C]
mov [rsp+78h+var_18], rcx
mov [rsp+78h+var_1C], eax
mov eax, [rsp+78h+var_1C]
mov dword ptr [rsp+78h+var_10], eax
mov [rsp+78h+var_8], 0
mov rcx, [rsp+78h+var_10]
mov rax, [rsp+78h+var_8]
mov [rsp+78h+var_30], rcx
mov [rsp+78h+var_28], rax
loc_1B62B:
mov rax, [rsp+78h+var_30]
mov rdx, [rsp+78h+var_28]
add rsp, 78h
retn
|
long long js_os_symlink(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
int v5; // eax
int errno; // [rsp+Ch] [rbp-6Ch]
long long v8; // [rsp+10h] [rbp-68h]
long long v9; // [rsp+18h] [rbp-60h]
long long v11; // [rsp+48h] [rbp-30h]
long long v12; // [rsp+68h] [rbp-10h]
v9 = JS_ToCString(a1, *a5, a5[1]);
if ( v9 )
{
v8 = JS_ToCString(a1, a5[2], a5[3]);
if ( v8 )
{
v5 = symlink(v9, v8);
errno = js_get_errno(v5);
JS_FreeCString(a1, v9);
JS_FreeCString(a1, v8);
LODWORD(v12) = errno;
return v12;
}
else
{
JS_FreeCString(a1, v9);
LODWORD(v11) = 0;
}
}
else
{
LODWORD(v11) = 0;
}
return v11;
}
|
js_os_symlink:
SUB RSP,0x78
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x30],RDI
MOV dword ptr [RSP + 0x2c],ECX
MOV qword ptr [RSP + 0x20],R8
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001147e0
MOV qword ptr [RSP + 0x18],RAX
CMP qword ptr [RSP + 0x18],0x0
JNZ 0x0011b575
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x6
JMP 0x0011b62b
LAB_0011b575:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x001147e0
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x0011b5bb
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00129e50
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x6
JMP 0x0011b62b
LAB_0011b5bb:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x0010e2b0
MOVSXD RDI,EAX
CALL 0x00113a50
MOV dword ptr [RSP + 0xc],EAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00129e50
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00129e50
MOV RCX,qword ptr [RSP + 0x30]
MOV EAX,dword ptr [RSP + 0xc]
MOV qword ptr [RSP + 0x60],RCX
MOV dword ptr [RSP + 0x5c],EAX
MOV EAX,dword ptr [RSP + 0x5c]
MOV dword ptr [RSP + 0x68],EAX
MOV qword ptr [RSP + 0x70],0x0
MOV RCX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x48],RCX
MOV qword ptr [RSP + 0x50],RAX
LAB_0011b62b:
MOV RAX,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
ADD RSP,0x78
RET
|
int1 [16] js_os_symlink(int8 param_1)
{
int1 auVar1 [16];
int iVar2;
char *__from;
char *__to;
int8 *in_R8;
int4 local_30;
int4 uStack_2c;
int8 local_28;
int4 uStack_c;
__from = (char *)JS_ToCString(param_1,*in_R8,in_R8[1]);
if (__from == (char *)0x0) {
local_30 = 0;
local_28 = 6;
}
else {
__to = (char *)JS_ToCString(param_1,in_R8[2],in_R8[3]);
if (__to == (char *)0x0) {
JS_FreeCString(param_1,__from);
local_30 = 0;
local_28 = 6;
}
else {
iVar2 = symlink(__from,__to);
local_30 = js_get_errno((long)iVar2);
JS_FreeCString(param_1,__from);
JS_FreeCString(param_1,__to);
uStack_2c = uStack_c;
local_28 = 0;
}
}
auVar1._4_4_ = uStack_2c;
auVar1._0_4_ = local_30;
auVar1._8_8_ = local_28;
return auVar1;
}
|
|
64,739 |
js_os_symlink
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_os_symlink(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *target, *linkpath;
int err;
target = JS_ToCString(ctx, argv[0]);
if (!target)
return JS_EXCEPTION;
linkpath = JS_ToCString(ctx, argv[1]);
if (!linkpath) {
JS_FreeCString(ctx, target);
return JS_EXCEPTION;
}
err = js_get_errno(symlink(target, linkpath));
JS_FreeCString(ctx, target);
JS_FreeCString(ctx, linkpath);
return JS_NewInt32(ctx, err);
}
|
O3
|
c
|
js_os_symlink:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
xorl %r12d, %r12d
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x21353
movl $0x6, %r15d
testq %rax, %rax
je 0x1a920
movq %rax, %r14
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x21353
testq %rax, %rax
je 0x1a912
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0xe2b0
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x1a8f4
callq 0xe0b0
xorl %ebp, %ebp
subl (%rax), %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21629
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21629
movl %ebp, %r12d
xorl %r15d, %r15d
jmp 0x1a920
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21629
xorl %r12d, %r12d
movq %r12, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_os_symlink:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13, r8
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
xor r12d, r12d
xor esi, esi
xor r8d, r8d
call JS_ToCStringLen2
mov r15d, 6
test rax, rax
jz short loc_1A920
mov r14, rax
mov rdx, [r13+10h]
mov rcx, [r13+18h]
mov rdi, rbx
xor esi, esi
xor r8d, r8d
call JS_ToCStringLen2
test rax, rax
jz short loc_1A912
mov r12, rax
mov rdi, r14
mov rsi, rax
call _symlink
mov ebp, eax
cmp eax, 0FFFFFFFFh
jnz short loc_1A8F4
call ___errno_location
xor ebp, ebp
sub ebp, [rax]
loc_1A8F4:
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
mov rdi, rbx
mov rsi, r12
call JS_FreeCString
mov r12d, ebp
xor r15d, r15d
jmp short loc_1A920
loc_1A912:
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
xor r12d, r12d
loc_1A920:
mov rax, r12
mov rdx, r15
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_os_symlink(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v6; // r12
long long v7; // rax
long long v8; // r14
long long v9; // rax
long long v10; // r12
unsigned int v11; // ebp
v6 = 0LL;
v7 = JS_ToCStringLen2(a1, 0LL, *a5, a5[1], 0LL);
if ( v7 )
{
v8 = v7;
v9 = JS_ToCStringLen2(a1, 0LL, a5[2], a5[3], 0LL);
if ( v9 )
{
v10 = v9;
v11 = symlink(v8, v9);
if ( v11 == -1 )
v11 = -*(_DWORD *)__errno_location(v8);
JS_FreeCString(a1, v8);
JS_FreeCString(a1, v10);
return v11;
}
else
{
JS_FreeCString(a1, v8);
return 0LL;
}
}
return v6;
}
|
js_os_symlink:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13,R8
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
XOR R12D,R12D
XOR ESI,ESI
XOR R8D,R8D
CALL 0x00121353
MOV R15D,0x6
TEST RAX,RAX
JZ 0x0011a920
MOV R14,RAX
MOV RDX,qword ptr [R13 + 0x10]
MOV RCX,qword ptr [R13 + 0x18]
MOV RDI,RBX
XOR ESI,ESI
XOR R8D,R8D
CALL 0x00121353
TEST RAX,RAX
JZ 0x0011a912
MOV R12,RAX
MOV RDI,R14
MOV RSI,RAX
CALL 0x0010e2b0
MOV EBP,EAX
CMP EAX,-0x1
JNZ 0x0011a8f4
CALL 0x0010e0b0
XOR EBP,EBP
SUB EBP,dword ptr [RAX]
LAB_0011a8f4:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00121629
MOV RDI,RBX
MOV RSI,R12
CALL 0x00121629
MOV R12D,EBP
XOR R15D,R15D
JMP 0x0011a920
LAB_0011a912:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00121629
XOR R12D,R12D
LAB_0011a920:
MOV RAX,R12
MOV RDX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int js_os_symlink(int8 param_1)
{
int iVar1;
char *__from;
char *__to;
int *piVar2;
int8 *in_R8;
iVar1 = 0;
__from = (char *)JS_ToCStringLen2(param_1,0,*in_R8,in_R8[1],0);
if (__from != (char *)0x0) {
__to = (char *)JS_ToCStringLen2(param_1,0,in_R8[2],in_R8[3],0);
if (__to == (char *)0x0) {
JS_FreeCString(param_1,__from);
iVar1 = 0;
}
else {
iVar1 = symlink(__from,__to);
if (iVar1 == -1) {
piVar2 = __errno_location();
iVar1 = -*piVar2;
}
JS_FreeCString(param_1,__from);
JS_FreeCString(param_1,__to);
}
}
return iVar1;
}
|
|
64,740 |
ma_pvio_write_async
|
eloqsql/libmariadb/libmariadb/ma_pvio.c
|
static ssize_t ma_pvio_write_async(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
{
ssize_t res;
struct mysql_async_context *b= pvio->mysql->options.extension->async_context;
int timeout= pvio->timeout[PVIO_WRITE_TIMEOUT];
for (;;)
{
res= pvio->methods->async_write(pvio, buffer, length);
if (res >= 0 || IS_BLOCKING_ERROR())
return res;
b->events_to_wait_for= MYSQL_WAIT_WRITE;
if (timeout >= 0)
{
b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT;
b->timeout_value= timeout;
}
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
my_context_yield(&b->async_context);
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
if (b->events_occurred & MYSQL_WAIT_TIMEOUT)
return -1;
}
}
|
O0
|
c
|
ma_pvio_write_async:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x7e7ce
callq 0x3bb30
cmpl $0xb, (%rax)
je 0x7e7db
callq 0x3bb30
cmpl $0x4, (%rax)
je 0x7e7db
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7e86c
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
cmpl $0x0, -0x34(%rbp)
jl 0x7e800
movq -0x30(%rbp), %rax
movl (%rax), %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x7e822
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rsi
movl $0x1, %edi
callq *%rax
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0x9a140
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x7e84e
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rsi
xorl %edi, %edi
callq *%rax
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x7e867
movq $-0x1, -0x8(%rbp)
jmp 0x7e86c
jmp 0x7e795
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_pvio_write_async:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov eax, [rax+2Ch]
mov [rbp+var_34], eax
loc_7E795:
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov rax, [rax+28h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call rax
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jge short loc_7E7CE
call ___errno_location
cmp dword ptr [rax], 0Bh
jz short loc_7E7DB
call ___errno_location
cmp dword ptr [rax], 4
jz short loc_7E7DB
loc_7E7CE:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp loc_7E86C
loc_7E7DB:
mov rax, [rbp+var_30]
mov dword ptr [rax], 2
cmp [rbp+var_34], 0
jl short loc_7E800
mov rax, [rbp+var_30]
mov ecx, [rax]
or ecx, 8
mov [rax], ecx
mov ecx, [rbp+var_34]
mov rax, [rbp+var_30]
mov [rax+10h], ecx
loc_7E800:
mov rax, [rbp+var_30]
cmp qword ptr [rax+20h], 0
jz short loc_7E822
mov rax, [rbp+var_30]
mov rax, [rax+20h]
mov rcx, [rbp+var_30]
mov rsi, [rcx+28h]
mov edi, 1
call rax
loc_7E822:
mov rdi, [rbp+var_30]
add rdi, 38h ; '8'
call my_context_yield
mov rax, [rbp+var_30]
cmp qword ptr [rax+20h], 0
jz short loc_7E84E
mov rax, [rbp+var_30]
mov rax, [rax+20h]
mov rcx, [rbp+var_30]
mov rsi, [rcx+28h]
xor edi, edi
call rax
loc_7E84E:
mov rax, [rbp+var_30]
mov eax, [rax+4]
and eax, 8
cmp eax, 0
jz short loc_7E867
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_7E86C
loc_7E867:
jmp loc_7E795
loc_7E86C:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
long long ma_pvio_write_async(long long a1, long long a2, long long a3)
{
int v4; // [rsp+Ch] [rbp-34h]
long long v5; // [rsp+10h] [rbp-30h]
long long v6; // [rsp+18h] [rbp-28h]
v5 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL);
v4 = *(_DWORD *)(a1 + 44);
do
{
v6 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 72) + 40LL))(a1, a2, a3);
if ( v6 >= 0 || *(_DWORD *)__errno_location() != 11 && *(_DWORD *)__errno_location() != 4 )
return v6;
*(_DWORD *)v5 = 2;
if ( v4 >= 0 )
{
*(_DWORD *)v5 |= 8u;
*(_DWORD *)(v5 + 16) = v4;
}
if ( *(_QWORD *)(v5 + 32) )
(*(void ( **)(long long, _QWORD))(v5 + 32))(1LL, *(_QWORD *)(v5 + 40));
my_context_yield(v5 + 56);
if ( *(_QWORD *)(v5 + 32) )
(*(void ( **)(_QWORD, _QWORD))(v5 + 32))(0LL, *(_QWORD *)(v5 + 40));
}
while ( (*(_DWORD *)(v5 + 4) & 8) == 0 );
return -1LL;
}
|
ma_pvio_write_async:
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 RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x2c]
MOV dword ptr [RBP + -0x34],EAX
LAB_0017e795:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX + 0x28]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL RAX
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JGE 0x0017e7ce
CALL 0x0013bb30
CMP dword ptr [RAX],0xb
JZ 0x0017e7db
CALL 0x0013bb30
CMP dword ptr [RAX],0x4
JZ 0x0017e7db
LAB_0017e7ce:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e86c
LAB_0017e7db:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x2
CMP dword ptr [RBP + -0x34],0x0
JL 0x0017e800
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
OR ECX,0x8
MOV dword ptr [RAX],ECX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x10],ECX
LAB_0017e800:
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x0017e822
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x28]
MOV EDI,0x1
CALL RAX
LAB_0017e822:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x38
CALL 0x0019a140
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x0017e84e
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x28]
XOR EDI,EDI
CALL RAX
LAB_0017e84e:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x4]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0017e867
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0017e86c
LAB_0017e867:
JMP 0x0017e795
LAB_0017e86c:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long ma_pvio_write_async(long param_1,int8 param_2,int8 param_3)
{
uint uVar1;
uint *puVar2;
long lVar3;
int *piVar4;
puVar2 = *(uint **)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28);
uVar1 = *(uint *)(param_1 + 0x2c);
while( true ) {
lVar3 = (**(code **)(*(long *)(param_1 + 0x48) + 0x28))(param_1,param_2,param_3);
if (-1 < lVar3) {
return lVar3;
}
piVar4 = __errno_location();
if ((*piVar4 != 0xb) && (piVar4 = __errno_location(), *piVar4 != 4)) break;
*puVar2 = 2;
if (-1 < (int)uVar1) {
*puVar2 = *puVar2 | 8;
puVar2[4] = uVar1;
}
if (*(long *)(puVar2 + 8) != 0) {
(**(code **)(puVar2 + 8))(1,*(int8 *)(puVar2 + 10));
}
my_context_yield(puVar2 + 0xe);
if (*(long *)(puVar2 + 8) != 0) {
(**(code **)(puVar2 + 8))(0,*(int8 *)(puVar2 + 10));
}
if ((puVar2[1] & 8) != 0) {
return -1;
}
}
return lVar3;
}
|
|
64,741 |
ast_create_cond
|
tsotchke[P]eshkol/src/frontend/ast/create/ast_create.c
|
AstNode* ast_create_cond(Arena* arena, AstNode** clauses, size_t clause_count, size_t line, size_t column) {
AstNode* node = ast_create_node(arena, AST_COND, line, column);
if (!node) {
return NULL;
}
node->as.cond.clauses = clauses;
node->as.cond.clause_count = clause_count;
return node;
}
|
O3
|
c
|
ast_create_cond:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x12, %esi
movq %rcx, %rdx
movq %r8, %rcx
callq 0xa65c
testq %rax, %rax
je 0xaa23
movq %r14, 0x48(%rax)
movq %rbx, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
ast_create_cond:
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov esi, 12h
mov rdx, rcx
mov rcx, r8
call ast_create_node
test rax, rax
jz short loc_AA23
mov [rax+48h], r14
mov [rax+50h], rbx
loc_AA23:
add rsp, 8
pop rbx
pop r14
retn
|
long long ast_create_cond(long long a1, long long a2, long long a3, long long a4, long long a5)
{
long long result; // rax
result = ast_create_node(a1, 18, a4, a5);
if ( result )
{
*(_QWORD *)(result + 72) = a2;
*(_QWORD *)(result + 80) = a3;
}
return result;
}
|
ast_create_cond:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV ESI,0x12
MOV RDX,RCX
MOV RCX,R8
CALL 0x0010a65c
TEST RAX,RAX
JZ 0x0010aa23
MOV qword ptr [RAX + 0x48],R14
MOV qword ptr [RAX + 0x50],RBX
LAB_0010aa23:
ADD RSP,0x8
POP RBX
POP R14
RET
|
void ast_create_cond(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
long lVar1;
lVar1 = ast_create_node(param_1,0x12,param_4,param_5);
if (lVar1 != 0) {
*(int8 *)(lVar1 + 0x48) = param_2;
*(int8 *)(lVar1 + 0x50) = param_3;
}
return;
}
|
|
64,742 |
int10_to_str
|
eloqsql/strings/int2str.c
|
char *int10_to_str(long int val,char *dst,int radix)
{
char buffer[65];
register char *p;
long int new_val;
unsigned long int uval = (unsigned long int) val;
if (radix < 0) /* -10 */
{
if (val < 0)
{
*dst++ = '-';
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (unsigned long int)0 - uval;
}
}
p = &buffer[sizeof(buffer)-1];
*p = '\0';
new_val= (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val = new_val;
while (val != 0)
{
new_val=val/10;
*--p = '0' + (char) (val-new_val*10);
val= new_val;
}
while ((*dst++ = *p++) != 0) ;
return dst-1;
}
|
O3
|
c
|
int10_to_str:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
testl %edx, %edx
setns %al
testq %rdi, %rdi
setns %cl
orb %al, %cl
jne 0x398d7
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
leaq -0x11(%rbp), %r8
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %r9
movq %rdx, %rcx
movb $0x0, 0x1(%r8)
shrq $0x3, %rcx
imull $0xf6, %ecx, %eax
addl %edi, %eax
addb $0x30, %al
movb %al, (%r8)
cmpq $0xa, %rdi
jb 0x3992e
movq %rcx, %rax
mulq %r9
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %ecx, %eax
addb $0x30, %al
movb %al, -0x1(%r8)
decq %r8
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x3990a
decq %rsi
movb (%r8), %al
incq %r8
movb %al, 0x1(%rsi)
incq %rsi
testb %al, %al
jne 0x39931
movq %fs:0x28, %rax
cmpq -0x8(%rbp), %rax
jne 0x39959
movq %rsi, %rax
addq $0x50, %rsp
popq %rbp
retq
callq 0x25320
nop
|
int10_to_str:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
test edx, edx
setns al
test rdi, rdi
setns cl
or cl, al
jnz short loc_398D7
mov byte ptr [rsi], 2Dh ; '-'
inc rsi
neg rdi
loc_398D7:
lea r8, [rbp+var_11]
mov r9, 0CCCCCCCCCCCCCCCDh
mov rax, rdi
mul r9
mov rcx, rdx
mov byte ptr [r8+1], 0
shr rcx, 3
imul eax, ecx, 0F6h
add eax, edi
add al, 30h ; '0'
mov [r8], al
cmp rdi, 0Ah
jb short loc_3992E
loc_3990A:
mov rax, rcx
mul r9
shr rdx, 3
imul eax, edx, 0F6h
add eax, ecx
add al, 30h ; '0'
mov [r8-1], al
dec r8
cmp rcx, 9
mov rcx, rdx
ja short loc_3990A
loc_3992E:
dec rsi
loc_39931:
mov al, [r8]
inc r8
mov [rsi+1], al
inc rsi
test al, al
jnz short loc_39931
mov rax, fs:28h
cmp rax, [rbp+var_8]
jnz short loc_39959
mov rax, rsi
add rsp, 50h
pop rbp
retn
loc_39959:
call ___stack_chk_fail
|
_BYTE * int10_to_str(unsigned long long a1, _BYTE *a2, int a3)
{
char *v3; // r8
unsigned long long v4; // rcx
bool v5; // cc
_BYTE *v6; // rsi
char v7; // al
_BYTE v9[9]; // [rsp+3Fh] [rbp-11h] BYREF
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
if ( a3 < 0 && (a1 & 0x8000000000000000LL) != 0LL )
{
*a2++ = 45;
a1 = -(long long)a1;
}
v3 = v9;
v9[1] = 0;
v4 = a1 / 0xA;
v9[0] = a1 % 0xA + 48;
if ( a1 >= 0xA )
{
do
{
*--v3 = v4 % 0xA + 48;
v5 = v4 <= 9;
v4 /= 0xAuLL;
}
while ( !v5 );
}
v6 = a2 - 1;
do
{
v7 = *v3++;
*++v6 = v7;
}
while ( v7 );
return v6;
}
|
int10_to_str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
TEST EDX,EDX
SETNS AL
TEST RDI,RDI
SETNS CL
OR CL,AL
JNZ 0x001398d7
MOV byte ptr [RSI],0x2d
INC RSI
NEG RDI
LAB_001398d7:
LEA R8,[RBP + -0x11]
MOV R9,-0x3333333333333333
MOV RAX,RDI
MUL R9
MOV RCX,RDX
MOV byte ptr [R8 + 0x1],0x0
SHR RCX,0x3
IMUL EAX,ECX,0xf6
ADD EAX,EDI
ADD AL,0x30
MOV byte ptr [R8],AL
CMP RDI,0xa
JC 0x0013992e
LAB_0013990a:
MOV RAX,RCX
MUL R9
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,ECX
ADD AL,0x30
MOV byte ptr [R8 + -0x1],AL
DEC R8
CMP RCX,0x9
MOV RCX,RDX
JA 0x0013990a
LAB_0013992e:
DEC RSI
LAB_00139931:
MOV AL,byte ptr [R8]
INC R8
MOV byte ptr [RSI + 0x1],AL
INC RSI
TEST AL,AL
JNZ 0x00139931
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x8]
JNZ 0x00139959
MOV RAX,RSI
ADD RSP,0x50
POP RBP
RET
LAB_00139959:
CALL 0x00125320
|
int1 * int10_to_str(ulong param_1,int1 *param_2,int param_3)
{
char cVar1;
ulong uVar2;
ulong uVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if ((long)param_1 < 0 && param_3 < 0) {
*param_2 = 0x2d;
param_2 = param_2 + 1;
param_1 = -param_1;
}
pcVar4 = local_1a + 1;
local_1a[2] = 0;
local_1a[1] = (char)(param_1 / 10) * -10 + (char)param_1 + '0';
uVar3 = param_1 / 10;
while (uVar2 = uVar3, 9 < param_1) {
pcVar4[-1] = (char)(uVar2 / 10) * -10 + (char)uVar2 + '0';
pcVar4 = pcVar4 + -1;
uVar3 = uVar2 / 10;
param_1 = uVar2;
}
param_2 = param_2 + -1;
do {
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
param_2[1] = cVar1;
param_2 = param_2 + 1;
} while (cVar1 != '\0');
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_2;
}
|
|
64,743 |
test_gen(llama_context*, int, int)
|
monkey531[P]llama/examples/llama-bench/llama-bench.cpp
|
static void test_gen(llama_context * ctx, int n_gen, int n_threads) {
llama_set_n_threads(ctx, n_threads, n_threads);
const llama_model * model = llama_get_model(ctx);
const llama_vocab * vocab = llama_model_get_vocab(model);
const int32_t n_vocab = llama_vocab_n_tokens(vocab);
llama_token token = llama_vocab_get_add_bos(vocab) ? llama_vocab_bos(vocab) : std::rand() % n_vocab;
for (int i = 0; i < n_gen; i++) {
llama_decode(ctx, llama_batch_get_one(&token, 1));
llama_synchronize(ctx);
token = std::rand() % n_vocab;
}
}
|
O0
|
cpp
|
test_gen(llama_context*, int, int):
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movl %esi, 0xac(%rsp)
movl %edx, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
movl 0xa8(%rsp), %esi
movl 0xa8(%rsp), %edx
callq 0x57190
movq 0xb0(%rsp), %rdi
callq 0x56c20
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x57000
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x565d0
movl %eax, 0x94(%rsp)
movq 0x98(%rsp), %rdi
callq 0x57210
testb $0x1, %al
jne 0x63559
jmp 0x6356e
movq 0x98(%rsp), %rdi
callq 0x57270
movl %eax, %edx
movl %edx, 0x4c(%rsp)
jmp 0x6357f
callq 0x56f20
cltd
idivl 0x94(%rsp)
movl %edx, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x90(%rsp)
movl $0x0, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
cmpl 0xac(%rsp), %eax
jge 0x63637
movq 0xb0(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl $0x1, %edx
callq 0x563f0
movq 0x40(%rsp), %rdi
movq 0x80(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups 0x50(%rsp), %xmm0
movups 0x60(%rsp), %xmm1
movups 0x70(%rsp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x56540
movq 0xb0(%rsp), %rdi
callq 0x56700
callq 0x56f20
cltd
idivl 0x94(%rsp)
movl %edx, 0x90(%rsp)
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x63595
addq $0xb8, %rsp
retq
nop
|
_ZL8test_genP13llama_contextii:
sub rsp, 0B8h
mov [rsp+0B8h+var_8], rdi
mov [rsp+0B8h+var_C], esi
mov [rsp+0B8h+var_10], edx
mov rdi, [rsp+0B8h+var_8]
mov esi, [rsp+0B8h+var_10]
mov edx, [rsp+0B8h+var_10]
call _llama_set_n_threads
mov rdi, [rsp+0B8h+var_8]
call _llama_get_model
mov [rsp+0B8h+var_18], rax
mov rdi, [rsp+0B8h+var_18]
call _llama_model_get_vocab
mov [rsp+0B8h+var_20], rax
mov rdi, [rsp+0B8h+var_20]
call _llama_vocab_n_tokens
mov [rsp+0B8h+var_24], eax
mov rdi, [rsp+0B8h+var_20]
call _llama_vocab_get_add_bos
test al, 1
jnz short loc_63559
jmp short loc_6356E
loc_63559:
mov rdi, [rsp+0B8h+var_20]
call _llama_vocab_bos
mov edx, eax
mov [rsp+0B8h+var_6C], edx
jmp short loc_6357F
loc_6356E:
call _rand
cdq
idiv [rsp+0B8h+var_24]
mov [rsp+0B8h+var_6C], edx
loc_6357F:
mov eax, [rsp+0B8h+var_6C]
mov [rsp+0B8h+var_28], eax
mov [rsp+0B8h+var_2C], 0
loc_63595:
mov eax, [rsp+0B8h+var_2C]
cmp eax, [rsp+0B8h+var_C]
jge loc_63637
mov rax, [rsp+0B8h+var_8]
mov [rsp+0B8h+var_78], rax
lea rdi, [rsp+0B8h+var_68]
lea rsi, [rsp+0B8h+var_28]
mov edx, 1
call _llama_batch_get_one
mov rdi, [rsp+0B8h+var_78]
mov rcx, [rsp+0B8h+var_38]
mov rax, rsp
mov [rax+30h], rcx
movups xmm0, [rsp+0B8h+var_68]
movups xmm1, [rsp+0B8h+var_58]
movups xmm2, [rsp+0B8h+var_48]
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
call _llama_decode
mov rdi, [rsp+0B8h+var_8]
call _llama_synchronize
call _rand
cdq
idiv [rsp+0B8h+var_24]
mov [rsp+0B8h+var_28], edx
mov eax, [rsp+0B8h+var_2C]
add eax, 1
mov [rsp+0B8h+var_2C], eax
jmp loc_63595
loc_63637:
add rsp, 0B8h
retn
|
long long test_gen(long long a1, int a2, unsigned int a3)
{
long long result; // rax
long long v4; // rdx
long long v5; // r8
long long v6; // r9
long long v7; // [rsp+40h] [rbp-78h]
int v8; // [rsp+4Ch] [rbp-6Ch]
_QWORD v9[6]; // [rsp+50h] [rbp-68h] BYREF
long long v10; // [rsp+80h] [rbp-38h]
unsigned int i; // [rsp+8Ch] [rbp-2Ch]
int v12; // [rsp+90h] [rbp-28h] BYREF
int v13; // [rsp+94h] [rbp-24h]
long long vocab; // [rsp+98h] [rbp-20h]
long long model; // [rsp+A0h] [rbp-18h]
unsigned int v16; // [rsp+A8h] [rbp-10h]
int v17; // [rsp+ACh] [rbp-Ch]
long long v18; // [rsp+B0h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
llama_set_n_threads(a1, a3);
model = llama_get_model(a1);
vocab = llama_model_get_vocab(model);
v13 = llama_vocab_n_tokens(vocab);
if ( (llama_vocab_get_add_bos(vocab) & 1) != 0 )
v8 = llama_vocab_bos(vocab);
else
v8 = (int)rand() % v13;
v12 = v8;
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= v17 )
break;
v7 = v18;
llama_batch_get_one(v9, &v12, 1LL);
llama_decode(v7, &v12, v4, v10, v5, v6, v9[0], v9[1], v9[2], v9[3], v9[4], v9[5], v10);
llama_synchronize(v18);
v12 = (int)rand() % v13;
}
return result;
}
|
test_gen:
SUB RSP,0xb8
MOV qword ptr [RSP + 0xb0],RDI
MOV dword ptr [RSP + 0xac],ESI
MOV dword ptr [RSP + 0xa8],EDX
MOV RDI,qword ptr [RSP + 0xb0]
MOV ESI,dword ptr [RSP + 0xa8]
MOV EDX,dword ptr [RSP + 0xa8]
CALL 0x00157190
MOV RDI,qword ptr [RSP + 0xb0]
CALL 0x00156c20
MOV qword ptr [RSP + 0xa0],RAX
MOV RDI,qword ptr [RSP + 0xa0]
CALL 0x00157000
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0x98]
CALL 0x001565d0
MOV dword ptr [RSP + 0x94],EAX
MOV RDI,qword ptr [RSP + 0x98]
CALL 0x00157210
TEST AL,0x1
JNZ 0x00163559
JMP 0x0016356e
LAB_00163559:
MOV RDI,qword ptr [RSP + 0x98]
CALL 0x00157270
MOV EDX,EAX
MOV dword ptr [RSP + 0x4c],EDX
JMP 0x0016357f
LAB_0016356e:
CALL 0x00156f20
CDQ
IDIV dword ptr [RSP + 0x94]
MOV dword ptr [RSP + 0x4c],EDX
LAB_0016357f:
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0x90],EAX
MOV dword ptr [RSP + 0x8c],0x0
LAB_00163595:
MOV EAX,dword ptr [RSP + 0x8c]
CMP EAX,dword ptr [RSP + 0xac]
JGE 0x00163637
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x40],RAX
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x90]
MOV EDX,0x1
CALL 0x001563f0
MOV RDI,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x80]
MOV RAX,RSP
MOV qword ptr [RAX + 0x30],RCX
MOVUPS XMM0,xmmword ptr [RSP + 0x50]
MOVUPS XMM1,xmmword ptr [RSP + 0x60]
MOVUPS XMM2,xmmword ptr [RSP + 0x70]
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
CALL 0x00156540
MOV RDI,qword ptr [RSP + 0xb0]
CALL 0x00156700
CALL 0x00156f20
CDQ
IDIV dword ptr [RSP + 0x94]
MOV dword ptr [RSP + 0x90],EDX
MOV EAX,dword ptr [RSP + 0x8c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x8c],EAX
JMP 0x00163595
LAB_00163637:
ADD RSP,0xb8
RET
|
/* test_gen(llama_context*, int, int) */
void test_gen(llama_context *param_1,int param_2,int param_3)
{
llama_context *plVar1;
ulong uVar2;
int local_6c;
int1 local_68 [60];
int local_2c;
int local_28;
int local_24;
int8 local_20;
int8 local_18;
int local_10;
int local_c;
llama_context *local_8;
local_10 = param_3;
local_c = param_2;
local_8 = param_1;
llama_set_n_threads(param_1,param_3,param_3);
local_18 = llama_get_model(local_8);
local_20 = llama_model_get_vocab(local_18);
local_24 = llama_vocab_n_tokens(local_20);
uVar2 = llama_vocab_get_add_bos(local_20);
if ((uVar2 & 1) == 0) {
local_6c = rand();
local_6c = local_6c % local_24;
}
else {
local_6c = llama_vocab_bos(local_20);
}
local_28 = local_6c;
for (local_2c = 0; plVar1 = local_8, local_2c < local_c; local_2c = local_2c + 1) {
llama_batch_get_one(local_68,&local_28,1);
llama_decode(plVar1);
llama_synchronize(local_8);
local_28 = rand();
local_28 = local_28 % local_24;
}
return;
}
|
|
64,744 |
google::protobuf::FileDescriptor::InternalDependenciesOnceInit() const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc
|
void FileDescriptor::InternalDependenciesOnceInit() const {
GOOGLE_CHECK(finished_building_ == true);
const char* names_ptr = reinterpret_cast<const char*>(dependencies_once_ + 1);
for (int i = 0; i < dependency_count(); i++) {
const char* name = names_ptr;
names_ptr += strlen(name) + 1;
if (name[0] != '\0') {
dependencies_[i] = pool_->FindFileByName(name);
}
}
}
|
O3
|
cpp
|
google::protobuf::FileDescriptor::InternalDependenciesOnceInit() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x2(%rdi)
jne 0xdd29f
leaq 0x8ec31(%rip), %rdx # 0x16be93
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x204d, %ecx # imm = 0x204D
callq 0x857c2
leaq 0x910b8(%rip), %rsi # 0x16e338
movq %r14, %rdi
callq 0x852c0
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x8539a
leaq 0x10(%rsp), %rdi
callq 0x857e0
movl 0x28(%rbx), %r13d
testl %r13d, %r13d
jle 0xdd32d
movq 0x20(%rbx), %r14
addq $0x4, %r14
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
movq %r14, %rdi
callq 0x2c700
movq %rax, %r12
cmpb $0x0, (%r14)
je 0xdd31c
movq 0x18(%rbx), %r13
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x2c700
leaq (%rax,%r14), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2c610
movq %r13, %rdi
movq %r15, %rsi
callq 0xc0454
movq 0x40(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xdd318
callq 0x2d160
movl 0x28(%rbx), %r13d
addq %r12, %r14
incq %r14
incq %rbp
movslq %r13d, %rax
cmpq %rax, %rbp
jl 0xdd2bb
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdd33e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x857e0
jmp 0xdd369
movq %rax, %rbx
jmp 0xdd369
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xdd369
callq 0x2d160
movq %rbx, %rdi
callq 0x2e220
nop
|
_ZNK6google8protobuf14FileDescriptor28InternalDependenciesOnceInitEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdi
cmp byte ptr [rdi+2], 0
jnz short loc_DD29F
lea rdx, aWorkspaceLlm4b_34; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+78h+var_68]
mov rdi, r14
mov esi, 3
mov ecx, 204Dh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedFin; "CHECK failed: finished_building_ == tru"...
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+78h+var_69]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+78h+var_68]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_DD29F:
mov r13d, [rbx+28h]
test r13d, r13d
jle loc_DD32D
mov r14, [rbx+20h]
add r14, 4
xor ebp, ebp
lea r15, [rsp+78h+var_68]
loc_DD2BB:
mov rdi, r14
call _strlen
mov r12, rax
cmp byte ptr [r14], 0
jz short loc_DD31C
mov r13, [rbx+18h]
lea rax, [rsp+78h+var_58]
mov [rsp+78h+var_68], rax
mov rdi, r14
call _strlen
lea rdx, [rax+r14]
mov rdi, r15
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, r13
mov rsi, r15
call _ZNK6google8protobuf14DescriptorPool14FindFileByNameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::DescriptorPool::FindFileByName(std::string const&)
mov rcx, [rbx+40h]
mov [rcx+rbp*8], rax
mov rdi, [rsp+78h+var_68]; void *
lea rax, [rsp+78h+var_58]
cmp rdi, rax
jz short loc_DD318
call __ZdlPv; operator delete(void *)
loc_DD318:
mov r13d, [rbx+28h]
loc_DD31C:
add r14, r12
inc r14
inc rbp
movsxd rax, r13d
cmp rbp, rax
jl short loc_DD2BB
loc_DD32D:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_DD33E:
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_DD369
mov rbx, rax
jmp short loc_DD369
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
lea rax, [rsp+arg_18]
cmp rdi, rax
jz short loc_DD369
call __ZdlPv; operator delete(void *)
loc_DD369:
mov rdi, rbx
call __Unwind_Resume
|
void google::protobuf::FileDescriptor::InternalDependenciesOnceInit(google::protobuf::FileDescriptor *this)
{
google::protobuf::internal::LogMessage *v1; // rax
int v2; // r13d
const char *v3; // r14
long long i; // rbp
long long v5; // r12
_QWORD *v6; // r13
long long v7; // rax
char v8; // [rsp+Fh] [rbp-69h] BYREF
void *v9[2]; // [rsp+10h] [rbp-68h] BYREF
_BYTE v10[88]; // [rsp+20h] [rbp-58h] BYREF
if ( !*((_BYTE *)this + 2) )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v9,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc",
8269);
v1 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v9,
(long long)"CHECK failed: finished_building_ == true: ");
google::protobuf::internal::LogFinisher::operator=((long long)&v8, v1);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v9);
}
v2 = *((_DWORD *)this + 10);
if ( v2 > 0 )
{
v3 = (const char *)(*((_QWORD *)this + 4) + 4LL);
for ( i = 0LL; i < v2; ++i )
{
v5 = strlen(v3);
if ( *v3 )
{
v6 = (_QWORD *)*((_QWORD *)this + 3);
v9[0] = v10;
v7 = strlen(v3);
std::string::_M_construct<char const*>(v9, v3, &v3[v7]);
*(_QWORD *)(*((_QWORD *)this + 8) + 8 * i) = google::protobuf::DescriptorPool::FindFileByName(v6, v9);
if ( v9[0] != v10 )
operator delete(v9[0]);
v2 = *((_DWORD *)this + 10);
}
v3 += v5 + 1;
}
}
}
|
InternalDependenciesOnceInit:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDI
CMP byte ptr [RDI + 0x2],0x0
JNZ 0x001dd29f
LEA RDX,[0x26be93]
LEA R14,[RSP + 0x10]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x204d
CALL 0x001857c2
LAB_001dd279:
LEA RSI,[0x26e338]
MOV RDI,R14
CALL 0x001852c0
LAB_001dd288:
LEA RDI,[RSP + 0xf]
MOV RSI,RAX
CALL 0x0018539a
LEA RDI,[RSP + 0x10]
CALL 0x001857e0
LAB_001dd29f:
MOV R13D,dword ptr [RBX + 0x28]
TEST R13D,R13D
JLE 0x001dd32d
MOV R14,qword ptr [RBX + 0x20]
ADD R14,0x4
XOR EBP,EBP
LEA R15,[RSP + 0x10]
LAB_001dd2bb:
MOV RDI,R14
CALL 0x0012c700
MOV R12,RAX
CMP byte ptr [R14],0x0
JZ 0x001dd31c
MOV R13,qword ptr [RBX + 0x18]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,R14
CALL 0x0012c700
LEA RDX,[RAX + R14*0x1]
LAB_001dd2e6:
MOV RDI,R15
MOV RSI,R14
CALL 0x0012c610
LAB_001dd2f1:
MOV RDI,R13
MOV RSI,R15
CALL 0x001c0454
LAB_001dd2fc:
MOV RCX,qword ptr [RBX + 0x40]
MOV qword ptr [RCX + RBP*0x8],RAX
MOV RDI,qword ptr [RSP + 0x10]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x001dd318
CALL 0x0012d160
LAB_001dd318:
MOV R13D,dword ptr [RBX + 0x28]
LAB_001dd31c:
ADD R14,R12
INC R14
INC RBP
MOVSXD RAX,R13D
CMP RBP,RAX
JL 0x001dd2bb
LAB_001dd32d:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::FileDescriptor::InternalDependenciesOnceInit() const */
void __thiscall google::protobuf::FileDescriptor::InternalDependenciesOnceInit(FileDescriptor *this)
{
DescriptorPool *this_00;
LogMessage *pLVar1;
size_t sVar2;
size_t sVar3;
int8 uVar4;
long lVar5;
int iVar6;
char *__s;
LogFinisher local_69;
int1 *local_68 [2];
int1 local_58 [40];
if (this[2] == (FileDescriptor)0x0) {
internal::LogMessage::LogMessage
((LogMessage *)local_68,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc"
,0x204d);
/* try { // try from 001dd279 to 001dd287 has its CatchHandler @ 001dd33e */
pLVar1 = (LogMessage *)
internal::LogMessage::operator<<
((LogMessage *)local_68,"CHECK failed: finished_building_ == true: ");
/* try { // try from 001dd288 to 001dd294 has its CatchHandler @ 001dd33c */
internal::LogFinisher::operator=(&local_69,pLVar1);
internal::LogMessage::~LogMessage((LogMessage *)local_68);
}
iVar6 = *(int *)(this + 0x28);
if (0 < iVar6) {
__s = (char *)(*(long *)(this + 0x20) + 4);
lVar5 = 0;
do {
sVar2 = strlen(__s);
if (*__s != '\0') {
this_00 = *(DescriptorPool **)(this + 0x18);
local_68[0] = local_58;
sVar3 = strlen(__s);
/* try { // try from 001dd2e6 to 001dd2f0 has its CatchHandler @ 001dd34d */
std::__cxx11::string::_M_construct<char_const*>((string *)local_68,__s,__s + sVar3);
/* try { // try from 001dd2f1 to 001dd2fb has its CatchHandler @ 001dd352 */
uVar4 = DescriptorPool::FindFileByName(this_00,(string *)local_68);
*(int8 *)(*(long *)(this + 0x40) + lVar5 * 8) = uVar4;
if (local_68[0] != local_58) {
operator_delete(local_68[0]);
}
iVar6 = *(int *)(this + 0x28);
}
__s = __s + sVar2 + 1;
lVar5 = lVar5 + 1;
} while (lVar5 < iVar6);
}
return;
}
|
|
64,745 |
gguf_get_val_u64
|
monkey531[P]llama/ggml/src/gguf.cpp
|
uint64_t gguf_get_val_u64(const struct gguf_context * ctx, int64_t key_id) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
GGML_ASSERT(ctx->kv[key_id].get_ne() == 1);
return ctx->kv[key_id].get_val<uint64_t>();
}
|
O2
|
cpp
|
gguf_get_val_u64:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x3f346
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rax
subq %rdi, %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
cmpq %rsi, %rax
jle 0x3f346
imulq $0x58, %rsi, %r14
addq %r14, %rdi
callq 0x1c870
cmpq $0x1, %rax
jne 0x3f362
addq 0x8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1ce60
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1b4b8(%rip), %rdi # 0x5a805
leaq 0xc279(%rip), %rdx # 0x4b5cd
leaq 0x1b935(%rip), %rcx # 0x5ac90
movl $0x34d, %esi # imm = 0x34D
jmp 0x3f37c
leaq 0x1b49c(%rip), %rdi # 0x5a805
leaq 0xc25d(%rip), %rdx # 0x4b5cd
leaq 0x1b9e8(%rip), %rcx # 0x5ad5f
movl $0x34e, %esi # imm = 0x34E
xorl %eax, %eax
callq 0x1e760
|
gguf_get_val_u64:
push r14
push rbx
push rax
test rsi, rsi
js short loc_3F346
mov rbx, rdi
mov rdi, [rdi+8]
mov rax, [rbx+10h]
sub rax, rdi
push 58h ; 'X'
pop rcx
cqo
idiv rcx
cmp rax, rsi
jle short loc_3F346
imul r14, rsi, 58h ; 'X'
add rdi, r14; this
call __ZNK7gguf_kv6get_neEv; gguf_kv::get_ne(void)
cmp rax, 1
jnz short loc_3F362
add r14, [rbx+8]
mov rdi, r14
xor esi, esi
call __ZNK7gguf_kv7get_valImEERKT_m; gguf_kv::get_val<ulong>(ulong)
mov rax, [rax]
add rsp, 8
pop rbx
pop r14
retn
loc_3F346:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyId0KeyIdGgu; "key_id >= 0 && key_id < gguf_get_n_kv(c"...
mov esi, 34Dh
jmp short loc_3F37C
loc_3F362:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCtxKvKeyIdGetN; "ctx->kv[key_id].get_ne() == 1"
mov esi, 34Eh
loc_3F37C:
xor eax, eax
call _ggml_abort
|
long long gguf_get_val_u64(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char v14; // al
long long v16; // rdi
const char *v18; // rcx
int v19; // esi
char v20; // [rsp-8h] [rbp-18h]
v20 = v14;
if ( a2 < 0 || (v16 = *(_QWORD *)(a1 + 8), (*(_QWORD *)(a1 + 16) - v16) / 88 <= a2) )
{
v18 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
v19 = 845;
goto LABEL_7;
}
if ( gguf_kv::get_ne((gguf_kv *)(88 * a2 + v16)) != 1 )
{
v18 = "ctx->kv[key_id].get_ne() == 1";
v19 = 846;
LABEL_7:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",
v19,
(long long)"GGML_ASSERT(%s) failed",
(long long)v18,
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v20);
}
return *(_QWORD *)gguf_kv::get_val<unsigned long>(*(_QWORD *)(a1 + 8) + 88 * a2, 0LL);
}
|
gguf_get_val_u64:
PUSH R14
PUSH RBX
PUSH RAX
TEST RSI,RSI
JS 0x0013f346
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,RDI
PUSH 0x58
POP RCX
CQO
IDIV RCX
CMP RAX,RSI
JLE 0x0013f346
IMUL R14,RSI,0x58
ADD RDI,R14
CALL 0x0011c870
CMP RAX,0x1
JNZ 0x0013f362
ADD R14,qword ptr [RBX + 0x8]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0011ce60
MOV RAX,qword ptr [RAX]
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0013f346:
LEA RDI,[0x15a805]
LEA RDX,[0x14b5cd]
LEA RCX,[0x15ac90]
MOV ESI,0x34d
JMP 0x0013f37c
LAB_0013f362:
LEA RDI,[0x15a805]
LEA RDX,[0x14b5cd]
LEA RCX,[0x15ad5f]
MOV ESI,0x34e
LAB_0013f37c:
XOR EAX,EAX
CALL 0x0011e760
|
ulong gguf_get_val_u64(long param_1,long param_2)
{
long lVar1;
ulong *puVar2;
char *pcVar3;
int8 uVar4;
if (-1 < param_2) {
if (param_2 < (*(long *)(param_1 + 0x10) - *(long *)(param_1 + 8)) / 0x58) {
lVar1 = gguf_kv::get_ne((gguf_kv *)(*(long *)(param_1 + 8) + param_2 * 0x58));
if (lVar1 == 1) {
puVar2 = gguf_kv::get_val<unsigned_long>
((gguf_kv *)(param_2 * 0x58 + *(long *)(param_1 + 8)),0);
return *puVar2;
}
pcVar3 = "ctx->kv[key_id].get_ne() == 1";
uVar4 = 0x34e;
goto LAB_0013f37c;
}
}
pcVar3 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
uVar4 = 0x34d;
LAB_0013f37c:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",uVar4,
"GGML_ASSERT(%s) failed",pcVar3);
}
|
|
64,746 |
minja::ForTemplateToken::ForTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, bool)
|
llama.cpp/common/minja/minja.hpp
|
ForTemplateToken(const Location & loc, SpaceHandling pre, SpaceHandling post, const std::vector<std::string> & vns, std::shared_ptr<Expression> && iter,
std::shared_ptr<Expression> && c, bool r)
: TemplateToken(Type::For, loc, pre, post), var_names(vns), iterable(std::move(iter)), condition(std::move(c)), recursive(r) {}
|
O3
|
cpp
|
minja::ForTemplateToken::ForTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, bool):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %rdi, %rbx
leaq 0x60eb1(%rip), %r12 # 0x109960
addq $0x10, %r12
movq %r12, (%rdi)
movl $0x6, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0xa8ae6
movq 0x624b0(%rip), %rdi # 0x10af88
cmpb $0x0, (%rdi)
je 0xa8ae2
incl 0x8(%rax)
jmp 0xa8ae6
lock
incl 0x8(%rax)
leaq 0x18(%rbx), %r15
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rbx)
movl %edx, 0x28(%rbx)
movl %ecx, 0x2c(%rbx)
leaq 0x61699(%rip), %rax # 0x10a198
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x30(%rbx), %rdi
movq %r8, %rsi
callq 0x6e1f0
movb 0x38(%rsp), %al
movq 0x30(%rsp), %rcx
xorl %edx, %edx
movq %rdx, 0x50(%rbx)
movups (%r14), %xmm0
movq %rdx, 0x8(%r14)
movups %xmm0, 0x48(%rbx)
movq %rdx, (%r14)
movq %rdx, 0x60(%rbx)
movups (%rcx), %xmm0
movq %rdx, 0x8(%rcx)
movups %xmm0, 0x58(%rbx)
movq %rdx, (%rcx)
movb %al, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, (%rbx)
movq %r15, %rdi
callq 0x56124
movq %r14, %rdi
callq 0x1d8e0
nop
|
_ZN5minja16ForTemplateTokenC2ERKNS_8LocationENS_13SpaceHandlingES4_RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaISB_EEOSt10shared_ptrINS_10ExpressionEESJ_b:
push r15
push r14
push r12
push rbx
push rax
mov r14, r9
mov rbx, rdi
lea r12, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add r12, 10h
mov [rdi], r12
mov dword ptr [rdi+8], 6
mov rax, [rsi]
mov [rdi+10h], rax
mov rax, [rsi+8]
mov [rdi+18h], rax
test rax, rax
jz short loc_A8AE6
mov rdi, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rdi], 0
jz short loc_A8AE2
inc dword ptr [rax+8]
jmp short loc_A8AE6
loc_A8AE2:
lock inc dword ptr [rax+8]
loc_A8AE6:
lea r15, [rbx+18h]
mov rax, [rsi+10h]
mov [rbx+20h], rax
mov [rbx+28h], edx
mov [rbx+2Ch], ecx
lea rax, _ZTVN5minja16ForTemplateTokenE; `vtable for'minja::ForTemplateToken
add rax, 10h
mov [rbx], rax
lea rdi, [rbx+30h]
mov rsi, r8
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
mov al, [rsp+28h+arg_8]
mov rcx, [rsp+28h+arg_0]
xor edx, edx
mov [rbx+50h], rdx
movups xmm0, xmmword ptr [r14]
mov [r14+8], rdx
movups xmmword ptr [rbx+48h], xmm0
mov [r14], rdx
mov [rbx+60h], rdx
movups xmm0, xmmword ptr [rcx]
mov [rcx+8], rdx
movups xmmword ptr [rbx+58h], xmm0
mov [rcx], rdx
mov [rbx+68h], al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov [rbx], r12
mov rdi, r15
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
|
char minja::ForTemplateToken::ForTemplateToken(
long long a1,
_QWORD *a2,
int a3,
int a4,
_QWORD *a5,
__int128 *a6,
__int128 *a7,
char a8)
{
long long v9; // rax
char result; // al
__int128 v11; // xmm0
__int128 v12; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::TemplateToken + 2;
*(_DWORD *)(a1 + 8) = 6;
*(_QWORD *)(a1 + 16) = *a2;
v9 = a2[1];
*(_QWORD *)(a1 + 24) = v9;
if ( v9 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v9 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v9 + 8));
}
*(_QWORD *)(a1 + 32) = a2[2];
*(_DWORD *)(a1 + 40) = a3;
*(_DWORD *)(a1 + 44) = a4;
*(_QWORD *)a1 = &`vtable for'minja::ForTemplateToken + 2;
std::vector<std::string>::vector(a1 + 48, a5);
result = a8;
*(_QWORD *)(a1 + 80) = 0LL;
v11 = *a6;
*((_QWORD *)a6 + 1) = 0LL;
*(_OWORD *)(a1 + 72) = v11;
*(_QWORD *)a6 = 0LL;
*(_QWORD *)(a1 + 96) = 0LL;
v12 = *a7;
*((_QWORD *)a7 + 1) = 0LL;
*(_OWORD *)(a1 + 88) = v12;
*(_QWORD *)a7 = 0LL;
*(_BYTE *)(a1 + 104) = a8;
return result;
}
|
ForTemplateToken:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R9
MOV RBX,RDI
LEA R12,[0x209960]
ADD R12,0x10
MOV qword ptr [RDI],R12
MOV dword ptr [RDI + 0x8],0x6
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x18],RAX
TEST RAX,RAX
JZ 0x001a8ae6
MOV RDI,qword ptr [0x0020af88]
CMP byte ptr [RDI],0x0
JZ 0x001a8ae2
INC dword ptr [RAX + 0x8]
JMP 0x001a8ae6
LAB_001a8ae2:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001a8ae6:
LEA R15,[RBX + 0x18]
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RBX + 0x20],RAX
MOV dword ptr [RBX + 0x28],EDX
MOV dword ptr [RBX + 0x2c],ECX
LEA RAX,[0x20a198]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA RDI,[RBX + 0x30]
LAB_001a8b0a:
MOV RSI,R8
CALL 0x0016e1f0
LAB_001a8b12:
MOV AL,byte ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP + 0x30]
XOR EDX,EDX
MOV qword ptr [RBX + 0x50],RDX
MOVUPS XMM0,xmmword ptr [R14]
MOV qword ptr [R14 + 0x8],RDX
MOVUPS xmmword ptr [RBX + 0x48],XMM0
MOV qword ptr [R14],RDX
MOV qword ptr [RBX + 0x60],RDX
MOVUPS XMM0,xmmword ptr [RCX]
MOV qword ptr [RCX + 0x8],RDX
MOVUPS xmmword ptr [RBX + 0x58],XMM0
MOV qword ptr [RCX],RDX
MOV byte ptr [RBX + 0x68],AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::ForTemplateToken::ForTemplateToken(minja::Location const&, minja::SpaceHandling,
minja::SpaceHandling, std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > >
const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, bool) */
void __thiscall
minja::ForTemplateToken::ForTemplateToken
(ForTemplateToken *this,int8 *param_1,int4 param_3,int4 param_4,
vector *param_5,int8 *param_6,int8 *param_7,ForTemplateToken param_8)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR__TemplateToken_00209970;
*(int4 *)(this + 8) = 6;
*(int8 *)(this + 0x10) = *param_1;
lVar1 = param_1[1];
*(long *)(this + 0x18) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_0020af88 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x20) = param_1[2];
*(int4 *)(this + 0x28) = param_3;
*(int4 *)(this + 0x2c) = param_4;
*(int ***)this = &PTR__ForTemplateToken_0020a1a8;
/* try { // try from 001a8b0a to 001a8b11 has its CatchHandler @ 001a8b51 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)(this + 0x30),
param_5);
*(int8 *)(this + 0x50) = 0;
uVar2 = param_6[1];
param_6[1] = 0;
*(int8 *)(this + 0x48) = *param_6;
*(int8 *)(this + 0x50) = uVar2;
*param_6 = 0;
*(int8 *)(this + 0x60) = 0;
uVar2 = param_7[1];
param_7[1] = 0;
*(int8 *)(this + 0x58) = *param_7;
*(int8 *)(this + 0x60) = uVar2;
*param_7 = 0;
this[0x68] = param_8;
return;
}
|
|
64,747 |
bitmap_subtract
|
eloqsql/mysys/my_bitmap.c
|
void bitmap_subtract(MY_BITMAP *map, const MY_BITMAP *map2)
{
my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map->n_bits==map2->n_bits);
end= map->last_word_ptr;
while (to <= end)
*to++ &= ~(*from++);
}
|
O0
|
c
|
bitmap_subtract:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xf04d4
jmp 0xf04d6
jmp 0xf04d8
jmp 0xf04da
jmp 0xf04dc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0xf051b
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %ecx
xorl $-0x1, %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x18(%rbp)
andl (%rax), %ecx
movl %ecx, (%rax)
jmp 0xf04e8
popq %rbp
retq
nopl (%rax)
|
bitmap_subtract:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short $+2
loc_F04D4:
jmp short $+2
loc_F04D6:
jmp short $+2
loc_F04D8:
jmp short $+2
loc_F04DA:
jmp short $+2
loc_F04DC:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_28], rax
loc_F04E8:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_28]
ja short loc_F051B
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 4
mov [rbp+var_20], rcx
mov ecx, [rax]
xor ecx, 0FFFFFFFFh
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 4
mov [rbp+var_18], rdx
and ecx, [rax]
mov [rax], ecx
jmp short loc_F04E8
loc_F051B:
pop rbp
retn
|
_DWORD * bitmap_subtract(_QWORD *a1, _QWORD *a2)
{
_DWORD *result; // rax
_DWORD *v3; // rax
int v4; // ecx
_DWORD *v5; // rax
unsigned long long v6; // [rsp+0h] [rbp-28h]
_DWORD *v7; // [rsp+8h] [rbp-20h]
_DWORD *v8; // [rsp+10h] [rbp-18h]
v8 = (_DWORD *)*a1;
v7 = (_DWORD *)*a2;
v6 = a1[1];
while ( 1 )
{
result = v8;
if ( (unsigned long long)v8 > v6 )
break;
v3 = v7++;
v4 = ~*v3;
v5 = v8++;
*v5 &= v4;
}
return result;
}
|
bitmap_subtract:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001f04d4
LAB_001f04d4:
JMP 0x001f04d6
LAB_001f04d6:
JMP 0x001f04d8
LAB_001f04d8:
JMP 0x001f04da
LAB_001f04da:
JMP 0x001f04dc
LAB_001f04dc:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001f04e8:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x28]
JA 0x001f051b
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x20],RCX
MOV ECX,dword ptr [RAX]
XOR ECX,0xffffffff
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x18],RDX
AND ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
JMP 0x001f04e8
LAB_001f051b:
POP RBP
RET
|
void bitmap_subtract(int8 *param_1,int8 *param_2)
{
uint *puVar1;
uint *local_28;
uint *local_20;
puVar1 = (uint *)param_1[1];
local_28 = (uint *)*param_2;
local_20 = (uint *)*param_1;
while (local_20 <= puVar1) {
*local_20 = (*local_28 ^ 0xffffffff) & *local_20;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
}
return;
}
|
|
64,748 |
init_available_charsets
|
eloqsql/mysys/charset.c
|
static void init_available_charsets(void)
{
char fname[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
struct charset_info_st **cs;
MY_CHARSET_LOADER loader;
DBUG_ENTER("init_available_charsets");
bzero((char*) &all_charsets,sizeof(all_charsets));
bzero((char*) &my_collation_statistics, sizeof(my_collation_statistics));
my_hash_init2(key_memory_charsets, &charset_name_hash, 16,
&my_charset_latin1, 64, 0, 0, get_charset_key,
0, 0, HASH_UNIQUE);
init_compiled_charsets(MYF(0));
/* Copy compiled charsets */
for (cs= (struct charset_info_st**) all_charsets;
cs < (struct charset_info_st**) all_charsets +
array_elements(all_charsets)-1 ;
cs++)
{
if (*cs)
{
DBUG_ASSERT(cs[0]->mbmaxlen <= MY_CS_MBMAXLEN);
if (cs[0]->m_ctype)
if (init_state_maps(*cs))
*cs= NULL;
}
}
my_charset_loader_init_mysys(&loader);
strmov(get_charsets_dir(fname), MY_CHARSET_INDEX);
my_read_charset_file(&loader, fname, MYF(0));
DBUG_VOID_RETURN;
}
|
O3
|
c
|
init_available_charsets:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x300, %rsp # imm = 0x300
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
leaq 0x33dfc3(%rip), %rbx # 0x3658d0
movl $0x4000, %edx # imm = 0x4000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x24160
leaq 0x34201d(%rip), %rdi # 0x369940
movl $0x4000, %edx # imm = 0x4000
xorl %esi, %esi
callq 0x24160
leaq 0x33dc96(%rip), %rax # 0x3655cc
movl (%rax), %edi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
leaq 0x10fc(%rip), %rax # 0x28a43
movq %rax, 0x8(%rsp)
movl $0x1, 0x20(%rsp)
movq $0x0, (%rsp)
leaq 0x341f6d(%rip), %rsi # 0x3698d0
leaq 0x2ecdf6(%rip), %rcx # 0x314760
movl $0x40, %r8d
movl $0x10, %edx
xorl %r9d, %r9d
callq 0x28da1
xorl %edi, %edi
callq 0x2bb08
movq $-0x8, %r14
movq 0x8(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x279ae
cmpq $0x0, 0x40(%rdi)
je 0x279ae
callq 0x2888e
testb %al, %al
je 0x279ae
movq $0x0, 0x8(%rbx,%r14)
addq $0x8, %r14
cmpq $0x3ff0, %r14 # imm = 0x3FF0
jb 0x2798b
leaq -0x2e0(%rbp), %rbx
movb $0x0, (%rbx)
leaq -0x8ae(%rip), %rax # 0x2711e
movq %rax, 0x80(%rbx)
leaq -0x8ad(%rip), %rax # 0x2712d
movq %rax, 0x88(%rbx)
leaq -0x8a0(%rip), %rax # 0x27148
movq %rax, 0x90(%rbx)
leaq -0x1f24(%rip), %rax # 0x25ad2
movq %rax, 0x98(%rbx)
leaq 0x2c6e24(%rip), %rax # 0x2ee828
movq (%rax), %rax
movq %rax, 0xa0(%rbx)
leaq -0x8af(%rip), %rax # 0x27166
movq %rax, 0xa8(%rbx)
leaq -0x230(%rbp), %r14
movq %r14, %rdi
callq 0x276ab
movabsq $0x6d782e7865646e49, %rcx # imm = 0x6D782E7865646E49
movq %rcx, (%rax)
movw $0x6c, 0x8(%rax)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x28a54
movq %fs:0x28, %rax
cmpq -0x18(%rbp), %rax
jne 0x27a66
addq $0x300, %rsp # imm = 0x300
popq %rbx
popq %r14
popq %rbp
retq
callq 0x24340
|
init_available_charsets:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 300h
mov rax, fs:28h
mov [rbp+var_18], rax
lea rbx, all_charsets
mov edx, 4000h
mov rdi, rbx
xor esi, esi
call _memset
lea rdi, my_collation_statistics
mov edx, 4000h
xor esi, esi
call _memset
lea rax, key_memory_charsets
mov edi, [rax]
xorps xmm0, xmm0
movups [rsp+310h+var_300], xmm0
lea rax, get_charset_key
mov [rsp+310h+var_308], rax
mov [rsp+310h+var_2F0], 1
mov [rsp+310h+var_310], 0
lea rsi, charset_name_hash
lea rcx, my_charset_latin1
mov r8d, 40h ; '@'
mov edx, 10h
xor r9d, r9d
call my_hash_init2
xor edi, edi
call init_compiled_charsets
mov r14, 0FFFFFFFFFFFFFFF8h
loc_2798B:
mov rdi, [rbx+r14+8]
test rdi, rdi
jz short loc_279AE
cmp qword ptr [rdi+40h], 0
jz short loc_279AE
call init_state_maps
test al, al
jz short loc_279AE
mov qword ptr [rbx+r14+8], 0
loc_279AE:
add r14, 8
cmp r14, 3FF0h
jb short loc_2798B
lea rbx, [rbp+var_2E0]
mov byte ptr [rbx], 0
lea rax, my_once_alloc_c
mov [rbx+80h], rax
lea rax, my_malloc_c
mov [rbx+88h], rax
lea rax, my_realloc_c
mov [rbx+90h], rax
lea rax, my_free
mov [rbx+98h], rax
lea rax, my_charset_error_reporter
mov rax, [rax]
mov [rbx+0A0h], rax
lea rax, add_collation
mov [rbx+0A8h], rax
lea r14, [rbp+var_230]
mov rdi, r14
call get_charsets_dir
mov rcx, 6D782E7865646E49h
mov [rax], rcx
mov word ptr [rax+8], 6Ch ; 'l'
mov rdi, rbx
mov rsi, r14
xor edx, edx
call my_read_charset_file
mov rax, fs:28h
cmp rax, [rbp+var_18]
jnz short loc_27A66
add rsp, 300h
pop rbx
pop r14
pop rbp
retn
loc_27A66:
call ___stack_chk_fail
|
unsigned long long init_available_charsets()
{
unsigned long long v0; // r14
long long v1; // rdi
_BYTE v3[128]; // [rsp+30h] [rbp-2E0h] BYREF
long long ( *v4)(long long); // [rsp+B0h] [rbp-260h]
long long ( *v5)(unsigned long long); // [rsp+B8h] [rbp-258h]
long long ( *v6)(long long, unsigned long long); // [rsp+C0h] [rbp-250h]
long long ( *v7)(long long); // [rsp+C8h] [rbp-248h]
long long ( *v8)(); // [rsp+D0h] [rbp-240h]
long long ( *v9)(unsigned int *); // [rsp+D8h] [rbp-238h]
_BYTE v10[536]; // [rsp+E0h] [rbp-230h] BYREF
unsigned long long v11; // [rsp+2F8h] [rbp-18h]
v11 = __readfsqword(0x28u);
memset(all_charsets, 0LL, sizeof(all_charsets));
memset(my_collation_statistics, 0LL, sizeof(my_collation_statistics));
my_hash_init2(
key_memory_charsets,
(unsigned int)&charset_name_hash,
16,
(unsigned int)&my_charset_latin1,
64,
0,
0LL,
(long long)get_charset_key,
0LL,
0LL,
1);
init_compiled_charsets(0LL);
v0 = 0x1FFFFFFFFFFFFFFFLL;
do
{
v1 = all_charsets[v0 + 1];
if ( v1 && *(_QWORD *)(v1 + 64) && (unsigned __int8)init_state_maps(v1) )
all_charsets[v0 + 1] = 0LL;
++v0;
}
while ( v0 < 2046 );
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;
strcpy((char *)get_charsets_dir((long long)v10), "Index.xml");
my_read_charset_file(v3, v10, 0LL);
return __readfsqword(0x28u);
}
|
init_available_charsets:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x300
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
LEA RBX,[0x4658d0]
MOV EDX,0x4000
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00124160
LEA RDI,[0x469940]
MOV EDX,0x4000
XOR ESI,ESI
CALL 0x00124160
LEA RAX,[0x4655cc]
MOV EDI,dword ptr [RAX]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x10],XMM0
LEA RAX,[0x128a43]
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RSP + 0x20],0x1
MOV qword ptr [RSP],0x0
LEA RSI,[0x4698d0]
LEA RCX,[0x414760]
MOV R8D,0x40
MOV EDX,0x10
XOR R9D,R9D
CALL 0x00128da1
XOR EDI,EDI
CALL 0x0012bb08
MOV R14,-0x8
LAB_0012798b:
MOV RDI,qword ptr [RBX + R14*0x1 + 0x8]
TEST RDI,RDI
JZ 0x001279ae
CMP qword ptr [RDI + 0x40],0x0
JZ 0x001279ae
CALL 0x0012888e
TEST AL,AL
JZ 0x001279ae
MOV qword ptr [RBX + R14*0x1 + 0x8],0x0
LAB_001279ae:
ADD R14,0x8
CMP R14,0x3ff0
JC 0x0012798b
LEA RBX,[RBP + -0x2e0]
MOV byte ptr [RBX],0x0
LEA RAX,[0x12711e]
MOV qword ptr [RBX + 0x80],RAX
LEA RAX,[0x12712d]
MOV qword ptr [RBX + 0x88],RAX
LEA RAX,[0x127148]
MOV qword ptr [RBX + 0x90],RAX
LEA RAX,[0x125ad2]
MOV qword ptr [RBX + 0x98],RAX
LEA RAX,[0x3ee828]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBX + 0xa0],RAX
LEA RAX,[0x127166]
MOV qword ptr [RBX + 0xa8],RAX
LEA R14,[RBP + -0x230]
MOV RDI,R14
CALL 0x001276ab
MOV RCX,0x6d782e7865646e49
MOV qword ptr [RAX],RCX
MOV word ptr [RAX + 0x8],0x6c
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00128a54
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x00127a66
ADD RSP,0x300
POP RBX
POP R14
POP RBP
RET
LAB_00127a66:
CALL 0x00124340
|
void init_available_charsets(void)
{
char cVar1;
int8 *puVar2;
ulong uVar3;
long in_FS_OFFSET;
int1 local_2e8 [128];
code *local_268;
code *local_260;
code *local_258;
code *local_250;
int *local_248;
code *local_240;
int1 local_238 [536];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
memset(&all_charsets,0,0x4000);
memset(my_collation_statistics,0,0x4000);
my_hash_init2(key_memory_charsets,charset_name_hash,0x10,&my_charset_latin1,0x40,0,0,
get_charset_key,0,0,1);
init_compiled_charsets(0);
uVar3 = 0xfffffffffffffff8;
do {
if ((*(long *)((long)&DAT_004658d8 + uVar3) != 0) &&
(*(long *)(*(long *)((long)&DAT_004658d8 + uVar3) + 0x40) != 0)) {
cVar1 = init_state_maps();
if (cVar1 != '\0') {
*(int8 *)((long)&DAT_004658d8 + uVar3) = 0;
}
}
uVar3 = uVar3 + 8;
} while (uVar3 < 0x3ff0);
local_2e8[0] = 0;
local_268 = my_once_alloc_c;
local_260 = my_malloc_c;
local_258 = my_realloc_c;
local_250 = my_free;
local_248 = my_charset_error_reporter;
local_240 = add_collation;
puVar2 = (int8 *)get_charsets_dir(local_238);
*puVar2 = 0x6d782e7865646e49;
*(int2 *)(puVar2 + 1) = 0x6c;
my_read_charset_file(local_2e8,local_238,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
64,749 |
ma_fcvt
|
eloqsql/libmariadb/libmariadb/ma_dtoa.c
|
size_t ma_fcvt(double x, int precision, char *to, my_bool *error)
{
int decpt, sign, len, i;
char *res, *src, *end, *dst= to;
char buf[DTOA_BUFF_SIZE];
DBUG_ASSERT(precision >= 0 && precision < NOT_FIXED_DEC && to != NULL);
res= dtoa(x, 5, precision, &decpt, &sign, &end, buf, sizeof(buf));
if (decpt == DTOA_OVERFLOW)
{
dtoa_free(res, buf, sizeof(buf));
*to++= '0';
*to= '\0';
if (error != NULL)
*error= TRUE;
return 1;
}
src= res;
len= (int)(end - src);
if (sign)
*dst++= '-';
if (decpt <= 0)
{
*dst++= '0';
*dst++= '.';
for (i= decpt; i < 0; i++)
*dst++= '0';
}
for (i= 1; i <= len; i++)
{
*dst++= *src++;
if (i == decpt && i < len)
*dst++= '.';
}
while (i++ <= decpt)
*dst++= '0';
if (precision > 0)
{
if (len <= decpt)
*dst++= '.';
for (i= precision - MAX(0, (len - decpt)); i > 0; i--)
*dst++= '0';
}
*dst= '\0';
if (error != NULL)
*error= FALSE;
dtoa_free(res, buf, sizeof(buf));
return dst - to;
}
|
O3
|
c
|
ma_fcvt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe98, %rsp # imm = 0xE98
movq %rdx, -0xea8(%rbp)
movq %rsi, %r14
movl %edi, %esi
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0xe94(%rbp), %r13
leaq -0xe9c(%rbp), %rcx
leaq -0xec0(%rbp), %r8
leaq -0xe90(%rbp), %rbx
movl $0x5, %edi
movl %esi, -0xe98(%rbp)
movq %r13, %rdx
movq %rbx, %r9
callq 0x28072
movq %rax, %r15
movl (%r13), %r12d
cmpl $0x270f, %r12d # imm = 0x270F
jne 0x27edf
cmpq %rbx, %r15
setae %al
leaq -0x30(%rbp), %rcx
cmpq %r15, %rcx
seta %cl
testb %cl, %al
jne 0x27ebb
movq %r15, %rdi
callq 0x13570
movw $0x30, (%r14)
movl $0x1, %r13d
movq -0xea8(%rbp), %rax
testq %rax, %rax
je 0x28049
movb $0x1, (%rax)
jmp 0x28049
movq -0xec0(%rbp), %rbx
movq %r14, %rax
movl %ebx, %r14d
cmpl $0x0, -0xe9c(%rbp)
movq %rax, %r13
je 0x27eff
leaq 0x1(%rax), %r13
movb $0x2d, (%rax)
movq %rax, -0xeb8(%rbp)
subl %r15d, %r14d
testl %r12d, %r12d
movl -0xe98(%rbp), %r8d
jg 0x27f59
movw $0x2e30, (%r13) # imm = 0x2E30
leaq 0x2(%r13), %rdi
testl %r12d, %r12d
js 0x27f2a
movq %rdi, %r13
jmp 0x27f59
movl %r12d, %eax
notl %eax
movq %rax, -0xeb0(%rbp)
leaq 0x1(%rax), %rdx
movl $0x30, %esi
callq 0x13260
movl -0xe98(%rbp), %r8d
movq -0xeb0(%rbp), %rax
addq %rax, %r13
addq $0x3, %r13
testl %r14d, %r14d
jle 0x27fa0
subl %r15d, %ebx
incl %ebx
movl %r14d, %eax
xorl %ecx, %ecx
movq %r13, %rdx
leal 0x1(%rcx), %esi
movb (%r15,%rcx), %dil
incq %r13
movb %dil, (%rdx)
cmpl -0xe94(%rbp), %esi
jne 0x27f90
cmpl %r14d, %esi
jge 0x27f90
movb $0x2e, 0x1(%rdx)
addq $0x2, %rdx
movq %rdx, %r13
incq %rcx
cmpl %ecx, %eax
jne 0x27f68
movl -0xe94(%rbp), %r12d
jmp 0x27fa5
movl $0x1, %ebx
cmpl %r12d, %ebx
jg 0x27fc2
decl %ebx
movb $0x30, (%r13)
incq %r13
movl -0xe94(%rbp), %r12d
incl %ebx
cmpl %r12d, %ebx
jl 0x27fac
testl %r8d, %r8d
jle 0x28008
cmpl %r14d, %r12d
jl 0x27fdb
movb $0x2e, (%r13)
incq %r13
movl -0xe94(%rbp), %r12d
subl %r12d, %r14d
cmpl %r8d, %r14d
jge 0x28008
xorl %ebx, %ebx
testl %r14d, %r14d
cmovgl %r14d, %ebx
notl %ebx
addl %r8d, %ebx
leaq 0x1(%rbx), %rdx
movq %r13, %rdi
movl $0x30, %esi
callq 0x13260
addq %rbx, %r13
incq %r13
movb $0x0, (%r13)
movq -0xea8(%rbp), %rax
testq %rax, %rax
movq -0xeb8(%rbp), %rbx
je 0x28023
movb $0x0, (%rax)
leaq -0xe90(%rbp), %rax
cmpq %rax, %r15
setae %al
leaq -0x30(%rbp), %rcx
cmpq %r15, %rcx
seta %cl
testb %cl, %al
jne 0x28046
movq %r15, %rdi
callq 0x13570
subq %rbx, %r13
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x2806d
movq %r13, %rax
addq $0xe98, %rsp # imm = 0xE98
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
|
ma_fcvt:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E98h
mov [rbp+var_EA8], rdx
mov r14, rsi
mov esi, edi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r13, [rbp+var_E94]
lea rcx, [rbp+var_E9C]
lea r8, [rbp+var_EC0]
lea rbx, [rbp+var_E90]
mov edi, 5
mov [rbp+var_E98], esi
mov rdx, r13
mov r9, rbx
call dtoa
mov r15, rax
mov r12d, [r13+0]
cmp r12d, 270Fh
jnz short loc_27EDF
cmp r15, rbx
setnb al
lea rcx, [rbp+var_30]
cmp rcx, r15
setnbe cl
test al, cl
jnz short loc_27EBB
mov rdi, r15
call _free
loc_27EBB:
mov word ptr [r14], 30h ; '0'
mov r13d, 1
mov rax, [rbp+var_EA8]
test rax, rax
jz loc_28049
mov byte ptr [rax], 1
jmp loc_28049
loc_27EDF:
mov rbx, [rbp+var_EC0]
mov rax, r14
mov r14d, ebx
cmp [rbp+var_E9C], 0
mov r13, rax
jz short loc_27EFF
lea r13, [rax+1]
mov byte ptr [rax], 2Dh ; '-'
loc_27EFF:
mov [rbp+var_EB8], rax
sub r14d, r15d
test r12d, r12d
mov r8d, [rbp+var_E98]
jg short loc_27F59
mov word ptr [r13+0], 2E30h
lea rdi, [r13+2]
test r12d, r12d
js short loc_27F2A
mov r13, rdi
jmp short loc_27F59
loc_27F2A:
mov eax, r12d
not eax
mov [rbp+var_EB0], rax
lea rdx, [rax+1]
mov esi, 30h ; '0'
call _memset
mov r8d, [rbp+var_E98]
mov rax, [rbp+var_EB0]
add r13, rax
add r13, 3
loc_27F59:
test r14d, r14d
jle short loc_27FA0
sub ebx, r15d
inc ebx
mov eax, r14d
xor ecx, ecx
loc_27F68:
mov rdx, r13
lea esi, [rcx+1]
mov dil, [r15+rcx]
inc r13
mov [rdx], dil
cmp esi, [rbp+var_E94]
jnz short loc_27F90
cmp esi, r14d
jge short loc_27F90
mov byte ptr [rdx+1], 2Eh ; '.'
add rdx, 2
mov r13, rdx
loc_27F90:
inc rcx
cmp eax, ecx
jnz short loc_27F68
mov r12d, [rbp+var_E94]
jmp short loc_27FA5
loc_27FA0:
mov ebx, 1
loc_27FA5:
cmp ebx, r12d
jg short loc_27FC2
dec ebx
loc_27FAC:
mov byte ptr [r13+0], 30h ; '0'
inc r13
mov r12d, [rbp+var_E94]
inc ebx
cmp ebx, r12d
jl short loc_27FAC
loc_27FC2:
test r8d, r8d
jle short loc_28008
cmp r12d, r14d
jl short loc_27FDB
mov byte ptr [r13+0], 2Eh ; '.'
inc r13
mov r12d, [rbp+var_E94]
loc_27FDB:
sub r14d, r12d
cmp r14d, r8d
jge short loc_28008
xor ebx, ebx
test r14d, r14d
cmovg ebx, r14d
not ebx
add ebx, r8d
lea rdx, [rbx+1]
mov rdi, r13
mov esi, 30h ; '0'
call _memset
add r13, rbx
inc r13
loc_28008:
mov byte ptr [r13+0], 0
mov rax, [rbp+var_EA8]
test rax, rax
mov rbx, [rbp+var_EB8]
jz short loc_28023
mov byte ptr [rax], 0
loc_28023:
lea rax, [rbp+var_E90]
cmp r15, rax
setnb al
lea rcx, [rbp+var_30]
cmp rcx, r15
setnbe cl
test al, cl
jnz short loc_28046
mov rdi, r15
call _free
loc_28046:
sub r13, rbx
loc_28049:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_2806D
mov rax, r13
add rsp, 0E98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2806D:
call ___stack_chk_fail
|
_BYTE * ma_fcvt(unsigned int a1, _WORD *a2, _BYTE *a3)
{
unsigned long long v3; // r15
int v4; // r12d
long long v5; // r13
int v6; // ebx
int v7; // r14d
_BYTE *v8; // r13
int v9; // r14d
int v10; // r8d
int v11; // ebx
long long v12; // rcx
_BYTE *v13; // rdx
int v14; // ebx
int v15; // r14d
int v16; // ebx
long long v17; // rbx
_WORD *v18; // rbx
long long v20; // [rsp+0h] [rbp-EC0h] BYREF
_WORD *v21; // [rsp+8h] [rbp-EB8h]
long long v22; // [rsp+10h] [rbp-EB0h]
_BYTE *v23; // [rsp+18h] [rbp-EA8h]
int v24; // [rsp+24h] [rbp-E9Ch] BYREF
int v25; // [rsp+28h] [rbp-E98h]
int v26; // [rsp+2Ch] [rbp-E94h] BYREF
_BYTE v27[3680]; // [rsp+30h] [rbp-E90h] BYREF
_QWORD v28[6]; // [rsp+E90h] [rbp-30h] BYREF
v23 = a3;
v28[0] = __readfsqword(0x28u);
v25 = a1;
v3 = dtoa(5LL, a1, &v26, &v24, &v20, v27);
v4 = v26;
if ( v26 == 9999 )
{
if ( (unsigned long long)v28 <= v3 || v3 < (unsigned long long)v27 )
free(v3);
*a2 = 48;
v5 = 1LL;
if ( v23 )
*v23 = 1;
}
else
{
v6 = v20;
v7 = v20;
v8 = a2;
if ( v24 )
{
v8 = (char *)a2 + 1;
*(_BYTE *)a2 = 45;
}
v21 = a2;
v9 = v7 - v3;
v10 = v25;
if ( v4 <= 0 )
{
*(_WORD *)v8 = 11824;
if ( v4 < 0 )
{
v22 = (unsigned int)~v4;
memset(v8 + 2, 48LL, v22 + 1);
v10 = v25;
v8 += v22 + 3;
}
else
{
v8 += 2;
}
}
if ( v9 <= 0 )
{
v11 = 1;
}
else
{
v11 = v6 - v3 + 1;
v12 = 0LL;
do
{
v13 = v8++;
*v13 = *(_BYTE *)(v3 + v12);
if ( (_DWORD)v12 + 1 == v26 && (int)v12 + 1 < v9 )
{
v13[1] = 46;
v8 = v13 + 2;
}
++v12;
}
while ( v9 != (_DWORD)v12 );
v4 = v26;
}
if ( v11 <= v4 )
{
v14 = v11 - 1;
do
{
*v8++ = 48;
v4 = v26;
++v14;
}
while ( v14 < v26 );
}
if ( v10 > 0 )
{
if ( v4 >= v9 )
{
*v8++ = 46;
v4 = v26;
}
v15 = v9 - v4;
if ( v15 < v10 )
{
v16 = 0;
if ( v15 > 0 )
v16 = v15;
v17 = (unsigned int)(v10 + ~v16);
memset(v8, 48LL, v17 + 1);
v8 += v17 + 1;
}
}
*v8 = 0;
v18 = v21;
if ( v23 )
*v23 = 0;
if ( (unsigned long long)v28 <= v3 || v3 < (unsigned long long)v27 )
free(v3);
return (_BYTE *)(v8 - (_BYTE *)v18);
}
return (_BYTE *)v5;
}
|
ma_fcvt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe98
MOV qword ptr [RBP + -0xea8],RDX
MOV R14,RSI
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R13,[RBP + -0xe94]
LEA RCX,[RBP + -0xe9c]
LEA R8,[RBP + -0xec0]
LEA RBX,[RBP + -0xe90]
MOV EDI,0x5
MOV dword ptr [RBP + -0xe98],ESI
MOV RDX,R13
MOV R9,RBX
CALL 0x00128072
MOV R15,RAX
MOV R12D,dword ptr [R13]
CMP R12D,0x270f
JNZ 0x00127edf
CMP R15,RBX
SETNC AL
LEA RCX,[RBP + -0x30]
CMP RCX,R15
SETA CL
TEST AL,CL
JNZ 0x00127ebb
MOV RDI,R15
CALL 0x00113570
LAB_00127ebb:
MOV word ptr [R14],0x30
MOV R13D,0x1
MOV RAX,qword ptr [RBP + -0xea8]
TEST RAX,RAX
JZ 0x00128049
MOV byte ptr [RAX],0x1
JMP 0x00128049
LAB_00127edf:
MOV RBX,qword ptr [RBP + -0xec0]
MOV RAX,R14
MOV R14D,EBX
CMP dword ptr [RBP + -0xe9c],0x0
MOV R13,RAX
JZ 0x00127eff
LEA R13,[RAX + 0x1]
MOV byte ptr [RAX],0x2d
LAB_00127eff:
MOV qword ptr [RBP + -0xeb8],RAX
SUB R14D,R15D
TEST R12D,R12D
MOV R8D,dword ptr [RBP + -0xe98]
JG 0x00127f59
MOV word ptr [R13],0x2e30
LEA RDI,[R13 + 0x2]
TEST R12D,R12D
JS 0x00127f2a
MOV R13,RDI
JMP 0x00127f59
LAB_00127f2a:
MOV EAX,R12D
NOT EAX
MOV qword ptr [RBP + -0xeb0],RAX
LEA RDX,[RAX + 0x1]
MOV ESI,0x30
CALL 0x00113260
MOV R8D,dword ptr [RBP + -0xe98]
MOV RAX,qword ptr [RBP + -0xeb0]
ADD R13,RAX
ADD R13,0x3
LAB_00127f59:
TEST R14D,R14D
JLE 0x00127fa0
SUB EBX,R15D
INC EBX
MOV EAX,R14D
XOR ECX,ECX
LAB_00127f68:
MOV RDX,R13
LEA ESI,[RCX + 0x1]
MOV DIL,byte ptr [R15 + RCX*0x1]
INC R13
MOV byte ptr [RDX],DIL
CMP ESI,dword ptr [RBP + -0xe94]
JNZ 0x00127f90
CMP ESI,R14D
JGE 0x00127f90
MOV byte ptr [RDX + 0x1],0x2e
ADD RDX,0x2
MOV R13,RDX
LAB_00127f90:
INC RCX
CMP EAX,ECX
JNZ 0x00127f68
MOV R12D,dword ptr [RBP + -0xe94]
JMP 0x00127fa5
LAB_00127fa0:
MOV EBX,0x1
LAB_00127fa5:
CMP EBX,R12D
JG 0x00127fc2
DEC EBX
LAB_00127fac:
MOV byte ptr [R13],0x30
INC R13
MOV R12D,dword ptr [RBP + -0xe94]
INC EBX
CMP EBX,R12D
JL 0x00127fac
LAB_00127fc2:
TEST R8D,R8D
JLE 0x00128008
CMP R12D,R14D
JL 0x00127fdb
MOV byte ptr [R13],0x2e
INC R13
MOV R12D,dword ptr [RBP + -0xe94]
LAB_00127fdb:
SUB R14D,R12D
CMP R14D,R8D
JGE 0x00128008
XOR EBX,EBX
TEST R14D,R14D
CMOVG EBX,R14D
NOT EBX
ADD EBX,R8D
LEA RDX,[RBX + 0x1]
MOV RDI,R13
MOV ESI,0x30
CALL 0x00113260
ADD R13,RBX
INC R13
LAB_00128008:
MOV byte ptr [R13],0x0
MOV RAX,qword ptr [RBP + -0xea8]
TEST RAX,RAX
MOV RBX,qword ptr [RBP + -0xeb8]
JZ 0x00128023
MOV byte ptr [RAX],0x0
LAB_00128023:
LEA RAX,[RBP + -0xe90]
CMP R15,RAX
SETNC AL
LEA RCX,[RBP + -0x30]
CMP RCX,R15
SETA CL
TEST AL,CL
JNZ 0x00128046
MOV RDI,R15
CALL 0x00113570
LAB_00128046:
SUB R13,RBX
LAB_00128049:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0012806d
MOV RAX,R13
ADD RSP,0xe98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012806d:
CALL 0x00113500
|
long ma_fcvt(int param_1,int2 *param_2,int1 *param_3)
{
long *__ptr;
int iVar1;
uint uVar2;
uint uVar3;
long lVar4;
int2 *puVar5;
int2 *__s;
int iVar6;
long in_FS_OFFSET;
int local_ec8 [2];
int2 *local_ec0;
ulong local_eb8;
int1 *local_eb0;
int local_ea4;
int local_ea0;
uint local_e9c;
long local_e98 [460];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_eb0 = param_3;
local_ea0 = param_1;
__ptr = (long *)dtoa(5,param_1,&local_e9c,&local_ea4,local_ec8,local_e98);
uVar3 = local_e9c;
if (local_e9c == 9999) {
if (__ptr < local_e98 || &local_38 <= __ptr) {
free(__ptr);
}
*param_2 = 0x30;
lVar4 = 1;
if (local_eb0 != (int1 *)0x0) {
*local_eb0 = 1;
}
}
else {
puVar5 = param_2;
if (local_ea4 != 0) {
puVar5 = (int2 *)((long)param_2 + 1);
*(int1 *)param_2 = 0x2d;
}
iVar6 = local_ec8[0] - (int)__ptr;
__s = puVar5;
local_ec0 = param_2;
if ((int)local_e9c < 1) {
*puVar5 = 0x2e30;
__s = puVar5 + 1;
if ((int)local_e9c < 0) {
local_eb8 = (ulong)~local_e9c;
memset(__s,0x30,local_eb8 + 1);
__s = (int2 *)((long)puVar5 + local_eb8 + 3);
}
}
if (iVar6 < 1) {
iVar1 = 1;
}
else {
iVar1 = (local_ec8[0] - (int)__ptr) + 1;
lVar4 = 0;
puVar5 = __s;
do {
uVar3 = (int)lVar4 + 1;
__s = (int2 *)((long)puVar5 + 1);
*(int1 *)puVar5 = *(int1 *)((long)__ptr + lVar4);
if ((uVar3 == local_e9c) && ((int)uVar3 < iVar6)) {
*(int1 *)((long)puVar5 + 1) = 0x2e;
__s = puVar5 + 1;
}
lVar4 = lVar4 + 1;
puVar5 = __s;
uVar3 = local_e9c;
} while (iVar6 != (int)lVar4);
}
if (iVar1 <= (int)uVar3) {
iVar1 = iVar1 + -1;
do {
*(int1 *)__s = 0x30;
__s = (int2 *)((long)__s + 1);
iVar1 = iVar1 + 1;
uVar3 = local_e9c;
} while (iVar1 < (int)local_e9c);
}
if (0 < local_ea0) {
if (iVar6 <= (int)uVar3) {
*(int1 *)__s = 0x2e;
__s = (int2 *)((long)__s + 1);
uVar3 = local_e9c;
}
uVar3 = iVar6 - uVar3;
if ((int)uVar3 < local_ea0) {
uVar2 = 0;
if (0 < (int)uVar3) {
uVar2 = uVar3;
}
uVar3 = ~uVar2 + local_ea0;
memset(__s,0x30,(ulong)uVar3 + 1);
__s = (int2 *)((long)__s + (ulong)uVar3 + 1);
}
}
puVar5 = local_ec0;
*(int1 *)__s = 0;
if (local_eb0 != (int1 *)0x0) {
*local_eb0 = 0;
}
if (__ptr < local_e98 || &local_38 <= __ptr) {
free(__ptr);
}
lVar4 = (long)__s - (long)puVar5;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar4;
}
|
|
64,750 |
google::protobuf::ServiceDescriptorProto::MergeImpl(google::protobuf::Message&, google::protobuf::Message const&)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc
|
void ServiceDescriptorProto::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
auto* const _this = static_cast<ServiceDescriptorProto*>(&to_msg);
auto& from = static_cast<const ServiceDescriptorProto&>(from_msg);
// @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.ServiceDescriptorProto)
GOOGLE_DCHECK_NE(&from, _this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
_this->_impl_.method_.MergeFrom(from._impl_.method_);
cached_has_bits = from._impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
_this->_internal_set_name(from._internal_name());
}
if (cached_has_bits & 0x00000002u) {
_this->_internal_mutable_options()->::PROTOBUF_NAMESPACE_ID::ServiceOptions::MergeFrom(
from._internal_options());
}
}
_this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}
|
O3
|
cpp
|
google::protobuf::ServiceDescriptorProto::MergeImpl(google::protobuf::Message&, google::protobuf::Message const&):
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x20(%rsi)
je 0xf173e
leaq 0x18(%r14), %rsi
leaq 0x18(%rbx), %rdi
leaq 0xa1d9(%rip), %rdx # 0xfb910
xorl %ecx, %ecx
callq 0x74546
movl 0x10(%r14), %ebp
testb $0x3, %bpl
je 0xf17b7
testb $0x1, %bpl
je 0xf1772
movq 0x30(%r14), %rsi
andq $-0x4, %rsi
orl $0x1, 0x10(%rbx)
leaq 0x30(%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
andq $-0x4, %rdx
testb $0x1, %al
jne 0xf17de
callq 0x786ce
testb $0x2, %bpl
je 0xf17b7
orb $0x2, 0x10(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
jne 0xf17a0
movq 0x8(%rbx), %rax
movq %rax, %rdi
andq $-0x4, %rdi
testb $0x1, %al
jne 0xf17e3
callq 0xfa9b2
movq %rax, %rdi
movq %rax, 0x38(%rbx)
movq 0x38(%r14), %rax
testq %rax, %rax
leaq 0x12097a(%rip), %rsi # 0x212128
cmovneq %rax, %rsi
callq 0xf6a14
movq 0x8(%r14), %rsi
testb $0x1, %sil
jne 0xf17c6
popq %rbx
popq %r14
popq %rbp
retq
addq $0x8, %rbx
andq $-0x4, %rsi
addq $0x8, %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x734be
movq (%rdx), %rdx
jmp 0xf176d
movq (%rdi), %rdi
jmp 0xf1794
|
_ZN6google8protobuf22ServiceDescriptorProto9MergeImplERNS0_7MessageERKS2_:
push rbp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
cmp dword ptr [rsi+20h], 0
jz short loc_F173E
lea rsi, [r14+18h]
lea rdi, [rbx+18h]
lea rdx, _ZN6google8protobuf8internal20RepeatedPtrFieldBase18MergeFromInnerLoopINS0_16RepeatedPtrFieldINS0_21MethodDescriptorProtoEE11TypeHandlerEEEvPPvS9_ii; google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<google::protobuf::MethodDescriptorProto>::TypeHandler>(void **,void **,int,int)
xor ecx, ecx
call _ZN6google8protobuf8internal20RepeatedPtrFieldBase17MergeFromInternalERKS2_MS2_FvPPvS6_iiE; google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInternal(google::protobuf::internal::RepeatedPtrFieldBase const&,void (google::protobuf::internal::RepeatedPtrFieldBase::*)(void **,void **,int,int))
loc_F173E:
mov ebp, [r14+10h]
test bpl, 3
jz short loc_F17B7
test bpl, 1
jz short loc_F1772
mov rsi, [r14+30h]
and rsi, 0FFFFFFFFFFFFFFFCh
or dword ptr [rbx+10h], 1
lea rdi, [rbx+30h]
mov rax, [rbx+8]
mov rdx, rax
and rdx, 0FFFFFFFFFFFFFFFCh
test al, 1
jnz short loc_F17DE
loc_F176D:
call _ZN6google8protobuf8internal14ArenaStringPtr3SetERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPNS0_5ArenaE; google::protobuf::internal::ArenaStringPtr::Set(std::string const&,google::protobuf::Arena *)
loc_F1772:
test bpl, 2
jz short loc_F17B7
or byte ptr [rbx+10h], 2
mov rdi, [rbx+38h]
test rdi, rdi
jnz short loc_F17A0
mov rax, [rbx+8]
mov rdi, rax
and rdi, 0FFFFFFFFFFFFFFFCh
test al, 1
jnz short loc_F17E3
loc_F1794:
call _ZN6google8protobuf5Arena18CreateMaybeMessageINS0_14ServiceOptionsEJEEEPT_PS1_DpOT0_; google::protobuf::Arena::CreateMaybeMessage<google::protobuf::ServiceOptions>(google::protobuf::Arena*)
mov rdi, rax; this
mov [rbx+38h], rax
loc_F17A0:
mov rax, [r14+38h]
test rax, rax
lea rsi, _ZN6google8protobuf33_ServiceOptions_default_instance_E; google::protobuf::_ServiceOptions_default_instance_
cmovnz rsi, rax; google::protobuf::Message *
call _ZN6google8protobuf14ServiceOptions9MergeImplERNS0_7MessageERKS2_; google::protobuf::ServiceOptions::MergeImpl(google::protobuf::Message &,google::protobuf::Message const&)
loc_F17B7:
mov rsi, [r14+8]
test sil, 1
jnz short loc_F17C6
pop rbx
pop r14
pop rbp
retn
loc_F17C6:
add rbx, 8
and rsi, 0FFFFFFFFFFFFFFFCh
add rsi, 8
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _ZN6google8protobuf8internal16InternalMetadata11DoMergeFromINS0_15UnknownFieldSetEEEvRKT_; google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(google::protobuf::UnknownFieldSet const&)
loc_F17DE:
mov rdx, [rdx]
jmp short loc_F176D
loc_F17E3:
mov rdi, [rdi]
jmp short loc_F1794
|
void google::protobuf::ServiceDescriptorProto::MergeImpl(
google::protobuf::ServiceDescriptorProto *this,
google::protobuf::Message *a2,
const google::protobuf::Message *a3)
{
int v5; // ebp
unsigned long long v6; // rsi
google::protobuf::Arena *v7; // rdx
google::protobuf::ServiceOptions *v8; // rdi
_QWORD *v9; // rdi
google::protobuf::Message *v10; // rsi
long long v11; // rsi
if ( *((_DWORD *)a2 + 8) )
google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInternal(
(long long)this + 24,
(long long)a2 + 24,
(char *)google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<google::protobuf::MethodDescriptorProto>::TypeHandler>,
0LL);
v5 = *((_DWORD *)a2 + 4);
if ( (v5 & 3) != 0 )
{
if ( (v5 & 1) != 0 )
{
v6 = *((_QWORD *)a2 + 6) & 0xFFFFFFFFFFFFFFFCLL;
*((_DWORD *)this + 4) |= 1u;
v7 = (google::protobuf::Arena *)(*((_QWORD *)this + 1) & 0xFFFFFFFFFFFFFFFCLL);
if ( (*((_QWORD *)this + 1) & 1) != 0 )
v7 = *(google::protobuf::Arena **)v7;
google::protobuf::internal::ArenaStringPtr::Set((long long *)this + 6, v6, v7);
}
if ( (v5 & 2) != 0 )
{
*((_BYTE *)this + 16) |= 2u;
v8 = (google::protobuf::ServiceOptions *)*((_QWORD *)this + 7);
if ( !v8 )
{
v9 = (_QWORD *)(*((_QWORD *)this + 1) & 0xFFFFFFFFFFFFFFFCLL);
if ( (*((_QWORD *)this + 1) & 1) != 0 )
v9 = (_QWORD *)*v9;
v8 = (google::protobuf::ServiceOptions *)google::protobuf::Arena::CreateMaybeMessage<google::protobuf::ServiceOptions>(v9);
*((_QWORD *)this + 7) = v8;
}
v10 = (google::protobuf::Message *)&google::protobuf::_ServiceOptions_default_instance_;
if ( *((_QWORD *)a2 + 7) )
v10 = (google::protobuf::Message *)*((_QWORD *)a2 + 7);
google::protobuf::ServiceOptions::MergeImpl(v8, v10, a3);
}
}
v11 = *((_QWORD *)a2 + 1);
if ( (v11 & 1) != 0 )
google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(
(long long *)this + 1,
(const google::protobuf::UnknownFieldSet *)((v11 & 0xFFFFFFFFFFFFFFFCLL) + 8));
}
|
MergeImpl:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
CMP dword ptr [RSI + 0x20],0x0
JZ 0x001f173e
LEA RSI,[R14 + 0x18]
LEA RDI,[RBX + 0x18]
LEA RDX,[0x1fb910]
XOR ECX,ECX
CALL 0x00174546
LAB_001f173e:
MOV EBP,dword ptr [R14 + 0x10]
TEST BPL,0x3
JZ 0x001f17b7
TEST BPL,0x1
JZ 0x001f1772
MOV RSI,qword ptr [R14 + 0x30]
AND RSI,-0x4
OR dword ptr [RBX + 0x10],0x1
LEA RDI,[RBX + 0x30]
MOV RAX,qword ptr [RBX + 0x8]
MOV RDX,RAX
AND RDX,-0x4
TEST AL,0x1
JNZ 0x001f17de
LAB_001f176d:
CALL 0x001786ce
LAB_001f1772:
TEST BPL,0x2
JZ 0x001f17b7
OR byte ptr [RBX + 0x10],0x2
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JNZ 0x001f17a0
MOV RAX,qword ptr [RBX + 0x8]
MOV RDI,RAX
AND RDI,-0x4
TEST AL,0x1
JNZ 0x001f17e3
LAB_001f1794:
CALL 0x001fa9b2
MOV RDI,RAX
MOV qword ptr [RBX + 0x38],RAX
LAB_001f17a0:
MOV RAX,qword ptr [R14 + 0x38]
TEST RAX,RAX
LEA RSI,[0x312128]
CMOVNZ RSI,RAX
CALL 0x001f6a14
LAB_001f17b7:
MOV RSI,qword ptr [R14 + 0x8]
TEST SIL,0x1
JNZ 0x001f17c6
POP RBX
POP R14
POP RBP
RET
LAB_001f17c6:
ADD RBX,0x8
AND RSI,-0x4
ADD RSI,0x8
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x001734be
LAB_001f17de:
MOV RDX,qword ptr [RDX]
JMP 0x001f176d
LAB_001f17e3:
MOV RDI,qword ptr [RDI]
JMP 0x001f1794
|
/* google::protobuf::ServiceDescriptorProto::MergeImpl(google::protobuf::Message&,
google::protobuf::Message const&) */
void google::protobuf::ServiceDescriptorProto::MergeImpl(Message *param_1,Message *param_2)
{
uint uVar1;
ulong uVar2;
Message *pMVar3;
Arena *pAVar4;
Message *pMVar5;
if (*(int *)(param_2 + 0x20) != 0) {
internal::RepeatedPtrFieldBase::MergeFromInternal
((RepeatedPtrFieldBase *)(param_1 + 0x18),
(_func_void_void_ptr_ptr_void_ptr_ptr_int_int *)(param_2 + 0x18));
}
uVar1 = *(uint *)(param_2 + 0x10);
if ((uVar1 & 3) != 0) {
if ((uVar1 & 1) != 0) {
uVar2 = *(ulong *)(param_2 + 0x30);
*(uint *)(param_1 + 0x10) = *(uint *)(param_1 + 0x10) | 1;
pAVar4 = (Arena *)(*(ulong *)(param_1 + 8) & 0xfffffffffffffffc);
if ((*(ulong *)(param_1 + 8) & 1) != 0) {
pAVar4 = *(Arena **)pAVar4;
}
internal::ArenaStringPtr::Set
((ArenaStringPtr *)(param_1 + 0x30),(string *)(uVar2 & 0xfffffffffffffffc),pAVar4);
}
if ((uVar1 & 2) != 0) {
param_1[0x10] = (Message)((byte)param_1[0x10] | 2);
pMVar3 = *(Message **)(param_1 + 0x38);
if (pMVar3 == (Message *)0x0) {
pAVar4 = (Arena *)(*(ulong *)(param_1 + 8) & 0xfffffffffffffffc);
if ((*(ulong *)(param_1 + 8) & 1) != 0) {
pAVar4 = *(Arena **)pAVar4;
}
pMVar3 = (Message *)Arena::CreateMaybeMessage<google::protobuf::ServiceOptions>(pAVar4);
*(Message **)(param_1 + 0x38) = pMVar3;
}
pMVar5 = (Message *)_ServiceOptions_default_instance_;
if (*(Message **)(param_2 + 0x38) != (Message *)0x0) {
pMVar5 = *(Message **)(param_2 + 0x38);
}
ServiceOptions::MergeImpl(pMVar3,pMVar5);
}
}
if ((*(ulong *)(param_2 + 8) & 1) == 0) {
return;
}
internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>
((InternalMetadata *)(param_1 + 8),
(UnknownFieldSet *)((*(ulong *)(param_2 + 8) & 0xfffffffffffffffc) + 8));
return;
}
|
|
64,751 |
ExportImageToMemory
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c
|
unsigned char *ExportImageToMemory(Image image, const char *fileType, int *dataSize)
{
unsigned char *fileData = NULL;
*dataSize = 0;
// Security check for input data
if ((image.width == 0) || (image.height == 0) || (image.data == NULL)) return NULL;
#if defined(SUPPORT_IMAGE_EXPORT)
int channels = 4;
if (image.format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) channels = 1;
else if (image.format == PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) channels = 2;
else if (image.format == PIXELFORMAT_UNCOMPRESSED_R8G8B8) channels = 3;
else if (image.format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8) channels = 4;
#if defined(SUPPORT_FILEFORMAT_PNG)
if ((strcmp(fileType, ".png") == 0) || (strcmp(fileType, ".PNG") == 0))
{
fileData = stbi_write_png_to_mem((const unsigned char *)image.data, image.width*channels, image.width, image.height, channels, dataSize);
}
#endif
#endif
return fileData;
}
|
O0
|
c
|
ExportImageToMemory:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movl $0x0, (%rcx)
cmpl $0x0, 0x8(%rax)
je 0xfc974
movq -0x30(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0xfc974
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xfc981
movq $0x0, -0x8(%rbp)
jmp 0xfca2f
movq -0x30(%rbp), %rax
movl $0x4, -0x24(%rbp)
cmpl $0x1, 0x14(%rax)
jne 0xfc99b
movl $0x1, -0x24(%rbp)
jmp 0xfc9d8
movq -0x30(%rbp), %rax
cmpl $0x2, 0x14(%rax)
jne 0xfc9ae
movl $0x2, -0x24(%rbp)
jmp 0xfc9d6
movq -0x30(%rbp), %rax
cmpl $0x4, 0x14(%rax)
jne 0xfc9c1
movl $0x3, -0x24(%rbp)
jmp 0xfc9d4
movq -0x30(%rbp), %rax
cmpl $0x7, 0x14(%rax)
jne 0xfc9d2
movl $0x4, -0x24(%rbp)
jmp 0xfc9d4
jmp 0xfc9d6
jmp 0xfc9d8
movq -0x10(%rbp), %rdi
leaq 0xa7766(%rip), %rsi # 0x1a4149
callq 0xa750
cmpl $0x0, %eax
je 0xfca02
movq -0x10(%rbp), %rdi
leaq 0xc49e0(%rip), %rsi # 0x1c13d8
callq 0xa750
cmpl $0x0, %eax
jne 0xfca27
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl 0x8(%rax), %esi
imull -0x24(%rbp), %esi
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
movl -0x24(%rbp), %r8d
movq -0x18(%rbp), %r9
callq 0xf6940
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
ExportImageToMemory:
push rbp
mov rbp, rsp
sub rsp, 30h
lea rax, [rbp+arg_0]
mov [rbp+var_30], rax
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], 0
mov rcx, [rbp+var_18]
mov dword ptr [rcx], 0
cmp dword ptr [rax+8], 0
jz short loc_FC974
mov rax, [rbp+var_30]
cmp dword ptr [rax+0Ch], 0
jz short loc_FC974
mov rax, [rbp+var_30]
cmp qword ptr [rax], 0
jnz short loc_FC981
loc_FC974:
mov [rbp+var_8], 0
jmp loc_FCA2F
loc_FC981:
mov rax, [rbp+var_30]
mov [rbp+var_24], 4
cmp dword ptr [rax+14h], 1
jnz short loc_FC99B
mov [rbp+var_24], 1
jmp short loc_FC9D8
loc_FC99B:
mov rax, [rbp+var_30]
cmp dword ptr [rax+14h], 2
jnz short loc_FC9AE
mov [rbp+var_24], 2
jmp short loc_FC9D6
loc_FC9AE:
mov rax, [rbp+var_30]
cmp dword ptr [rax+14h], 4
jnz short loc_FC9C1
mov [rbp+var_24], 3
jmp short loc_FC9D4
loc_FC9C1:
mov rax, [rbp+var_30]
cmp dword ptr [rax+14h], 7
jnz short loc_FC9D2
mov [rbp+var_24], 4
loc_FC9D2:
jmp short $+2
loc_FC9D4:
jmp short $+2
loc_FC9D6:
jmp short $+2
loc_FC9D8:
mov rdi, [rbp+var_10]
lea rsi, aAssetsWall1Png+0Ch; ".png"
call _strcmp
cmp eax, 0
jz short loc_FCA02
mov rdi, [rbp+var_10]
lea rsi, aPng; ".PNG"
call _strcmp
cmp eax, 0
jnz short loc_FCA27
loc_FCA02:
mov rax, [rbp+var_30]
mov rdi, [rax]
mov esi, [rax+8]
imul esi, [rbp+var_24]
mov edx, [rax+8]
mov ecx, [rax+0Ch]
mov r8d, [rbp+var_24]
mov r9, [rbp+var_18]
call stbi_write_png_to_mem
mov [rbp+var_20], rax
loc_FCA27:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_FCA2F:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
long long * ExportImageToMemory(
long long a1,
int *a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9)
{
int v10; // [rsp+Ch] [rbp-24h]
long long v11; // [rsp+10h] [rbp-20h]
v11 = 0LL;
*a2 = 0;
if ( !(_DWORD)a8 || !HIDWORD(a8) || !a7 )
return 0LL;
v10 = 4;
switch ( HIDWORD(a9) )
{
case 1:
v10 = 1;
break;
case 2:
v10 = 2;
break;
case 4:
v10 = 3;
break;
case 7:
v10 = 4;
break;
}
if ( !(unsigned int)strcmp(a1, ".png") || !(unsigned int)strcmp(a1, ".PNG") )
return stbi_write_png_to_mem(a7, v10 * (int)a8, a8, SHIDWORD(a8), v10, a2);
return (long long *)v11;
}
|
ExportImageToMemory:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],0x0
MOV RCX,qword ptr [RBP + -0x18]
MOV dword ptr [RCX],0x0
CMP dword ptr [RAX + 0x8],0x0
JZ 0x001fc974
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX + 0xc],0x0
JZ 0x001fc974
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX],0x0
JNZ 0x001fc981
LAB_001fc974:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001fca2f
LAB_001fc981:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x24],0x4
CMP dword ptr [RAX + 0x14],0x1
JNZ 0x001fc99b
MOV dword ptr [RBP + -0x24],0x1
JMP 0x001fc9d8
LAB_001fc99b:
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX + 0x14],0x2
JNZ 0x001fc9ae
MOV dword ptr [RBP + -0x24],0x2
JMP 0x001fc9d6
LAB_001fc9ae:
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX + 0x14],0x4
JNZ 0x001fc9c1
MOV dword ptr [RBP + -0x24],0x3
JMP 0x001fc9d4
LAB_001fc9c1:
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX + 0x14],0x7
JNZ 0x001fc9d2
MOV dword ptr [RBP + -0x24],0x4
LAB_001fc9d2:
JMP 0x001fc9d4
LAB_001fc9d4:
JMP 0x001fc9d6
LAB_001fc9d6:
JMP 0x001fc9d8
LAB_001fc9d8:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x2a4149]
CALL 0x0010a750
CMP EAX,0x0
JZ 0x001fca02
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x2c13d8]
CALL 0x0010a750
CMP EAX,0x0
JNZ 0x001fca27
LAB_001fca02:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX]
MOV ESI,dword ptr [RAX + 0x8]
IMUL ESI,dword ptr [RBP + -0x24]
MOV EDX,dword ptr [RAX + 0x8]
MOV ECX,dword ptr [RAX + 0xc]
MOV R8D,dword ptr [RBP + -0x24]
MOV R9,qword ptr [RBP + -0x18]
CALL 0x001f6940
MOV qword ptr [RBP + -0x20],RAX
LAB_001fca27:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_001fca2f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
int8 ExportImageToMemory(char *param_1,int4 *param_2)
{
int iVar1;
long in_stack_00000008;
int iStack0000000000000010;
int iStack0000000000000014;
int8 in_stack_00000018;
int local_2c;
int8 local_28;
int8 local_10;
local_28 = 0;
*param_2 = 0;
if (((iStack0000000000000010 == 0) || (iStack0000000000000014 == 0)) || (in_stack_00000008 == 0))
{
local_10 = 0;
}
else {
if (in_stack_00000018._4_4_ == 1) {
local_2c = 1;
}
else if (in_stack_00000018._4_4_ == 2) {
local_2c = 2;
}
else if (in_stack_00000018._4_4_ == 4) {
local_2c = 3;
}
else {
local_2c = 4;
}
iVar1 = strcmp(param_1,".png");
if ((iVar1 == 0) || (iVar1 = strcmp(param_1,".PNG"), iVar1 == 0)) {
local_28 = stbi_write_png_to_mem
(in_stack_00000008,iStack0000000000000010 * local_2c,
iStack0000000000000010,iStack0000000000000014,local_2c,param_2);
}
local_10 = local_28;
}
return local_10;
}
|
|
64,752 |
ExportImageToMemory
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c
|
unsigned char *ExportImageToMemory(Image image, const char *fileType, int *dataSize)
{
unsigned char *fileData = NULL;
*dataSize = 0;
// Security check for input data
if ((image.width == 0) || (image.height == 0) || (image.data == NULL)) return NULL;
#if defined(SUPPORT_IMAGE_EXPORT)
int channels = 4;
if (image.format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) channels = 1;
else if (image.format == PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) channels = 2;
else if (image.format == PIXELFORMAT_UNCOMPRESSED_R8G8B8) channels = 3;
else if (image.format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8) channels = 4;
#if defined(SUPPORT_FILEFORMAT_PNG)
if ((strcmp(fileType, ".png") == 0) || (strcmp(fileType, ".PNG") == 0))
{
fileData = stbi_write_png_to_mem((const unsigned char *)image.data, image.width*channels, image.width, image.height, channels, dataSize);
}
#endif
#endif
return fileData;
}
|
O2
|
c
|
ExportImageToMemory:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
andl $0x0, (%rsi)
movl 0x48(%rsp), %ebp
testl %ebp, %ebp
sete %al
movl 0x4c(%rsp), %r14d
testl %r14d, %r14d
sete %cl
orb %al, %cl
movq 0x40(%rsp), %r15
testq %r15, %r15
sete %al
orb %cl, %al
jne 0x7e97e
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x40(%rsp), %rax
movl 0x14(%rax), %eax
decl %eax
cmpl $0x6, %eax
ja 0x7e954
movl %eax, %eax
leaq 0x540c2(%rip), %rcx # 0xd2a10
movl (%rcx,%rax,4), %r13d
jmp 0x7e958
pushq $0x4
popq %r13
leaq 0x3688a(%rip), %rsi # 0xb51e9
movq %r12, %rdi
callq 0x9750
testl %eax, %eax
je 0x7e98f
leaq 0x54429(%rip), %rsi # 0xd2d9b
movq %r12, %rdi
callq 0x9750
testl %eax, %eax
je 0x7e98f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r13d, %esi
imull %ebp, %esi
movq %r15, %rdi
movl %ebp, %edx
movl %r14d, %ecx
movl %r13d, %r8d
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x79039
|
ExportImageToMemory:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
and dword ptr [rsi], 0
mov ebp, [rsp+38h+arg_8]
test ebp, ebp
setz al
mov r14d, [rsp+38h+arg_C]
test r14d, r14d
setz cl
or cl, al
mov r15, [rsp+38h+arg_0]
test r15, r15
setz al
or al, cl
jnz short loc_7E97E
mov rbx, rsi
mov r12, rdi
lea rax, [rsp+38h+arg_0]
mov eax, [rax+14h]
dec eax
cmp eax, 6
ja short loc_7E954
mov eax, eax
lea rcx, unk_D2A10
mov r13d, [rcx+rax*4]
jmp short loc_7E958
loc_7E954:
push 4
pop r13
loc_7E958:
lea rsi, aAssetsWall1Png+0Ch; ".png"
mov rdi, r12
call _strcmp
test eax, eax
jz short loc_7E98F
lea rsi, aPng; ".PNG"
mov rdi, r12
call _strcmp
test eax, eax
jz short loc_7E98F
loc_7E97E:
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7E98F:
mov esi, r13d
imul esi, ebp
mov rdi, r15
mov edx, ebp
mov ecx, r14d
mov r8d, r13d
mov r9, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp stbi_write_png_to_mem
|
long long ExportImageToMemory(
long long a1,
int *a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9)
{
int v9; // r13d
*a2 = 0;
if ( (_DWORD)a8 != 0
&& HIDWORD(a8) != 0
&& a7 != 0
&& ((unsigned int)(HIDWORD(a9) - 1) > 6 ? (v9 = 4) : (v9 = dword_D2A10[HIDWORD(a9) - 1]),
!(unsigned int)strcmp(a1, ".png") || !(unsigned int)strcmp(a1, ".PNG")) )
{
return stbi_write_png_to_mem(a7, (int)a8 * v9, a8, SHIDWORD(a8), v9, a2);
}
else
{
return 0LL;
}
}
|
ExportImageToMemory:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
AND dword ptr [RSI],0x0
MOV EBP,dword ptr [RSP + 0x48]
TEST EBP,EBP
SETZ AL
MOV R14D,dword ptr [RSP + 0x4c]
TEST R14D,R14D
SETZ CL
OR CL,AL
MOV R15,qword ptr [RSP + 0x40]
TEST R15,R15
SETZ AL
OR AL,CL
JNZ 0x0017e97e
MOV RBX,RSI
MOV R12,RDI
LEA RAX,[RSP + 0x40]
MOV EAX,dword ptr [RAX + 0x14]
DEC EAX
CMP EAX,0x6
JA 0x0017e954
MOV EAX,EAX
LEA RCX,[0x1d2a10]
MOV R13D,dword ptr [RCX + RAX*0x4]
JMP 0x0017e958
LAB_0017e954:
PUSH 0x4
POP R13
LAB_0017e958:
LEA RSI,[0x1b51e9]
MOV RDI,R12
CALL 0x00109750
TEST EAX,EAX
JZ 0x0017e98f
LEA RSI,[0x1d2d9b]
MOV RDI,R12
CALL 0x00109750
TEST EAX,EAX
JZ 0x0017e98f
LAB_0017e97e:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017e98f:
MOV ESI,R13D
IMUL ESI,EBP
MOV RDI,R15
MOV EDX,EBP
MOV ECX,R14D
MOV R8D,R13D
MOV R9,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00179039
|
int8 ExportImageToMemory(char *param_1,int4 *param_2)
{
int iVar1;
int8 uVar2;
int iVar3;
long in_stack_00000008;
int iStack0000000000000010;
int iStack0000000000000014;
int8 in_stack_00000018;
*param_2 = 0;
if (in_stack_00000008 == 0 || (iStack0000000000000014 == 0 || iStack0000000000000010 == 0)) {
return 0;
}
if (in_stack_00000018._4_4_ - 1U < 7) {
iVar3 = *(int *)(&DAT_001d2a10 + (ulong)(in_stack_00000018._4_4_ - 1U) * 4);
}
else {
iVar3 = 4;
}
iVar1 = strcmp(param_1,".png");
if ((iVar1 != 0) && (iVar1 = strcmp(param_1,".PNG"), iVar1 != 0)) {
return 0;
}
uVar2 = stbi_write_png_to_mem
(in_stack_00000008,iVar3 * iStack0000000000000010,iStack0000000000000010,
iStack0000000000000014,iVar3,param_2);
return uVar2;
}
|
|
64,753 |
ggml_set_i32
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c
|
struct ggml_tensor * ggml_set_i32 (struct ggml_tensor * tensor, int32_t value) {
const int n = ggml_nrows(tensor);
const int nc = tensor->ne[0];
const size_t n1 = tensor->nb[1];
char * const data = tensor->data;
switch (tensor->type) {
case GGML_TYPE_I8:
{
assert(tensor->nb[0] == sizeof(int8_t));
for (int i = 0; i < n; i++) {
ggml_vec_set_i8(nc, (int8_t *)(data + i*n1), value);
}
} break;
case GGML_TYPE_I16:
{
assert(tensor->nb[0] == sizeof(int16_t));
for (int i = 0; i < n; i++) {
ggml_vec_set_i16(nc, (int16_t *)(data + i*n1), value);
}
} break;
case GGML_TYPE_I32:
{
assert(tensor->nb[0] == sizeof(int32_t));
for (int i = 0; i < n; i++) {
ggml_vec_set_i32(nc, (int32_t *)(data + i*n1), value);
}
} break;
case GGML_TYPE_F16:
{
assert(tensor->nb[0] == sizeof(ggml_fp16_t));
for (int i = 0; i < n; i++) {
ggml_vec_set_f16(nc, (ggml_fp16_t *)(data + i*n1), GGML_FP32_TO_FP16(value));
}
} break;
case GGML_TYPE_BF16:
{
assert(tensor->nb[0] == sizeof(ggml_fp16_t));
for (int i = 0; i < n; i++) {
ggml_vec_set_bf16(nc, (ggml_bf16_t *)(data + i*n1), GGML_FP32_TO_BF16(value));
}
} break;
case GGML_TYPE_F32:
{
assert(tensor->nb[0] == sizeof(float));
for (int i = 0; i < n; i++) {
ggml_vec_set_f32(nc, (float *)(data + i*n1), value);
}
} break;
default:
{
GGML_ABORT("fatal error");
}
}
return tensor;
}
|
O0
|
c
|
ggml_set_i32:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdc20
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x68(%rbp)
subq $0x1e, %rax
ja 0xf159
movq -0x68(%rbp), %rax
leaq 0x6415e(%rip), %rcx # 0x73000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
cmpq $0x1, 0x30(%rax)
jne 0xeeb8
jmp 0xeed7
leaq 0x64e18(%rip), %rdi # 0x73cd7
leaq 0x64c9c(%rip), %rsi # 0x73b62
movl $0x9b0, %edx # imm = 0x9B0
leaq 0x64e25(%rip), %rcx # 0x73cf7
callq 0xd690
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xef0f
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rax
imulq -0x20(%rbp), %rax
addq %rax, %rsi
movl -0xc(%rbp), %eax
movsbl %al, %edx
callq 0xf540
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xeede
jmp 0xf173
movq -0x8(%rbp), %rax
cmpq $0x2, 0x30(%rax)
jne 0xef21
jmp 0xef40
leaq 0x64e0f(%rip), %rdi # 0x73d37
leaq 0x64c33(%rip), %rsi # 0x73b62
movl $0x9b7, %edx # imm = 0x9B7
leaq 0x64dbc(%rip), %rcx # 0x73cf7
callq 0xd690
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xef78
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
movslq -0x30(%rbp), %rax
imulq -0x20(%rbp), %rax
addq %rax, %rsi
movl -0xc(%rbp), %eax
movswl %ax, %edx
callq 0xf580
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xef47
jmp 0xf173
movq -0x8(%rbp), %rax
cmpq $0x4, 0x30(%rax)
jne 0xef8a
jmp 0xefa9
leaq 0x64dc7(%rip), %rdi # 0x73d58
leaq 0x64bca(%rip), %rsi # 0x73b62
movl $0x9be, %edx # imm = 0x9BE
leaq 0x64d53(%rip), %rcx # 0x73cf7
callq 0xd690
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xefde
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
movslq -0x34(%rbp), %rax
imulq -0x20(%rbp), %rax
addq %rax, %rsi
movl -0xc(%rbp), %edx
callq 0xf5c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xefb0
jmp 0xf173
movq -0x8(%rbp), %rax
cmpq $0x2, 0x30(%rax)
jne 0xeff0
jmp 0xf00f
leaq 0x64d82(%rip), %rdi # 0x73d79
leaq 0x64b64(%rip), %rsi # 0x73b62
movl $0x9c5, %edx # imm = 0x9C5
leaq 0x64ced(%rip), %rcx # 0x73cf7
callq 0xd690
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xf06f
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
movslq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
imulq %rcx, %rax
addq %rax, %rsi
vcvtsi2ssl -0xc(%rbp), %xmm0, %xmm1
vxorps %xmm0, %xmm0, %xmm0
vblendps $0x1, %xmm1, %xmm0, %xmm0 # xmm0 = xmm1[0],xmm0[1,2,3]
vmovaps %xmm0, -0x50(%rbp)
vmovaps -0x50(%rbp), %xmm0
vcvtps2ph $0x0, %xmm0, %xmm0
vmovd %xmm0, %eax
movw %ax, -0x3a(%rbp)
movzwl -0x3a(%rbp), %edx
callq 0xf600
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xf016
jmp 0xf173
movq -0x8(%rbp), %rax
cmpq $0x2, 0x30(%rax)
jne 0xf081
jmp 0xf0a0
leaq 0x64cf1(%rip), %rdi # 0x73d79
leaq 0x64ad3(%rip), %rsi # 0x73b62
movl $0x9cc, %edx # imm = 0x9CC
leaq 0x64c5c(%rip), %rcx # 0x73cf7
callq 0xd690
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xf0f2
movl -0x14(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x28(%rbp), %rax
movslq -0x54(%rbp), %rcx
imulq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
vcvtsi2ssl -0xc(%rbp), %xmm0, %xmm0
callq 0xf680
movl -0x74(%rbp), %edi
movq -0x70(%rbp), %rsi
movw %ax, -0x56(%rbp)
movzwl -0x56(%rbp), %edx
callq 0xf640
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xf0a7
jmp 0xf173
movq -0x8(%rbp), %rax
cmpq $0x4, 0x30(%rax)
jne 0xf101
jmp 0xf120
leaq 0x64c96(%rip), %rdi # 0x73d9e
leaq 0x64a53(%rip), %rsi # 0x73b62
movl $0x9d3, %edx # imm = 0x9D3
leaq 0x64bdc(%rip), %rcx # 0x73cf7
callq 0xd690
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xf157
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
movslq -0x5c(%rbp), %rax
imulq -0x20(%rbp), %rax
addq %rax, %rsi
vcvtsi2ssl -0xc(%rbp), %xmm0, %xmm0
callq 0xf6e0
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0xf127
jmp 0xf173
leaq 0x64a02(%rip), %rdi # 0x73b62
movl $0x9da, %esi # imm = 0x9DA
leaq 0x64c51(%rip), %rdx # 0x73dbd
movb $0x0, %al
callq 0xe270
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
|
ggml_set_i32:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rdi, [rbp+var_8]
call _ggml_nrows
mov [rbp+var_10], eax
mov rax, [rbp+var_8]
mov eax, [rax+10h]
mov [rbp+var_14], eax
mov rax, [rbp+var_8]
mov rax, [rax+38h]
mov [rbp+var_20], rax
mov rax, [rbp+var_8]
mov rax, [rax+0F8h]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
mov eax, [rax]
mov [rbp+var_68], rax
sub rax, 1Eh; switch 31 cases
ja def_EEA9; jumptable 000000000000EEA9 default case, cases 2-23,27-29
mov rax, [rbp+var_68]
lea rcx, jpt_EEA9
movsxd rax, ds:(jpt_EEA9 - 73000h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_EEAB:
mov rax, [rbp+var_8]; jumptable 000000000000EEA9 case 24
cmp qword ptr [rax+30h], 1
jnz short loc_EEB8
jmp short loc_EED7
loc_EEB8:
lea rdi, aTensorNb0Sizeo; "tensor->nb[0] == sizeof(int8_t)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 9B0h
lea rcx, aStructGgmlTens; "struct ggml_tensor *ggml_set_i32(struct"...
call ___assert_fail
loc_EED7:
mov [rbp+var_2C], 0
loc_EEDE:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_10]
jge short loc_EF0F
mov edi, [rbp+var_14]
mov rsi, [rbp+var_28]
movsxd rax, [rbp+var_2C]
imul rax, [rbp+var_20]
add rsi, rax
mov eax, [rbp+var_C]
movsx edx, al
call ggml_vec_set_i8
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_EEDE
loc_EF0F:
jmp loc_F173
loc_EF14:
mov rax, [rbp+var_8]; jumptable 000000000000EEA9 case 25
cmp qword ptr [rax+30h], 2
jnz short loc_EF21
jmp short loc_EF40
loc_EF21:
lea rdi, aTensorNb0Sizeo_0; "tensor->nb[0] == sizeof(int16_t)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 9B7h
lea rcx, aStructGgmlTens; "struct ggml_tensor *ggml_set_i32(struct"...
call ___assert_fail
loc_EF40:
mov [rbp+var_30], 0
loc_EF47:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_10]
jge short loc_EF78
mov edi, [rbp+var_14]
mov rsi, [rbp+var_28]
movsxd rax, [rbp+var_30]
imul rax, [rbp+var_20]
add rsi, rax
mov eax, [rbp+var_C]
movsx edx, ax
call ggml_vec_set_i16
mov eax, [rbp+var_30]
add eax, 1
mov [rbp+var_30], eax
jmp short loc_EF47
loc_EF78:
jmp loc_F173
loc_EF7D:
mov rax, [rbp+var_8]; jumptable 000000000000EEA9 case 26
cmp qword ptr [rax+30h], 4
jnz short loc_EF8A
jmp short loc_EFA9
loc_EF8A:
lea rdi, aTensorNb0Sizeo_1; "tensor->nb[0] == sizeof(int32_t)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 9BEh
lea rcx, aStructGgmlTens; "struct ggml_tensor *ggml_set_i32(struct"...
call ___assert_fail
loc_EFA9:
mov [rbp+var_34], 0
loc_EFB0:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_10]
jge short loc_EFDE
mov edi, [rbp+var_14]
mov rsi, [rbp+var_28]
movsxd rax, [rbp+var_34]
imul rax, [rbp+var_20]
add rsi, rax
mov edx, [rbp+var_C]
call ggml_vec_set_i32
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
jmp short loc_EFB0
loc_EFDE:
jmp loc_F173
loc_EFE3:
mov rax, [rbp+var_8]; jumptable 000000000000EEA9 case 1
cmp qword ptr [rax+30h], 2
jnz short loc_EFF0
jmp short loc_F00F
loc_EFF0:
lea rdi, aTensorNb0Sizeo_2; "tensor->nb[0] == sizeof(ggml_fp16_t)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 9C5h
lea rcx, aStructGgmlTens; "struct ggml_tensor *ggml_set_i32(struct"...
call ___assert_fail
loc_F00F:
mov [rbp+var_38], 0
loc_F016:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_10]
jge short loc_F06F
mov edi, [rbp+var_14]
mov rsi, [rbp+var_28]
movsxd rax, [rbp+var_38]
mov rcx, [rbp+var_20]
imul rax, rcx
add rsi, rax
vcvtsi2ss xmm1, xmm0, [rbp+var_C]
vxorps xmm0, xmm0, xmm0
vblendps xmm0, xmm0, xmm1, 1
vmovaps [rbp+var_50], xmm0
vmovaps xmm0, [rbp+var_50]
vcvtps2ph xmm0, xmm0, 0
vmovd eax, xmm0
mov [rbp+var_3A], ax
movzx edx, [rbp+var_3A]
call ggml_vec_set_f16
mov eax, [rbp+var_38]
add eax, 1
mov [rbp+var_38], eax
jmp short loc_F016
loc_F06F:
jmp loc_F173
loc_F074:
mov rax, [rbp+var_8]; jumptable 000000000000EEA9 case 30
cmp qword ptr [rax+30h], 2
jnz short loc_F081
jmp short loc_F0A0
loc_F081:
lea rdi, aTensorNb0Sizeo_2; "tensor->nb[0] == sizeof(ggml_fp16_t)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 9CCh
lea rcx, aStructGgmlTens; "struct ggml_tensor *ggml_set_i32(struct"...
call ___assert_fail
loc_F0A0:
mov [rbp+var_54], 0
loc_F0A7:
mov eax, [rbp+var_54]
cmp eax, [rbp+var_10]
jge short loc_F0F2
mov eax, [rbp+var_14]
mov [rbp+var_74], eax
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_54]
imul rcx, [rbp+var_20]
add rax, rcx
mov [rbp+var_70], rax
vcvtsi2ss xmm0, xmm0, [rbp+var_C]
call ggml_compute_fp32_to_bf16
mov edi, [rbp+var_74]
mov rsi, [rbp+var_70]
mov [rbp+var_56], ax
movzx edx, [rbp+var_56]
call ggml_vec_set_bf16
mov eax, [rbp+var_54]
add eax, 1
mov [rbp+var_54], eax
jmp short loc_F0A7
loc_F0F2:
jmp short loc_F173
loc_F0F4:
mov rax, [rbp+var_8]; jumptable 000000000000EEA9 case 0
cmp qword ptr [rax+30h], 4
jnz short loc_F101
jmp short loc_F120
loc_F101:
lea rdi, aTensorNb0Sizeo_3; "tensor->nb[0] == sizeof(float)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 9D3h
lea rcx, aStructGgmlTens; "struct ggml_tensor *ggml_set_i32(struct"...
call ___assert_fail
loc_F120:
mov [rbp+var_5C], 0
loc_F127:
mov eax, [rbp+var_5C]
cmp eax, [rbp+var_10]
jge short loc_F157
mov edi, [rbp+var_14]
mov rsi, [rbp+var_28]
movsxd rax, [rbp+var_5C]
imul rax, [rbp+var_20]
add rsi, rax
vcvtsi2ss xmm0, xmm0, [rbp+var_C]
call ggml_vec_set_f32
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
jmp short loc_F127
loc_F157:
jmp short loc_F173
def_EEA9:
lea rdi, aWorkspaceLlm4b_0; jumptable 000000000000EEA9 default case, cases 2-23,27-29
mov esi, 9DAh
lea rdx, aFatalError; "fatal error"
mov al, 0
call _ggml_abort
loc_F173:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
|
long long ggml_set_i32(long long a1, unsigned int a2, __m128 _XMM0)
{
int i; // [rsp+24h] [rbp-5Ch]
unsigned __int16 v10; // [rsp+2Ah] [rbp-56h]
int ii; // [rsp+2Ch] [rbp-54h]
int j; // [rsp+48h] [rbp-38h]
int n; // [rsp+4Ch] [rbp-34h]
int m; // [rsp+50h] [rbp-30h]
int k; // [rsp+54h] [rbp-2Ch]
long long v17; // [rsp+58h] [rbp-28h]
long long v18; // [rsp+60h] [rbp-20h]
unsigned int v19; // [rsp+6Ch] [rbp-14h]
int v20; // [rsp+70h] [rbp-10h]
v20 = ggml_nrows(a1);
v19 = *(_DWORD *)(a1 + 16);
v18 = *(_QWORD *)(a1 + 56);
v17 = *(_QWORD *)(a1 + 248);
switch ( *(_DWORD *)a1 )
{
case 0:
if ( *(_QWORD *)(a1 + 48) != 4LL )
__assert_fail(
"tensor->nb[0] == sizeof(float)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
2515LL,
"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
for ( i = 0; i < v20; ++i )
{
__asm { vcvtsi2ss xmm0, xmm0, [rbp+var_C] }
ggml_vec_set_f32(v19, v18 * i + v17, *(double *)_XMM0.m128_u64);
}
break;
case 1:
if ( *(_QWORD *)(a1 + 48) != 2LL )
__assert_fail(
"tensor->nb[0] == sizeof(ggml_fp16_t)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
2501LL,
"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
for ( j = 0; j < v20; ++j )
{
__asm
{
vcvtsi2ss xmm1, xmm0, [rbp+var_C]
vxorps xmm0, xmm0, xmm0
vblendps xmm0, xmm0, xmm1, 1
vmovaps [rbp+var_50], xmm0
vmovaps xmm0, [rbp+var_50]
vcvtps2ph xmm0, xmm0, 0
vmovd eax, xmm0
}
ggml_vec_set_f16(v19, v18 * j + v17, (unsigned __int16)_EAX);
}
break;
case 0x18:
if ( *(_QWORD *)(a1 + 48) != 1LL )
__assert_fail(
"tensor->nb[0] == sizeof(int8_t)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
2480LL,
"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
for ( k = 0; k < v20; ++k )
ggml_vec_set_i8(v19, v18 * k + v17, (unsigned int)(char)a2);
break;
case 0x19:
if ( *(_QWORD *)(a1 + 48) != 2LL )
__assert_fail(
"tensor->nb[0] == sizeof(int16_t)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
2487LL,
"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
for ( m = 0; m < v20; ++m )
ggml_vec_set_i16(v19, v18 * m + v17, (unsigned int)(__int16)a2);
break;
case 0x1A:
if ( *(_QWORD *)(a1 + 48) != 4LL )
__assert_fail(
"tensor->nb[0] == sizeof(int32_t)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
2494LL,
"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
for ( n = 0; n < v20; ++n )
ggml_vec_set_i32(v19, v18 * n + v17, a2);
break;
case 0x1E:
if ( *(_QWORD *)(a1 + 48) != 2LL )
__assert_fail(
"tensor->nb[0] == sizeof(ggml_fp16_t)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
2508LL,
"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
for ( ii = 0; ii < v20; ++ii )
{
__asm { vcvtsi2ss xmm0, xmm0, [rbp+var_C] }
v10 = ggml_compute_fp32_to_bf16(*(double *)_XMM0.m128_u64);
ggml_vec_set_bf16(v19, v18 * ii + v17, v10);
}
break;
default:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
2522LL,
"fatal error");
break;
}
return a1;
}
|
ggml_set_i32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0010dc20
MOV dword ptr [RBP + -0x10],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xf8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
SUB RAX,0x1e
JA 0x0010f159
MOV RAX,qword ptr [RBP + -0x68]
LEA RCX,[0x173000]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_18:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x1
JNZ 0x0010eeb8
JMP 0x0010eed7
LAB_0010eeb8:
LEA RDI,[0x173cd7]
LEA RSI,[0x173b62]
MOV EDX,0x9b0
LEA RCX,[0x173cf7]
CALL 0x0010d690
LAB_0010eed7:
MOV dword ptr [RBP + -0x2c],0x0
LAB_0010eede:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x0010ef0f
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x28]
MOVSXD RAX,dword ptr [RBP + -0x2c]
IMUL RAX,qword ptr [RBP + -0x20]
ADD RSI,RAX
MOV EAX,dword ptr [RBP + -0xc]
MOVSX EDX,AL
CALL 0x0010f540
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0010eede
LAB_0010ef0f:
JMP 0x0010f173
caseD_19:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x2
JNZ 0x0010ef21
JMP 0x0010ef40
LAB_0010ef21:
LEA RDI,[0x173d37]
LEA RSI,[0x173b62]
MOV EDX,0x9b7
LEA RCX,[0x173cf7]
CALL 0x0010d690
LAB_0010ef40:
MOV dword ptr [RBP + -0x30],0x0
LAB_0010ef47:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x0010ef78
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x28]
MOVSXD RAX,dword ptr [RBP + -0x30]
IMUL RAX,qword ptr [RBP + -0x20]
ADD RSI,RAX
MOV EAX,dword ptr [RBP + -0xc]
MOVSX EDX,AX
CALL 0x0010f580
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0010ef47
LAB_0010ef78:
JMP 0x0010f173
caseD_1a:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x4
JNZ 0x0010ef8a
JMP 0x0010efa9
LAB_0010ef8a:
LEA RDI,[0x173d58]
LEA RSI,[0x173b62]
MOV EDX,0x9be
LEA RCX,[0x173cf7]
CALL 0x0010d690
LAB_0010efa9:
MOV dword ptr [RBP + -0x34],0x0
LAB_0010efb0:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x0010efde
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x28]
MOVSXD RAX,dword ptr [RBP + -0x34]
IMUL RAX,qword ptr [RBP + -0x20]
ADD RSI,RAX
MOV EDX,dword ptr [RBP + -0xc]
CALL 0x0010f5c0
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0010efb0
LAB_0010efde:
JMP 0x0010f173
caseD_1:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x2
JNZ 0x0010eff0
JMP 0x0010f00f
LAB_0010eff0:
LEA RDI,[0x173d79]
LEA RSI,[0x173b62]
MOV EDX,0x9c5
LEA RCX,[0x173cf7]
CALL 0x0010d690
LAB_0010f00f:
MOV dword ptr [RBP + -0x38],0x0
LAB_0010f016:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x0010f06f
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x28]
MOVSXD RAX,dword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x20]
IMUL RAX,RCX
ADD RSI,RAX
VCVTSI2SS XMM1,XMM0,dword ptr [RBP + -0xc]
VXORPS XMM0,XMM0,XMM0
VBLENDPS XMM0,XMM0,XMM1,0x1
VMOVAPS xmmword ptr [RBP + -0x50],XMM0
VMOVAPS XMM0,xmmword ptr [RBP + -0x50]
VCVTPS2PH XMM0,XMM0,0x0
VMOVD EAX,XMM0
MOV word ptr [RBP + -0x3a],AX
MOVZX EDX,word ptr [RBP + -0x3a]
CALL 0x0010f600
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0010f016
LAB_0010f06f:
JMP 0x0010f173
caseD_1e:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x2
JNZ 0x0010f081
JMP 0x0010f0a0
LAB_0010f081:
LEA RDI,[0x173d79]
LEA RSI,[0x173b62]
MOV EDX,0x9cc
LEA RCX,[0x173cf7]
CALL 0x0010d690
LAB_0010f0a0:
MOV dword ptr [RBP + -0x54],0x0
LAB_0010f0a7:
MOV EAX,dword ptr [RBP + -0x54]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x0010f0f2
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x74],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x54]
IMUL RCX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
VCVTSI2SS XMM0,XMM0,dword ptr [RBP + -0xc]
CALL 0x0010f680
MOV EDI,dword ptr [RBP + -0x74]
MOV RSI,qword ptr [RBP + -0x70]
MOV word ptr [RBP + -0x56],AX
MOVZX EDX,word ptr [RBP + -0x56]
CALL 0x0010f640
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0010f0a7
LAB_0010f0f2:
JMP 0x0010f173
caseD_0:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x4
JNZ 0x0010f101
JMP 0x0010f120
LAB_0010f101:
LEA RDI,[0x173d9e]
LEA RSI,[0x173b62]
MOV EDX,0x9d3
LEA RCX,[0x173cf7]
CALL 0x0010d690
LAB_0010f120:
MOV dword ptr [RBP + -0x5c],0x0
LAB_0010f127:
MOV EAX,dword ptr [RBP + -0x5c]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x0010f157
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x28]
MOVSXD RAX,dword ptr [RBP + -0x5c]
IMUL RAX,qword ptr [RBP + -0x20]
ADD RSI,RAX
VCVTSI2SS XMM0,XMM0,dword ptr [RBP + -0xc]
CALL 0x0010f6e0
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
JMP 0x0010f127
LAB_0010f157:
JMP 0x0010f173
caseD_2:
LEA RDI,[0x173b62]
MOV ESI,0x9da
LEA RDX,[0x173dbd]
MOV AL,0x0
CALL 0x0010e270
LAB_0010f173:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
int4 * ggml_set_i32(int4 *param_1,int param_2)
{
int4 uVar1;
long lVar2;
long lVar3;
int2 uVar4;
int iVar5;
int8 extraout_XMM0_Qa;
int1 auVar6 [16];
int1 auVar7 [16];
int1 extraout_var [56];
int1 extraout_var_00 [56];
int1 extraout_var_01 [56];
int1 extraout_var_02 [56];
int1 auVar9 [16];
int local_64;
int local_5c;
int local_40;
int local_3c;
int local_38;
int local_34;
int1 auVar8 [64];
iVar5 = ggml_nrows(param_1);
auVar8._8_56_ = extraout_var;
auVar8._0_8_ = extraout_XMM0_Qa;
uVar1 = param_1[4];
lVar2 = *(long *)(param_1 + 0xe);
lVar3 = *(long *)(param_1 + 0x3e);
switch(*param_1) {
case 0:
if (*(long *)(param_1 + 0xc) != 4) {
/* WARNING: Subroutine does not return */
__assert_fail("tensor->nb[0] == sizeof(float)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x9d3,"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
}
for (local_64 = 0; local_64 < iVar5; local_64 = local_64 + 1) {
auVar7._0_4_ = (float)param_2;
auVar7._4_12_ = auVar8._4_12_;
auVar8._0_8_ = ggml_vec_set_f32(auVar7._0_8_,uVar1,lVar3 + local_64 * lVar2);
auVar8._8_56_ = extraout_var_02;
}
break;
case 1:
if (*(long *)(param_1 + 0xc) != 2) {
/* WARNING: Subroutine does not return */
__assert_fail("tensor->nb[0] == sizeof(ggml_fp16_t)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x9c5,"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
}
for (local_40 = 0; local_40 < iVar5; local_40 = local_40 + 1) {
auVar9._0_4_ = (float)param_2;
auVar9._4_12_ = auVar8._4_12_;
auVar6 = vblendps_avx(ZEXT816(0) << 0x40,auVar9,1);
auVar6 = vcvtps2ph_f16c(auVar6,0);
auVar8._0_8_ = ggml_vec_set_f16(uVar1,lVar3 + local_40 * lVar2,auVar6._0_2_);
auVar8._8_56_ = extraout_var_00;
}
break;
default:
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x9da,"fatal error");
break;
case 0x18:
if (*(long *)(param_1 + 0xc) != 1) {
/* WARNING: Subroutine does not return */
__assert_fail("tensor->nb[0] == sizeof(int8_t)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x9b0,"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
}
for (local_34 = 0; local_34 < iVar5; local_34 = local_34 + 1) {
ggml_vec_set_i8(uVar1,lVar3 + local_34 * lVar2,(int)(char)param_2);
}
break;
case 0x19:
if (*(long *)(param_1 + 0xc) != 2) {
/* WARNING: Subroutine does not return */
__assert_fail("tensor->nb[0] == sizeof(int16_t)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x9b7,"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
}
for (local_38 = 0; local_38 < iVar5; local_38 = local_38 + 1) {
ggml_vec_set_i16(uVar1,lVar3 + local_38 * lVar2,(int)(short)param_2);
}
break;
case 0x1a:
if (*(long *)(param_1 + 0xc) != 4) {
/* WARNING: Subroutine does not return */
__assert_fail("tensor->nb[0] == sizeof(int32_t)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x9be,"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
}
for (local_3c = 0; local_3c < iVar5; local_3c = local_3c + 1) {
ggml_vec_set_i32(uVar1,lVar3 + local_3c * lVar2,param_2);
}
break;
case 0x1e:
if (*(long *)(param_1 + 0xc) != 2) {
/* WARNING: Subroutine does not return */
__assert_fail("tensor->nb[0] == sizeof(ggml_fp16_t)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x9cc,"struct ggml_tensor *ggml_set_i32(struct ggml_tensor *, int32_t)");
}
for (local_5c = 0; local_5c < iVar5; local_5c = local_5c + 1) {
auVar6._0_4_ = (float)param_2;
auVar6._4_12_ = auVar8._4_12_;
uVar4 = ggml_compute_fp32_to_bf16(auVar6._0_8_);
auVar8._0_8_ = ggml_vec_set_bf16(uVar1,lVar3 + local_5c * lVar2,uVar4);
auVar8._8_56_ = extraout_var_01;
}
}
return param_1;
}
|
|
64,754 |
PFS_table::safe_aggregate_lock(PFS_table_stat*, PFS_table_share*)
|
eloqsql/storage/perfschema/pfs_instr.cc
|
void PFS_table::safe_aggregate_lock(PFS_table_stat *table_stat,
PFS_table_share *table_share)
{
assert(table_stat != NULL);
assert(table_share != NULL);
PFS_table_lock_stat *from_stat= & table_stat->m_lock_stat;
PFS_table_share_lock *to_stat;
to_stat= table_share->find_or_create_lock_stat();
if (to_stat != NULL)
{
/* Aggregate to TABLE_LOCK_SUMMARY */
to_stat->m_stat.aggregate(from_stat);
}
table_stat->fast_reset_lock();
}
|
O3
|
cpp
|
PFS_table::safe_aggregate_lock(PFS_table_stat*, PFS_table_share*):
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x34ee4
testq %rax, %rax
je 0x30c11
movq $-0x20, %rcx
movq 0x22a8(%rbx,%rcx), %rdx
testq %rdx, %rdx
je 0x30bf4
addq %rdx, 0x28(%rax,%rcx)
movq 0x22b0(%rbx,%rcx), %rdx
addq %rdx, 0x30(%rax,%rcx)
movq 0x22b8(%rbx,%rcx), %rdx
cmpq %rdx, 0x38(%rax,%rcx)
ja 0x30c03
movq 0x22c0(%rbx,%rcx), %rdx
cmpq %rdx, 0x40(%rax,%rcx)
jb 0x30c0a
addq $0x20, %rcx
cmpq $0x140, %rcx # imm = 0x140
jb 0x30bb7
jmp 0x30c11
movq %rdx, 0x38(%rax,%rcx)
jmp 0x30be5
movq %rdx, 0x40(%rax,%rcx)
jmp 0x30bf4
movl $0x2288, %esi # imm = 0x2288
addq %rsi, %rbx
addq 0x2e6388(%rip), %rsi # 0x316fa8
movl $0x160, %edx # imm = 0x160
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x26290
nop
|
_ZN9PFS_table19safe_aggregate_lockEP14PFS_table_statP15PFS_table_share:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, rsi; this
call _ZN15PFS_table_share24find_or_create_lock_statEv; PFS_table_share::find_or_create_lock_stat(void)
test rax, rax
jz short loc_30C11
mov rcx, 0FFFFFFFFFFFFFFE0h
loc_30BB7:
mov rdx, [rbx+rcx+22A8h]
test rdx, rdx
jz short loc_30BF4
add [rax+rcx+28h], rdx
mov rdx, [rbx+rcx+22B0h]
add [rax+rcx+30h], rdx
mov rdx, [rbx+rcx+22B8h]
cmp [rax+rcx+38h], rdx
ja short loc_30C03
loc_30BE5:
mov rdx, [rbx+rcx+22C0h]
cmp [rax+rcx+40h], rdx
jb short loc_30C0A
loc_30BF4:
add rcx, 20h ; ' '
cmp rcx, 140h
jb short loc_30BB7
jmp short loc_30C11
loc_30C03:
mov [rax+rcx+38h], rdx
jmp short loc_30BE5
loc_30C0A:
mov [rax+rcx+40h], rdx
jmp short loc_30BF4
loc_30C11:
mov esi, 2288h
add rbx, rsi
add rsi, cs:_ZN14PFS_table_stat16g_reset_templateE_ptr
mov edx, 160h
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp _memcpy
|
long long PFS_table::safe_aggregate_lock(long long a1, PFS_table_share *a2)
{
long long lock_stat; // rax
unsigned long long v3; // rcx
long long v4; // rdx
unsigned long long v5; // rdx
unsigned long long v6; // rdx
lock_stat = PFS_table_share::find_or_create_lock_stat(a2);
if ( lock_stat )
{
v3 = -32LL;
do
{
v4 = *(_QWORD *)(a1 + v3 + 8872);
if ( v4 )
{
*(_QWORD *)(lock_stat + v3 + 40) += v4;
*(_QWORD *)(lock_stat + v3 + 48) += *(_QWORD *)(a1 + v3 + 8880);
v5 = *(_QWORD *)(a1 + v3 + 8888);
if ( *(_QWORD *)(lock_stat + v3 + 56) > v5 )
*(_QWORD *)(lock_stat + v3 + 56) = v5;
v6 = *(_QWORD *)(a1 + v3 + 8896);
if ( *(_QWORD *)(lock_stat + v3 + 64) < v6 )
*(_QWORD *)(lock_stat + v3 + 64) = v6;
}
v3 += 32LL;
}
while ( v3 < 0x140 );
}
return memcpy(a1 + 8840, &PFS_table_stat::g_reset_template[8840], 352LL);
}
|
safe_aggregate_lock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,RSI
CALL 0x00134ee4
TEST RAX,RAX
JZ 0x00130c11
MOV RCX,-0x20
LAB_00130bb7:
MOV RDX,qword ptr [RBX + RCX*0x1 + 0x22a8]
TEST RDX,RDX
JZ 0x00130bf4
ADD qword ptr [RAX + RCX*0x1 + 0x28],RDX
MOV RDX,qword ptr [RBX + RCX*0x1 + 0x22b0]
ADD qword ptr [RAX + RCX*0x1 + 0x30],RDX
MOV RDX,qword ptr [RBX + RCX*0x1 + 0x22b8]
CMP qword ptr [RAX + RCX*0x1 + 0x38],RDX
JA 0x00130c03
LAB_00130be5:
MOV RDX,qword ptr [RBX + RCX*0x1 + 0x22c0]
CMP qword ptr [RAX + RCX*0x1 + 0x40],RDX
JC 0x00130c0a
LAB_00130bf4:
ADD RCX,0x20
CMP RCX,0x140
JC 0x00130bb7
JMP 0x00130c11
LAB_00130c03:
MOV qword ptr [RAX + RCX*0x1 + 0x38],RDX
JMP 0x00130be5
LAB_00130c0a:
MOV qword ptr [RAX + RCX*0x1 + 0x40],RDX
JMP 0x00130bf4
LAB_00130c11:
MOV ESI,0x2288
ADD RBX,RSI
ADD RSI,qword ptr [0x00416fa8]
MOV EDX,0x160
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00126290
|
/* PFS_table::safe_aggregate_lock(PFS_table_stat*, PFS_table_share*) */
void PFS_table::safe_aggregate_lock(PFS_table_stat *param_1,PFS_table_share *param_2)
{
long *plVar1;
long lVar2;
ulong uVar3;
lVar2 = PFS_table_share::find_or_create_lock_stat(param_2);
if (lVar2 != 0) {
uVar3 = 0xffffffffffffffe0;
do {
if (*(long *)(param_1 + uVar3 + 0x22a8) != 0) {
plVar1 = (long *)(lVar2 + 0x28 + uVar3);
*plVar1 = *plVar1 + *(long *)(param_1 + uVar3 + 0x22a8);
plVar1 = (long *)(lVar2 + 0x30 + uVar3);
*plVar1 = *plVar1 + *(long *)(param_1 + uVar3 + 0x22b0);
if (*(ulong *)(param_1 + uVar3 + 0x22b8) < *(ulong *)(lVar2 + 0x38 + uVar3)) {
*(ulong *)(lVar2 + 0x38 + uVar3) = *(ulong *)(param_1 + uVar3 + 0x22b8);
}
if (*(ulong *)(lVar2 + 0x40 + uVar3) < *(ulong *)(param_1 + uVar3 + 0x22c0)) {
*(ulong *)(lVar2 + 0x40 + uVar3) = *(ulong *)(param_1 + uVar3 + 0x22c0);
}
}
uVar3 = uVar3 + 0x20;
} while (uVar3 < 0x140);
}
memcpy(param_1 + 0x2288,PTR_g_reset_template_00416fa8 + 0x2288,0x160);
return;
}
|
|
64,755 |
uf_space_prespace_selected
|
eloqsql/storage/maria/ma_packrec.c
|
static void uf_space_prespace_selected(MARIA_COLUMNDEF *rec,
MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
bfill(to, (end-to), ' ');
else
{
if (get_bit(bit_buff))
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill(to, spaces, ' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
}
else
decode_bytes(rec,bit_buff,to,end);
}
}
|
O3
|
c
|
uf_space_prespace_selected:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x37144
movl (%r14), %r15d
decl %eax
movl %eax, 0x4(%r14)
btl %eax, %r15d
jb 0x371b9
testl %eax, %eax
jne 0x37161
movq %r14, %rdi
callq 0x36858
movl $0x1f, 0x4(%r14)
movl (%r14), %r15d
testl %r15d, %r15d
jns 0x371da
movl $0x1f, %eax
jmp 0x3716d
movq %r14, %rdi
callq 0x36858
movl $0x1f, 0x4(%r14)
movl (%r14), %r15d
movl $0x1f, %eax
testl %r15d, %r15d
js 0x371b9
decl %eax
movl %eax, 0x4(%r14)
btl %eax, %r15d
jae 0x371da
movq %r13, %rdx
movl 0x24(%r13), %r13d
movl %eax, %ecx
subl %r13d, %ecx
movq %rdx, -0x30(%rbp)
jae 0x371e5
subl %eax, %r13d
movl %eax, %eax
leaq 0xa8af5(%rip), %rcx # 0xdfc80
andl (%rcx,%rax,4), %r15d
movl %r13d, %ecx
shll %cl, %r15d
movq %r14, %rdi
callq 0x36858
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %eax, %r15d
jmp 0x371fa
subq %r12, %rbx
movq %r12, %rdi
movl $0x20, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x292b0
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
jmp 0x3722c
movl %ecx, 0x4(%r14)
shrl %cl, %r15d
movl 0x24(%rdx), %eax
leaq 0xa8a8a(%rip), %rcx # 0xdfc80
andl (%rcx,%rax,4), %r15d
movl %r15d, %edx
leaq (%r12,%rdx), %r13
cmpq %rbx, %r13
jbe 0x37210
movl $0x1, 0x28(%r14)
jmp 0x37242
movq %r12, %rdi
movl $0x20, %esi
callq 0x292b0
cmpq %rbx, %r13
je 0x37242
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36a15
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
uf_space_prespace_selected:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r12, rdx
mov r14, rsi
mov r13, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_37144
mov r15d, [r14]
dec eax
mov [r14+4], eax
bt r15d, eax
jb loc_371B9
test eax, eax
jnz short loc_37161
mov rdi, r14
call fill_buffer
mov dword ptr [r14+4], 1Fh
mov r15d, [r14]
test r15d, r15d
jns loc_371DA
mov eax, 1Fh
jmp short loc_3716D
loc_37144:
mov rdi, r14
call fill_buffer
mov dword ptr [r14+4], 1Fh
mov r15d, [r14]
mov eax, 1Fh
test r15d, r15d
js short loc_371B9
loc_37161:
dec eax
mov [r14+4], eax
bt r15d, eax
jnb short loc_371DA
loc_3716D:
mov rdx, r13
mov r13d, [r13+24h]
mov ecx, eax
sub ecx, r13d
mov [rbp+var_30], rdx
jnb short loc_371E5
sub r13d, eax
mov eax, eax
lea rcx, mask
and r15d, [rcx+rax*4]
mov ecx, r13d
shl r15d, cl
mov rdi, r14
call fill_buffer
mov eax, 20h ; ' '
sub eax, r13d
mov [r14+4], eax
mov eax, [r14]
neg r13d
mov ecx, r13d
shr eax, cl
add r15d, eax
jmp short loc_371FA
loc_371B9:
sub rbx, r12
mov rdi, r12
mov esi, 20h ; ' '
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
loc_371DA:
mov rdi, r13
mov rsi, r14
mov rdx, r12
jmp short loc_3722C
loc_371E5:
mov [r14+4], ecx
shr r15d, cl
mov eax, [rdx+24h]
lea rcx, mask
and r15d, [rcx+rax*4]
loc_371FA:
mov edx, r15d
lea r13, [r12+rdx]
cmp r13, rbx
jbe short loc_37210
mov dword ptr [r14+28h], 1
jmp short loc_37242
loc_37210:
mov rdi, r12
mov esi, 20h ; ' '
call _memset
cmp r13, rbx
jz short loc_37242
mov rdi, [rbp+var_30]
mov rsi, r14
mov rdx, r13
loc_3722C:
mov rcx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes
loc_37242:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long uf_space_prespace_selected(long long a1, unsigned int *a2, _BYTE *a3, _BYTE *a4)
{
unsigned int v6; // eax
unsigned int v7; // r15d
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // r13d
unsigned int v11; // ecx
int v12; // r13d
int v13; // r15d
long long result; // rax
unsigned int v15; // r15d
_BYTE *v16; // rdx
_BYTE *v17; // r13
v6 = a2[1];
if ( !v6 )
{
fill_buffer((long long)a2);
a2[1] = 31;
v7 = *a2;
v8 = 31;
if ( (*a2 & 0x80000000) == 0 )
goto LABEL_7;
return memset(a3, 32LL, a4 - a3);
}
v7 = *a2;
v8 = v6 - 1;
a2[1] = v8;
if ( _bittest((const int *)&v7, v8) )
return memset(a3, 32LL, a4 - a3);
if ( !v8 )
{
fill_buffer((long long)a2);
a2[1] = 31;
v7 = *a2;
if ( (*a2 & 0x80000000) != 0 )
{
v9 = 31;
goto LABEL_8;
}
LABEL_11:
v16 = a3;
return (long long)decode_bytes(a1, (long long)a2, v16, a4);
}
LABEL_7:
v9 = v8 - 1;
a2[1] = v9;
if ( !_bittest((const int *)&v7, v9) )
goto LABEL_11;
LABEL_8:
v10 = *(_DWORD *)(a1 + 36);
v11 = v9 - v10;
if ( v9 >= v10 )
{
a2[1] = v11;
result = *(unsigned int *)(a1 + 36);
v15 = mask[result] & (v7 >> v11);
}
else
{
v12 = v10 - v9;
v13 = (mask[v9] & v7) << v12;
fill_buffer((long long)a2);
a2[1] = 32 - v12;
result = *a2 >> -(char)v12;
v15 = result + v13;
}
v17 = &a3[v15];
if ( v17 > a4 )
{
a2[10] = 1;
return result;
}
result = memset(a3, 32LL, v15);
if ( v17 != a4 )
{
v16 = &a3[v15];
return (long long)decode_bytes(a1, (long long)a2, v16, a4);
}
return result;
}
|
uf_space_prespace_selected:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R12,RDX
MOV R14,RSI
MOV R13,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x00137144
MOV R15D,dword ptr [R14]
DEC EAX
MOV dword ptr [R14 + 0x4],EAX
BT R15D,EAX
JC 0x001371b9
TEST EAX,EAX
JNZ 0x00137161
MOV RDI,R14
CALL 0x00136858
MOV dword ptr [R14 + 0x4],0x1f
MOV R15D,dword ptr [R14]
TEST R15D,R15D
JNS 0x001371da
MOV EAX,0x1f
JMP 0x0013716d
LAB_00137144:
MOV RDI,R14
CALL 0x00136858
MOV dword ptr [R14 + 0x4],0x1f
MOV R15D,dword ptr [R14]
MOV EAX,0x1f
TEST R15D,R15D
JS 0x001371b9
LAB_00137161:
DEC EAX
MOV dword ptr [R14 + 0x4],EAX
BT R15D,EAX
JNC 0x001371da
LAB_0013716d:
MOV RDX,R13
MOV R13D,dword ptr [R13 + 0x24]
MOV ECX,EAX
SUB ECX,R13D
MOV qword ptr [RBP + -0x30],RDX
JNC 0x001371e5
SUB R13D,EAX
MOV EAX,EAX
LEA RCX,[0x1dfc80]
AND R15D,dword ptr [RCX + RAX*0x4]
MOV ECX,R13D
SHL R15D,CL
MOV RDI,R14
CALL 0x00136858
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R14 + 0x4],EAX
MOV EAX,dword ptr [R14]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD R15D,EAX
JMP 0x001371fa
LAB_001371b9:
SUB RBX,R12
MOV RDI,R12
MOV ESI,0x20
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001292b0
LAB_001371da:
MOV RDI,R13
MOV RSI,R14
MOV RDX,R12
JMP 0x0013722c
LAB_001371e5:
MOV dword ptr [R14 + 0x4],ECX
SHR R15D,CL
MOV EAX,dword ptr [RDX + 0x24]
LEA RCX,[0x1dfc80]
AND R15D,dword ptr [RCX + RAX*0x4]
LAB_001371fa:
MOV EDX,R15D
LEA R13,[R12 + RDX*0x1]
CMP R13,RBX
JBE 0x00137210
MOV dword ptr [R14 + 0x28],0x1
JMP 0x00137242
LAB_00137210:
MOV RDI,R12
MOV ESI,0x20
CALL 0x001292b0
CMP R13,RBX
JZ 0x00137242
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R14
MOV RDX,R13
LAB_0013722c:
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00136a15
LAB_00137242:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void uf_space_prespace_selected(long param_1,uint *param_2,void *param_3,void *param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
void *pvVar5;
uint uVar6;
pvVar5 = param_3;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar6 = *param_2;
uVar3 = 0x1f;
if ((int)uVar6 < 0) goto LAB_001371b9;
LAB_00137161:
uVar3 = uVar3 - 1;
param_2[1] = uVar3;
if ((uVar6 >> (uVar3 & 0x1f) & 1) == 0) goto LAB_0013722c;
}
else {
uVar6 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar6 >> (uVar3 & 0x1f) & 1) != 0) {
LAB_001371b9:
memset(param_3,0x20,(long)param_4 - (long)param_3);
return;
}
if (uVar3 != 0) goto LAB_00137161;
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar6 = *param_2;
if (-1 < (int)uVar6) goto LAB_0013722c;
uVar3 = 0x1f;
}
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);
uVar6 = ((uVar6 & uVar2) << (bVar4 & 0x1f)) + (*param_2 >> (-bVar4 & 0x1f));
}
else {
param_2[1] = uVar3 - uVar1;
uVar6 = uVar6 >> ((byte)(uVar3 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x24)];
}
pvVar5 = (void *)((long)param_3 + (ulong)uVar6);
if (param_4 < pvVar5) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)uVar6);
if (pvVar5 != param_4) {
LAB_0013722c:
decode_bytes(param_1,param_2,pvVar5,param_4);
return;
}
}
return;
}
|
|
64,756 |
my_charpos_mb
|
eloqsql/strings/ctype-mb.c
|
size_t my_charpos_mb(CHARSET_INFO *cs __attribute__((unused)),
const char *pos, const char *end, size_t length)
{
const char *start= pos;
while (length && pos < end)
{
uint mb_len;
pos+= (mb_len= my_ismbchar(cs, pos, end)) ? mb_len : 1;
length--;
}
return (size_t) (length ? end+2-start : pos-start);
}
|
O0
|
c
|
my_charpos_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x2d(%rbp)
je 0x4c08a
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x4c093
jmp 0x4c0dc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4b500
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x4c0b4
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x4c0be
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4c0be
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4c070
cmpq $0x0, -0x20(%rbp)
je 0x4c0f8
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x4c107
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_charpos_mb:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
loc_4C070:
xor eax, eax
cmp [rbp+var_20], 0
mov [rbp+var_2D], al
jz short loc_4C08A
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
setb al
mov [rbp+var_2D], al
loc_4C08A:
mov al, [rbp+var_2D]
test al, 1
jnz short loc_4C093
jmp short loc_4C0DC
loc_4C093:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call my_ismbchar_0
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_4C0B4
mov eax, [rbp+var_2C]
mov [rbp+var_34], eax
jmp short loc_4C0BE
loc_4C0B4:
mov eax, 1
mov [rbp+var_34], eax
jmp short $+2
loc_4C0BE:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rax
jmp short loc_4C070
loc_4C0DC:
cmp [rbp+var_20], 0
jz short loc_4C0F8
mov rax, [rbp+var_18]
add rax, 2
mov rcx, [rbp+var_28]
sub rax, rcx
mov [rbp+var_40], rax
jmp short loc_4C107
loc_4C0F8:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
sub rax, rcx
mov [rbp+var_40], rax
loc_4C107:
mov rax, [rbp+var_40]
add rsp, 40h
pop rbp
retn
|
unsigned long long my_charpos_mb(long long a1, unsigned long long a2, unsigned long long a3, long long a4)
{
unsigned int v6; // [rsp+Ch] [rbp-34h]
bool v7; // [rsp+13h] [rbp-2Dh]
unsigned int v8; // [rsp+14h] [rbp-2Ch]
unsigned long long v11; // [rsp+30h] [rbp-10h]
v11 = a2;
while ( 1 )
{
v7 = 0;
if ( a4 )
v7 = v11 < a3;
if ( !v7 )
break;
v8 = my_ismbchar_0(a1, v11, a3);
if ( v8 )
v6 = v8;
else
v6 = 1;
v11 += v6;
--a4;
}
if ( a4 )
return a3 + 2 - a2;
else
return v11 - a2;
}
|
my_charpos_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
LAB_0014c070:
XOR EAX,EAX
CMP qword ptr [RBP + -0x20],0x0
MOV byte ptr [RBP + -0x2d],AL
JZ 0x0014c08a
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
SETC AL
MOV byte ptr [RBP + -0x2d],AL
LAB_0014c08a:
MOV AL,byte ptr [RBP + -0x2d]
TEST AL,0x1
JNZ 0x0014c093
JMP 0x0014c0dc
LAB_0014c093:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0014b500
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x0014c0b4
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0014c0be
LAB_0014c0b4:
MOV EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0014c0be
LAB_0014c0be:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0014c070
LAB_0014c0dc:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0014c0f8
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0014c107
LAB_0014c0f8:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_0014c107:
MOV RAX,qword ptr [RBP + -0x40]
ADD RSP,0x40
POP RBP
RET
|
long my_charpos_mb(int8 param_1,ulong param_2,ulong param_3,long param_4)
{
long local_48;
uint local_3c;
long local_28;
ulong local_18;
local_18 = param_2;
for (local_28 = param_4; local_28 != 0 && local_18 < param_3; local_28 = local_28 + -1) {
local_3c = my_ismbchar(param_1,local_18,param_3);
if (local_3c == 0) {
local_3c = 1;
}
local_18 = local_18 + local_3c;
}
if (local_28 == 0) {
local_48 = local_18 - param_2;
}
else {
local_48 = (param_3 + 2) - param_2;
}
return local_48;
}
|
|
64,757 |
plan
|
eloqsql/unittest/mytap/tap.c
|
void
plan(int count)
{
char *config= getenv("MYTAP_CONFIG");
size_t i;
start_time= start_timer();
if (config)
skip_big_tests= strcmp(config, "big");
setvbuf(tapout, 0, _IONBF, 0); /* provide output at once */
/*
Install signal handler
*/
for (i= 0; i < sizeof(install_signal)/sizeof(*install_signal); ++i)
signal(install_signal[i].signo, install_signal[i].handler);
g_test.plan= count;
switch (count)
{
case NO_PLAN:
break;
default:
if (count > 0)
{
fprintf(tapout, "1..%d\n", count);
fflush(tapout);
}
break;
}
}
|
O0
|
c
|
plan:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x57337(%rip), %rdi # 0x7d169
callq 0x25370
movq %rax, -0x10(%rbp)
callq 0x25f20
movq %rax, 0x364de9(%rip) # 0x38ac30
cmpq $0x0, -0x10(%rbp)
je 0x25e64
movq -0x10(%rbp), %rdi
leaq 0x59cb8(%rip), %rsi # 0x7fb11
callq 0x253d0
movl %eax, 0x1ac1ec(%rip) # 0x1d2050
movq 0x1ac155(%rip), %rax # 0x1d1fc0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %edx
movq %rcx, %rsi
callq 0x25040
movq $0x0, -0x18(%rbp)
cmpq $0xb, -0x18(%rbp)
jae 0x25ecb
movq -0x18(%rbp), %rcx
leaq 0x1ac1c7(%rip), %rax # 0x1d2060
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
movq -0x18(%rbp), %rcx
leaq 0x1ac1b3(%rip), %rax # 0x1d2060
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x25330
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x25e87
movl -0x4(%rbp), %eax
movl %eax, 0x364ccc(%rip) # 0x38aba0
movl -0x4(%rbp), %eax
testl %eax, %eax
jne 0x25edf
jmp 0x25edd
jmp 0x25f11
cmpl $0x0, -0x4(%rbp)
jle 0x25f0f
movq 0x1ac0d4(%rip), %rax # 0x1d1fc0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x5727d(%rip), %rsi # 0x7d176
movb $0x0, %al
callq 0x253f0
movq 0x1ac0b9(%rip), %rax # 0x1d1fc0
movq (%rax), %rdi
callq 0x25310
jmp 0x25f11
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
plan:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
lea rdi, aMytapConfig; "MYTAP_CONFIG"
call _getenv
mov [rbp+var_10], rax
call start_timer
mov cs:start_time, rax
cmp [rbp+var_10], 0
jz short loc_25E64
mov rdi, [rbp+var_10]
lea rsi, aUndoRecordTooB+10h; "big"
call _strcmp
mov cs:skip_big_tests, eax
loc_25E64:
mov rax, cs:stdout_ptr
mov rdi, [rax]
xor eax, eax
mov ecx, eax
mov edx, 2
mov rsi, rcx
call _setvbuf
mov [rbp+var_18], 0
loc_25E87:
cmp [rbp+var_18], 0Bh
jnb short loc_25ECB
mov rcx, [rbp+var_18]
lea rax, install_signal
shl rcx, 4
add rax, rcx
mov edi, [rax]
mov rcx, [rbp+var_18]
lea rax, install_signal
shl rcx, 4
add rax, rcx
mov rsi, [rax+8]
call _signal
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_25E87
loc_25ECB:
mov eax, [rbp+var_4]
mov cs:g_test, eax
mov eax, [rbp+var_4]
test eax, eax
jnz short loc_25EDF
jmp short $+2
loc_25EDD:
jmp short loc_25F11
loc_25EDF:
cmp [rbp+var_4], 0
jle short loc_25F0F
mov rax, cs:stdout_ptr
mov rdi, [rax]
mov edx, [rbp+var_4]
lea rsi, a1D; "1..%d\n"
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
loc_25F0F:
jmp short $+2
loc_25F11:
add rsp, 20h
pop rbp
retn
|
long long plan(int a1)
{
long long result; // rax
unsigned long long i; // [rsp+8h] [rbp-18h]
long long v3; // [rsp+10h] [rbp-10h]
v3 = getenv("MYTAP_CONFIG");
start_time = start_timer();
if ( v3 )
skip_big_tests = strcmp(v3, "big");
setvbuf(stdout, 0LL, 2LL);
for ( i = 0LL; i < 0xB; ++i )
signal(*((unsigned int *)&install_signal + 4 * i), *((_QWORD *)&install_signal + 2 * i + 1));
g_test = a1;
result = (unsigned int)a1;
if ( a1 > 0 )
{
fprintf(stdout, "1..%d\n", a1);
return fflush(stdout);
}
return result;
}
|
plan:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
LEA RDI,[0x17d169]
CALL 0x00125370
MOV qword ptr [RBP + -0x10],RAX
CALL 0x00125f20
MOV qword ptr [0x0048ac30],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00125e64
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x17fb11]
CALL 0x001253d0
MOV dword ptr [0x002d2050],EAX
LAB_00125e64:
MOV RAX,qword ptr [0x002d1fc0]
MOV RDI,qword ptr [RAX]
XOR EAX,EAX
MOV ECX,EAX
MOV EDX,0x2
MOV RSI,RCX
CALL 0x00125040
MOV qword ptr [RBP + -0x18],0x0
LAB_00125e87:
CMP qword ptr [RBP + -0x18],0xb
JNC 0x00125ecb
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x2d2060]
SHL RCX,0x4
ADD RAX,RCX
MOV EDI,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x2d2060]
SHL RCX,0x4
ADD RAX,RCX
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00125330
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00125e87
LAB_00125ecb:
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [0x0048aba0],EAX
MOV EAX,dword ptr [RBP + -0x4]
TEST EAX,EAX
JNZ 0x00125edf
JMP 0x00125edd
LAB_00125edd:
JMP 0x00125f11
LAB_00125edf:
CMP dword ptr [RBP + -0x4],0x0
JLE 0x00125f0f
MOV RAX,qword ptr [0x002d1fc0]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
LEA RSI,[0x17d176]
MOV AL,0x0
CALL 0x001253f0
MOV RAX,qword ptr [0x002d1fc0]
MOV RDI,qword ptr [RAX]
CALL 0x00125310
LAB_00125f0f:
JMP 0x00125f11
LAB_00125f11:
ADD RSP,0x20
POP RBP
RET
|
void plan(uint param_1)
{
char *__s1;
ulong local_20;
__s1 = getenv("MYTAP_CONFIG");
start_time = start_timer();
if (__s1 != (char *)0x0) {
skip_big_tests = strcmp(__s1,"big");
}
setvbuf(*(FILE **)PTR_stdout_002d1fc0,(char *)0x0,2,0);
for (local_20 = 0; local_20 < 0xb; local_20 = local_20 + 1) {
signal(*(int *)(install_signal + local_20 * 0x10),
*(__sighandler_t *)(install_signal + local_20 * 0x10 + 8));
}
g_test = param_1;
if ((param_1 != 0) && (0 < (int)param_1)) {
fprintf(*(FILE **)PTR_stdout_002d1fc0,"1..%d\n",(ulong)param_1);
fflush(*(FILE **)PTR_stdout_002d1fc0);
}
return;
}
|
|
64,758 |
init_dynamic_array2
|
eloqsql/mysys/array.c
|
my_bool init_dynamic_array2(PSI_memory_key psi_key, DYNAMIC_ARRAY *array,
uint element_size, void *init_buffer,
uint init_alloc, uint alloc_increment, myf my_flags)
{
DBUG_ENTER("init_dynamic_array2");
if (!alloc_increment)
{
alloc_increment=MY_MAX((8192-MALLOC_OVERHEAD)/element_size,16);
if (init_alloc > 8 && alloc_increment > init_alloc * 2)
alloc_increment=init_alloc*2;
}
array->elements=0;
array->max_element=init_alloc;
array->alloc_increment=alloc_increment;
array->size_of_element=element_size;
array->m_psi_key= psi_key;
array->malloc_flags= my_flags;
DBUG_ASSERT((my_flags & MY_INIT_BUFFER_USED) == 0);
if ((array->buffer= init_buffer))
{
array->malloc_flags|= MY_INIT_BUFFER_USED;
DBUG_RETURN(FALSE);
}
/*
Since the dynamic array is usable even if allocation fails here malloc
should not throw an error
*/
if (init_alloc &&
!(array->buffer= (uchar*) my_malloc(psi_key, element_size*init_alloc,
MYF(my_flags))))
array->max_element=0;
DBUG_RETURN(FALSE);
}
|
O3
|
c
|
init_dynamic_array2:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %r11d
movq %rsi, %rbx
movq 0x10(%rbp), %r10
testl %r9d, %r9d
jne 0x9695f
movl $0x10, %r9d
cmpl $0x1e1, %r11d # imm = 0x1E1
ja 0x9694e
movw $0x1ff8, %ax # imm = 0x1FF8
xorl %edx, %edx
divw %r11w
movzwl %ax, %r9d
cmpl $0x9, %r8d
jb 0x9695f
leal (%r8,%r8), %eax
cmpl %eax, %r9d
cmovael %eax, %r9d
movl $0x0, 0x8(%rbx)
movl %r8d, 0xc(%rbx)
movl %r9d, 0x10(%rbx)
movl %r11d, 0x14(%rbx)
movl %edi, 0x18(%rbx)
movq %r10, 0x20(%rbx)
movq %rcx, (%rbx)
testq %rcx, %rcx
je 0x96995
orq $0x100, %r10 # imm = 0x100
movq %r10, 0x20(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testl %r8d, %r8d
je 0x9698c
imull %r11d, %r8d
movq %r8, %rsi
movq %r10, %rdx
callq 0xa6f99
movq %rax, (%rbx)
testq %rax, %rax
jne 0x9698c
movl $0x0, 0xc(%rbx)
jmp 0x9698c
|
init_dynamic_array2:
push rbp
mov rbp, rsp
push rbx
push rax
mov r11d, edx
mov rbx, rsi
mov r10, [rbp+arg_0]
test r9d, r9d
jnz short loc_9695F
mov r9d, 10h
cmp r11d, 1E1h
ja short loc_9694E
mov ax, 1FF8h
xor edx, edx
div r11w
movzx r9d, ax
loc_9694E:
cmp r8d, 9
jb short loc_9695F
lea eax, [r8+r8]
cmp r9d, eax
cmovnb r9d, eax
loc_9695F:
mov dword ptr [rbx+8], 0
mov [rbx+0Ch], r8d
mov [rbx+10h], r9d
mov [rbx+14h], r11d
mov [rbx+18h], edi
mov [rbx+20h], r10
mov [rbx], rcx
test rcx, rcx
jz short loc_96995
or r10, 100h
mov [rbx+20h], r10
loc_9698C:
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
loc_96995:
test r8d, r8d
jz short loc_9698C
imul r8d, r11d
mov rsi, r8
mov rdx, r10
call my_malloc
mov [rbx], rax
test rax, rax
jnz short loc_9698C
mov dword ptr [rbx+0Ch], 0
jmp short loc_9698C
|
long long init_dynamic_array2(
long long a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
unsigned int a6,
long long a7)
{
long long v8; // rax
if ( !a6 )
{
a6 = 16;
if ( a3 <= 0x1E1 )
a6 = 0x1FF8u / (unsigned __int16)a3;
if ( a5 >= 9 && a6 >= 2 * a5 )
a6 = 2 * a5;
}
*(_DWORD *)(a2 + 8) = 0;
*(_DWORD *)(a2 + 12) = a5;
*(_DWORD *)(a2 + 16) = a6;
*(_DWORD *)(a2 + 20) = a3;
*(_DWORD *)(a2 + 24) = a1;
*(_QWORD *)(a2 + 32) = a7;
*(_QWORD *)a2 = a4;
if ( a4 )
{
*(_QWORD *)(a2 + 32) = a7 | 0x100;
}
else if ( a5 )
{
v8 = my_malloc(a1, a3 * a5, a7);
*(_QWORD *)a2 = v8;
if ( !v8 )
*(_DWORD *)(a2 + 12) = 0;
}
return 0LL;
}
|
init_dynamic_array2:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV R11D,EDX
MOV RBX,RSI
MOV R10,qword ptr [RBP + 0x10]
TEST R9D,R9D
JNZ 0x0019695f
MOV R9D,0x10
CMP R11D,0x1e1
JA 0x0019694e
MOV AX,0x1ff8
XOR EDX,EDX
DIV R11W
MOVZX R9D,AX
LAB_0019694e:
CMP R8D,0x9
JC 0x0019695f
LEA EAX,[R8 + R8*0x1]
CMP R9D,EAX
CMOVNC R9D,EAX
LAB_0019695f:
MOV dword ptr [RBX + 0x8],0x0
MOV dword ptr [RBX + 0xc],R8D
MOV dword ptr [RBX + 0x10],R9D
MOV dword ptr [RBX + 0x14],R11D
MOV dword ptr [RBX + 0x18],EDI
MOV qword ptr [RBX + 0x20],R10
MOV qword ptr [RBX],RCX
TEST RCX,RCX
JZ 0x00196995
OR R10,0x100
MOV qword ptr [RBX + 0x20],R10
LAB_0019698c:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00196995:
TEST R8D,R8D
JZ 0x0019698c
IMUL R8D,R11D
MOV RSI,R8
MOV RDX,R10
CALL 0x001a6f99
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JNZ 0x0019698c
MOV dword ptr [RBX + 0xc],0x0
JMP 0x0019698c
|
int8
init_dynamic_array2(int4 param_1,long *param_2,uint param_3,long param_4,uint param_5,
uint param_6,ulong param_7)
{
long lVar1;
if (param_6 == 0) {
param_6 = 0x10;
if (param_3 < 0x1e2) {
param_6 = 0x1ff8 / (param_3 & 0xffff);
}
if ((8 < param_5) && (param_5 * 2 <= param_6)) {
param_6 = param_5 * 2;
}
}
*(int4 *)(param_2 + 1) = 0;
*(uint *)((long)param_2 + 0xc) = param_5;
*(uint *)(param_2 + 2) = param_6;
*(uint *)((long)param_2 + 0x14) = param_3;
*(int4 *)(param_2 + 3) = param_1;
param_2[4] = param_7;
*param_2 = param_4;
if (param_4 == 0) {
if (param_5 != 0) {
lVar1 = my_malloc(param_1,param_5 * param_3,param_7);
*param_2 = lVar1;
if (lVar1 == 0) {
*(int4 *)((long)param_2 + 0xc) = 0;
}
}
}
else {
param_2[4] = param_7 | 0x100;
}
return 0;
}
|
|
64,759 |
UpscalerGGML::UpscalerGGML(int)
|
7CodeWizard[P]stablediffusion/upscaler.cpp
|
UpscalerGGML(int n_threads)
: n_threads(n_threads) {
}
|
O2
|
cpp
|
UpscalerGGML::UpscalerGGML(int):
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, (%rdi)
movl %esi, %ebp
movl $0x1, 0x8(%rdi)
addq $0x10, %rdi
callq 0x57e5c
leaq 0x770(%rbx), %rax
movq %rax, 0x760(%rbx)
andq $0x0, 0x768(%rbx)
movb $0x0, 0x770(%rbx)
movl %ebp, 0x780(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
_ZN12UpscalerGGMLC2Ei:
push rbp
push rbx
push rax
mov rbx, rdi
and qword ptr [rdi], 0
mov ebp, esi
mov dword ptr [rdi+8], 1
add rdi, 10h; this
call _ZN6ESRGANC2Ev; ESRGAN::ESRGAN(void)
lea rax, [rbx+770h]
mov [rbx+760h], rax
and qword ptr [rbx+768h], 0
mov byte ptr [rbx+770h], 0
mov [rbx+780h], ebp
add rsp, 8
pop rbx
pop rbp
retn
|
void UpscalerGGML::UpscalerGGML(UpscalerGGML *this, int a2)
{
*(_QWORD *)this = 0LL;
*((_DWORD *)this + 2) = 1;
ESRGAN::ESRGAN((UpscalerGGML *)((char *)this + 16));
*((_QWORD *)this + 236) = (char *)this + 1904;
*((_QWORD *)this + 237) = 0LL;
*((_BYTE *)this + 1904) = 0;
*((_DWORD *)this + 480) = a2;
}
|
UpscalerGGML:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
AND qword ptr [RDI],0x0
MOV EBP,ESI
MOV dword ptr [RDI + 0x8],0x1
ADD RDI,0x10
CALL 0x00157e5c
LEA RAX,[RBX + 0x770]
MOV qword ptr [RBX + 0x760],RAX
AND qword ptr [RBX + 0x768],0x0
MOV byte ptr [RBX + 0x770],0x0
MOV dword ptr [RBX + 0x780],EBP
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* UpscalerGGML::UpscalerGGML(int) */
void __thiscall UpscalerGGML::UpscalerGGML(UpscalerGGML *this,int param_1)
{
*(int8 *)this = 0;
*(int4 *)(this + 8) = 1;
ESRGAN::ESRGAN((ESRGAN *)(this + 0x10));
*(UpscalerGGML **)(this + 0x760) = this + 0x770;
*(int8 *)(this + 0x768) = 0;
this[0x770] = (UpscalerGGML)0x0;
*(int *)(this + 0x780) = param_1;
return;
}
|
|
64,760 |
JS_ConcatString
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ConcatString(JSContext *ctx, JSValue op1, JSValue op2)
{
JSValue ret;
JSString *p1, *p2;
if (unlikely(JS_VALUE_GET_TAG(op1) != JS_TAG_STRING)) {
op1 = JS_ToStringFree(ctx, op1);
if (JS_IsException(op1)) {
JS_FreeValue(ctx, op2);
return JS_EXCEPTION;
}
}
if (unlikely(JS_VALUE_GET_TAG(op2) != JS_TAG_STRING)) {
op2 = JS_ToStringFree(ctx, op2);
if (JS_IsException(op2)) {
JS_FreeValue(ctx, op1);
return JS_EXCEPTION;
}
}
p1 = JS_VALUE_GET_STRING(op1);
p2 = JS_VALUE_GET_STRING(op2);
/* XXX: could also check if p1 is empty */
if (p2->len == 0) {
goto ret_op1;
}
if (p1->header.ref_count == 1 && p1->is_wide_char == p2->is_wide_char
&& js_malloc_usable_size(ctx, p1) >= sizeof(*p1) + ((p1->len + p2->len) << p2->is_wide_char) + 1 - p1->is_wide_char) {
/* Concatenate in place in available space at the end of p1 */
if (p1->is_wide_char) {
memcpy(p1->u.str16 + p1->len, p2->u.str16, p2->len << 1);
p1->len += p2->len;
} else {
memcpy(p1->u.str8 + p1->len, p2->u.str8, p2->len);
p1->len += p2->len;
p1->u.str8[p1->len] = '\0';
}
ret_op1:
JS_FreeValue(ctx, op2);
return op1;
}
ret = JS_ConcatString1(ctx, p1, p2);
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
return ret;
}
|
O0
|
c
|
JS_ConcatString:
subq $0x88, %rsp
movq %rsi, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movq 0x70(%rsp), %rax
cmpl $-0x7, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x69981
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x4f3b0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x6997f
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x229d0
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0x69ccb
jmp 0x69981
movq 0x60(%rsp), %rax
cmpl $-0x7, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x69a12
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x4f3b0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x69a10
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x229d0
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0x69ccb
jmp 0x69a12
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
cmpl $0x0, %eax
jne 0x69a3f
jmp 0x69c2f
movq 0x38(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x69c5c
movq 0x38(%rsp), %rax
movq 0x4(%rax), %rax
shrq $0x1f, %rax
andq $0x1, %rax
movzbl %al, %eax
movq 0x30(%rsp), %rcx
movq 0x4(%rcx), %rcx
shrq $0x1f, %rcx
andq $0x1, %rcx
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x69c5c
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x20cb0
movq 0x38(%rsp), %rcx
movq 0x4(%rcx), %rcx
andq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
movl %ecx, %edx
movq 0x30(%rsp), %rcx
movq 0x4(%rcx), %rcx
andq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
addl %ecx, %edx
movq 0x30(%rsp), %rcx
movq 0x4(%rcx), %rcx
shrq $0x1f, %rcx
andq $0x1, %rcx
movzbl %cl, %ecx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
addq $0x18, %rcx
addq $0x1, %rcx
movq 0x38(%rsp), %rdx
movq 0x4(%rdx), %rdx
shrq $0x1f, %rdx
andq $0x1, %rdx
movzbl %dl, %edx
subq %rdx, %rcx
cmpq %rcx, %rax
jb 0x69c5c
movq 0x38(%rsp), %rax
movq 0x4(%rax), %rax
shrq $0x1f, %rax
andq $0x1, %rax
cmpb $0x0, %al
je 0x69b93
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
movq 0x38(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
cltq
shlq %rax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
addq $0x18, %rsi
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
shll %eax
movslq %eax, %rdx
callq 0xe5a0
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %edx
movq 0x38(%rsp), %rax
movq 0x4(%rax), %rcx
andq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
addl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
movq 0x4(%rax), %rcx
andq $0x7fffffff, %rdx # imm = 0x7FFFFFFF
andq $-0x80000000, %rcx # imm = 0x80000000
orq %rdx, %rcx
movq %rcx, 0x4(%rax)
jmp 0x69c2d
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
movq 0x38(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
cltq
addq %rax, %rdi
movq 0x30(%rsp), %rsi
addq $0x18, %rsi
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %edx
callq 0xe5a0
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %edx
movq 0x38(%rsp), %rax
movq 0x4(%rax), %rcx
andq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
addl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
movq 0x4(%rax), %rcx
andq $0x7fffffff, %rdx # imm = 0x7FFFFFFF
andq $-0x80000000, %rcx # imm = 0x80000000
orq %rdx, %rcx
movq %rcx, 0x4(%rax)
movq 0x38(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x4(%rcx), %rcx
andq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
movl %ecx, %ecx
movb $0x0, 0x18(%rax,%rcx)
jmp 0x69c2f
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x229d0
movq 0x68(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x69ccb
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x70210
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x229d0
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x229d0
movq 0x40(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rdx
addq $0x88, %rsp
retq
|
JS_ConcatString:
sub rsp, 88h
mov [rsp+88h+var_20], rsi
mov [rsp+88h+var_18], rdx
mov [rsp+88h+var_30], rcx
mov [rsp+88h+var_28], r8
mov [rsp+88h+var_38], rdi
mov rax, [rsp+88h+var_18]
cmp eax, 0FFFFFFF9h
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_69981
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_20]
mov rdx, [rsp+88h+var_18]
call JS_ToStringFree
mov [rsp+88h+var_68], rax
mov [rsp+88h+var_60], rdx
mov rax, [rsp+88h+var_68]
mov [rsp+88h+var_20], rax
mov rax, [rsp+88h+var_60]
mov [rsp+88h+var_18], rax
mov rdi, [rsp+88h+var_20]
mov rsi, [rsp+88h+var_18]
call JS_IsException_1
cmp eax, 0
jz short loc_6997F
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_30]
mov rdx, [rsp+88h+var_28]
call JS_FreeValue
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp loc_69CCB
loc_6997F:
jmp short $+2
loc_69981:
mov rax, [rsp+88h+var_28]
cmp eax, 0FFFFFFF9h
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_69A12
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_30]
mov rdx, [rsp+88h+var_28]
call JS_ToStringFree
mov [rsp+88h+var_78], rax
mov [rsp+88h+var_70], rdx
mov rax, [rsp+88h+var_78]
mov [rsp+88h+var_30], rax
mov rax, [rsp+88h+var_70]
mov [rsp+88h+var_28], rax
mov rdi, [rsp+88h+var_30]
mov rsi, [rsp+88h+var_28]
call JS_IsException_1
cmp eax, 0
jz short loc_69A10
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_20]
mov rdx, [rsp+88h+var_18]
call JS_FreeValue
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp loc_69CCB
loc_69A10:
jmp short $+2
loc_69A12:
mov rax, [rsp+88h+var_20]
mov [rsp+88h+var_50], rax
mov rax, [rsp+88h+var_30]
mov [rsp+88h+var_58], rax
mov rax, [rsp+88h+var_58]
mov rax, [rax+4]
and rax, 7FFFFFFFh
cmp eax, 0
jnz short loc_69A3F
jmp loc_69C2F
loc_69A3F:
mov rax, [rsp+88h+var_50]
cmp dword ptr [rax], 1
jnz loc_69C5C
mov rax, [rsp+88h+var_50]
mov rax, [rax+4]
shr rax, 1Fh
and rax, 1
movzx eax, al
mov rcx, [rsp+88h+var_58]
mov rcx, [rcx+4]
shr rcx, 1Fh
and rcx, 1
movzx ecx, cl
cmp eax, ecx
jnz loc_69C5C
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_50]
call js_malloc_usable_size
mov rcx, [rsp+88h+var_50]
mov rcx, [rcx+4]
and rcx, 7FFFFFFFh
mov edx, ecx
mov rcx, [rsp+88h+var_58]
mov rcx, [rcx+4]
and rcx, 7FFFFFFFh
add edx, ecx
mov rcx, [rsp+88h+var_58]
mov rcx, [rcx+4]
shr rcx, 1Fh
and rcx, 1
movzx ecx, cl
shl edx, cl
mov ecx, edx
movsxd rcx, ecx
add rcx, 18h
add rcx, 1
mov rdx, [rsp+88h+var_50]
mov rdx, [rdx+4]
shr rdx, 1Fh
and rdx, 1
movzx edx, dl
sub rcx, rdx
cmp rax, rcx
jb loc_69C5C
mov rax, [rsp+88h+var_50]
mov rax, [rax+4]
shr rax, 1Fh
and rax, 1
cmp al, 0
jz loc_69B93
mov rdi, [rsp+88h+var_50]
add rdi, 18h
mov rax, [rsp+88h+var_50]
mov rax, [rax+4]
and rax, 7FFFFFFFh
cdqe
shl rax, 1
add rdi, rax
mov rsi, [rsp+88h+var_58]
add rsi, 18h
mov rax, [rsp+88h+var_58]
mov rax, [rax+4]
and rax, 7FFFFFFFh
shl eax, 1
movsxd rdx, eax
call _memcpy
mov rax, [rsp+88h+var_58]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov edx, eax
mov rax, [rsp+88h+var_50]
mov rcx, [rax+4]
and rcx, 7FFFFFFFh
add ecx, edx
mov ecx, ecx
mov edx, ecx
mov rcx, [rax+4]
and rdx, 7FFFFFFFh
and rcx, 0FFFFFFFF80000000h
or rcx, rdx
mov [rax+4], rcx
jmp loc_69C2D
loc_69B93:
mov rdi, [rsp+88h+var_50]
add rdi, 18h
mov rax, [rsp+88h+var_50]
mov rax, [rax+4]
and rax, 7FFFFFFFh
cdqe
add rdi, rax
mov rsi, [rsp+88h+var_58]
add rsi, 18h
mov rax, [rsp+88h+var_58]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov eax, eax
mov edx, eax
call _memcpy
mov rax, [rsp+88h+var_58]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov edx, eax
mov rax, [rsp+88h+var_50]
mov rcx, [rax+4]
and rcx, 7FFFFFFFh
add ecx, edx
mov ecx, ecx
mov edx, ecx
mov rcx, [rax+4]
and rdx, 7FFFFFFFh
and rcx, 0FFFFFFFF80000000h
or rcx, rdx
mov [rax+4], rcx
mov rax, [rsp+88h+var_50]
mov rcx, [rsp+88h+var_50]
mov rcx, [rcx+4]
and rcx, 7FFFFFFFh
mov ecx, ecx
mov byte ptr [rax+rcx+18h], 0
loc_69C2D:
jmp short $+2
loc_69C2F:
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_30]
mov rdx, [rsp+88h+var_28]
call JS_FreeValue
mov rax, [rsp+88h+var_20]
mov [rsp+88h+var_10], rax
mov rax, [rsp+88h+var_18]
mov [rsp+88h+var_8], rax
jmp short loc_69CCB
loc_69C5C:
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_50]
mov rdx, [rsp+88h+var_58]
call JS_ConcatString1
mov [rsp+88h+var_88], rax
mov [rsp+88h+var_80], rdx
mov rax, [rsp+88h+var_88]
mov [rsp+88h+var_48], rax
mov rax, [rsp+88h+var_80]
mov [rsp+88h+var_40], rax
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_20]
mov rdx, [rsp+88h+var_18]
call JS_FreeValue
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_30]
mov rdx, [rsp+88h+var_28]
call JS_FreeValue
mov rax, [rsp+88h+var_48]
mov [rsp+88h+var_10], rax
mov rax, [rsp+88h+var_40]
mov [rsp+88h+var_8], rax
loc_69CCB:
mov rax, [rsp+88h+var_10]
mov rdx, [rsp+88h+var_8]
add rsp, 88h
retn
|
long long JS_ConcatString(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
long long v6; // rdx
long long v7; // rdx
long long v9; // [rsp+0h] [rbp-88h]
long long v10; // [rsp+58h] [rbp-30h]
long long v11; // [rsp+60h] [rbp-28h]
long long v12; // [rsp+68h] [rbp-20h]
long long v13; // [rsp+70h] [rbp-18h]
long long v14; // [rsp+78h] [rbp-10h]
v12 = a2;
v13 = a3;
v10 = a4;
v11 = a5;
if ( (_DWORD)a3 == -7 || (v12 = JS_ToStringFree(a1, a2, a3, a4, a5, a6), v13 = v6, !JS_IsException_1(v12, v6)) )
{
if ( (_DWORD)v11 == -7 || (v10 = JS_ToStringFree(a1, v10, v11, a4, a5, a6), v11 = v7, !JS_IsException_1(v10, v7)) )
{
if ( (*(_DWORD *)(v10 + 4) & 0x7FFFFFFF) != 0 )
{
if ( *(_DWORD *)v12 != 1
|| ((*(_QWORD *)(v12 + 4) & 0x80000000LL) != 0) != ((*(_QWORD *)(v10 + 4) & 0x80000000LL) != 0)
|| js_malloc_usable_size(a1, v12) < (int)(((*(_QWORD *)(v10 + 4) & 0x7FFFFFFF)
+ (*(_QWORD *)(v12 + 4) & 0x7FFFFFFF)) << ((*(_QWORD *)(v10 + 4) & 0x80000000LL) != 0))
+ 25LL
- (unsigned long long)((*(_QWORD *)(v12 + 4) & 0x80000000LL) != 0) )
{
v9 = JS_ConcatString1(a1, v12, v10);
JS_FreeValue(a1, v12, v13);
JS_FreeValue(a1, v10, v11);
return v9;
}
if ( (*(_QWORD *)(v12 + 4) & 0x80000000LL) != 0 )
{
memcpy(2LL * (*(_QWORD *)(v12 + 4) & 0x7FFFFFFF) + v12 + 24, v10 + 24, (int)(2 * *(_QWORD *)(v10 + 4)));
*(_QWORD *)(v12 + 4) = ((*(_QWORD *)(v10 + 4) & 0x7FFFFFFF) + (*(_QWORD *)(v12 + 4) & 0x7FFFFFFF)) & 0x7FFFFFFF | *(_QWORD *)(v12 + 4) & 0xFFFFFFFF80000000LL;
}
else
{
memcpy((*(_QWORD *)(v12 + 4) & 0x7FFFFFFF) + v12 + 24, v10 + 24, *(_DWORD *)(v10 + 4) & 0x7FFFFFFF);
*(_QWORD *)(v12 + 4) = ((*(_QWORD *)(v10 + 4) & 0x7FFFFFFF) + (*(_QWORD *)(v12 + 4) & 0x7FFFFFFF)) & 0x7FFFFFFF | *(_QWORD *)(v12 + 4) & 0xFFFFFFFF80000000LL;
*(_BYTE *)(v12 + (*(_DWORD *)(v12 + 4) & 0x7FFFFFFF) + 24) = 0;
}
}
JS_FreeValue(a1, v10, v11);
return v12;
}
else
{
JS_FreeValue(a1, v12, v13);
LODWORD(v14) = 0;
}
}
else
{
JS_FreeValue(a1, v10, v11);
LODWORD(v14) = 0;
}
return v14;
}
|
JS_ConcatString:
SUB RSP,0x88
MOV qword ptr [RSP + 0x68],RSI
MOV qword ptr [RSP + 0x70],RDX
MOV qword ptr [RSP + 0x58],RCX
MOV qword ptr [RSP + 0x60],R8
MOV qword ptr [RSP + 0x50],RDI
MOV RAX,qword ptr [RSP + 0x70]
CMP EAX,-0x7
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00169981
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x0014f3b0
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x70]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x0016997f
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
CALL 0x001229d0
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x00169ccb
LAB_0016997f:
JMP 0x00169981
LAB_00169981:
MOV RAX,qword ptr [RSP + 0x60]
CMP EAX,-0x7
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00169a12
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
CALL 0x0014f3b0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x60]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x00169a10
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x001229d0
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x00169ccb
LAB_00169a10:
JMP 0x00169a12
LAB_00169a12:
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
CMP EAX,0x0
JNZ 0x00169a3f
JMP 0x00169c2f
LAB_00169a3f:
MOV RAX,qword ptr [RSP + 0x38]
CMP dword ptr [RAX],0x1
JNZ 0x00169c5c
MOV RAX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RAX + 0x4]
SHR RAX,0x1f
AND RAX,0x1
MOVZX EAX,AL
MOV RCX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RCX + 0x4]
SHR RCX,0x1f
AND RCX,0x1
MOVZX ECX,CL
CMP EAX,ECX
JNZ 0x00169c5c
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x00120cb0
MOV RCX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RCX + 0x4]
AND RCX,0x7fffffff
MOV EDX,ECX
MOV RCX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RCX + 0x4]
AND RCX,0x7fffffff
ADD EDX,ECX
MOV RCX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RCX + 0x4]
SHR RCX,0x1f
AND RCX,0x1
MOVZX ECX,CL
SHL EDX,CL
MOV ECX,EDX
MOVSXD RCX,ECX
ADD RCX,0x18
ADD RCX,0x1
MOV RDX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RDX + 0x4]
SHR RDX,0x1f
AND RDX,0x1
MOVZX EDX,DL
SUB RCX,RDX
CMP RAX,RCX
JC 0x00169c5c
MOV RAX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RAX + 0x4]
SHR RAX,0x1f
AND RAX,0x1
CMP AL,0x0
JZ 0x00169b93
MOV RDI,qword ptr [RSP + 0x38]
ADD RDI,0x18
MOV RAX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
CDQE
SHL RAX,0x1
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x30]
ADD RSI,0x18
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
SHL EAX,0x1
MOVSXD RDX,EAX
CALL 0x0010e5a0
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV EDX,EAX
MOV RAX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RAX + 0x4]
AND RCX,0x7fffffff
ADD ECX,EDX
MOV ECX,ECX
MOV EDX,ECX
MOV RCX,qword ptr [RAX + 0x4]
AND RDX,0x7fffffff
AND RCX,-0x80000000
OR RCX,RDX
MOV qword ptr [RAX + 0x4],RCX
JMP 0x00169c2d
LAB_00169b93:
MOV RDI,qword ptr [RSP + 0x38]
ADD RDI,0x18
MOV RAX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
CDQE
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x30]
ADD RSI,0x18
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0010e5a0
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV EDX,EAX
MOV RAX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RAX + 0x4]
AND RCX,0x7fffffff
ADD ECX,EDX
MOV ECX,ECX
MOV EDX,ECX
MOV RCX,qword ptr [RAX + 0x4]
AND RDX,0x7fffffff
AND RCX,-0x80000000
OR RCX,RDX
MOV qword ptr [RAX + 0x4],RCX
MOV RAX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RCX + 0x4]
AND RCX,0x7fffffff
MOV ECX,ECX
MOV byte ptr [RAX + RCX*0x1 + 0x18],0x0
LAB_00169c2d:
JMP 0x00169c2f
LAB_00169c2f:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
CALL 0x001229d0
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x80],RAX
JMP 0x00169ccb
LAB_00169c5c:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x00170210
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x001229d0
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
CALL 0x001229d0
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x80],RAX
LAB_00169ccb:
MOV RAX,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
ADD RSP,0x88
RET
|
int1 [16]
JS_ConcatString(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int1 auVar1 [16];
int iVar2;
ulong uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
long local_30;
int8 local_28;
int *local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
auVar5._8_8_ = param_5;
auVar5._0_8_ = param_4;
auVar4._8_8_ = param_3;
auVar4._0_8_ = param_2;
if ((int)param_3 != -7) {
auVar4 = JS_ToStringFree(param_1,param_2,param_3);
iVar2 = JS_IsException(auVar4._0_8_,auVar4._8_8_);
if (iVar2 != 0) {
JS_FreeValue(param_1,param_4,param_5);
local_10 = 0;
local_8 = 6;
goto LAB_00169ccb;
}
}
local_18 = auVar4._8_8_;
local_20 = auVar4._0_8_;
if ((int)param_5 != -7) {
auVar5 = JS_ToStringFree(param_1,param_4,param_5);
iVar2 = JS_IsException(auVar5._0_8_,auVar5._8_8_);
if (iVar2 != 0) {
JS_FreeValue(param_1,local_20,local_18);
local_10 = 0;
local_8 = 6;
goto LAB_00169ccb;
}
}
local_28 = auVar5._8_8_;
local_30 = auVar5._0_8_;
if ((*(ulong *)(local_30 + 4) & 0x7fffffff) != 0) {
if (((*local_20 != 1) ||
(((byte)(*(ulong *)(local_20 + 1) >> 0x1f) & 1) !=
((byte)(*(ulong *)(local_30 + 4) >> 0x1f) & 1))) ||
(uVar3 = js_malloc_usable_size(param_1,local_20),
uVar3 < ((long)(int)(((uint)*(int8 *)(local_20 + 1) & 0x7fffffff) +
((uint)*(int8 *)(local_30 + 4) & 0x7fffffff) <<
((byte)(*(ulong *)(local_30 + 4) >> 0x1f) & 1)) + 0x19) -
(ulong)((byte)(*(ulong *)(local_20 + 1) >> 0x1f) & 1))) {
auVar4 = JS_ConcatString1(param_1,local_20,local_30);
local_8 = auVar4._8_8_;
JS_FreeValue(param_1,local_20,local_18);
JS_FreeValue(param_1,local_30,local_28);
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
goto LAB_00169ccb;
}
if ((*(ulong *)(local_20 + 1) >> 0x1f & 1) == 0) {
memcpy((void *)((long)local_20 +
(long)(int)((uint)*(int8 *)(local_20 + 1) & 0x7fffffff) + 0x18),
(void *)(local_30 + 0x18),(ulong)((uint)*(int8 *)(local_30 + 4) & 0x7fffffff));
*(ulong *)(local_20 + 1) =
*(ulong *)(local_20 + 1) & 0xffffffff80000000 |
(ulong)(((uint)*(int8 *)(local_20 + 1) & 0x7fffffff) +
((uint)*(int8 *)(local_30 + 4) & 0x7fffffff)) & 0x7fffffff;
*(int1 *)
((long)local_20 + (ulong)((uint)*(int8 *)(local_20 + 1) & 0x7fffffff) + 0x18) = 0;
}
else {
memcpy((void *)((long)local_20 +
(long)(int)((uint)*(int8 *)(local_20 + 1) & 0x7fffffff) * 2 + 0x18),
(void *)(local_30 + 0x18),(long)((int)*(int8 *)(local_30 + 4) << 1));
*(ulong *)(local_20 + 1) =
*(ulong *)(local_20 + 1) & 0xffffffff80000000 |
(ulong)(((uint)*(int8 *)(local_20 + 1) & 0x7fffffff) +
((uint)*(int8 *)(local_30 + 4) & 0x7fffffff)) & 0x7fffffff;
}
}
JS_FreeValue(param_1,local_30,local_28);
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
local_8 = local_18;
LAB_00169ccb:
auVar1._4_4_ = uStack_c;
auVar1._0_4_ = local_10;
auVar1._8_8_ = local_8;
return auVar1;
}
|
|
64,761 |
JS_ConcatString
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ConcatString(JSContext *ctx, JSValue op1, JSValue op2)
{
JSValue ret;
JSString *p1, *p2;
if (unlikely(JS_VALUE_GET_TAG(op1) != JS_TAG_STRING)) {
op1 = JS_ToStringFree(ctx, op1);
if (JS_IsException(op1)) {
JS_FreeValue(ctx, op2);
return JS_EXCEPTION;
}
}
if (unlikely(JS_VALUE_GET_TAG(op2) != JS_TAG_STRING)) {
op2 = JS_ToStringFree(ctx, op2);
if (JS_IsException(op2)) {
JS_FreeValue(ctx, op1);
return JS_EXCEPTION;
}
}
p1 = JS_VALUE_GET_STRING(op1);
p2 = JS_VALUE_GET_STRING(op2);
/* XXX: could also check if p1 is empty */
if (p2->len == 0) {
goto ret_op1;
}
if (p1->header.ref_count == 1 && p1->is_wide_char == p2->is_wide_char
&& js_malloc_usable_size(ctx, p1) >= sizeof(*p1) + ((p1->len + p2->len) << p2->is_wide_char) + 1 - p1->is_wide_char) {
/* Concatenate in place in available space at the end of p1 */
if (p1->is_wide_char) {
memcpy(p1->u.str16 + p1->len, p2->u.str16, p2->len << 1);
p1->len += p2->len;
} else {
memcpy(p1->u.str8 + p1->len, p2->u.str8, p2->len);
p1->len += p2->len;
p1->u.str8[p1->len] = '\0';
}
ret_op1:
JS_FreeValue(ctx, op2);
return op1;
}
ret = JS_ConcatString1(ctx, p1, p2);
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
return ret;
}
|
O1
|
c
|
JS_ConcatString:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
cmpl $-0x7, %ebx
jne 0x3fb3a
movl $0xfffffff9, %eax # imm = 0xFFFFFFF9
cmpl %eax, %ebp
jne 0x3fb62
movq 0x18(%rsp), %r12
movq 0x4(%r12), %rax
testl $0x7fffffff, %eax # imm = 0x7FFFFFFF
je 0x3fa6b
movq %r15, 0x8(%rsp)
movq 0x10(%rsp), %r13
cmpl $0x1, (%r13)
jne 0x3f8d3
xorl 0x4(%r13), %eax
js 0x3f8d3
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %r13, %rdi
callq *0x20(%rax)
movq 0x4(%r13), %r9
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
movslq %r9d, %rsi
movl %r9d, %edi
andl %r8d, %edi
movq 0x4(%r12), %rdx
andl %edx, %r8d
addl %r8d, %edi
movl %edx, %ecx
shrl $0x1f, %ecx
shll %cl, %edi
movslq %edi, %rcx
sarq $0x1f, %rsi
addq %rsi, %rcx
addq $0x19, %rcx
cmpq %rcx, %rax
jae 0x3f9b9
movq 0x4(%r13), %rax
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movl %eax, %r14d
andl %ecx, %r14d
movq 0x4(%r12), %r15
andl %r15d, %ecx
addq %rcx, %r14
cmpl $0x40000000, %r14d # imm = 0x40000000
jb 0x3f920
leaq 0x5d969(%rip), %rsi # 0x9d266
movq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %eax, %eax
callq 0x1fec9
movq $0x0, 0x20(%rsp)
movl $0x6, %r15d
jmp 0x3fafb
orl %eax, %r15d
movl %r15d, %edx
shrl $0x1f, %edx
movq 0x8(%rsp), %rdi
movl %r14d, %esi
callq 0x1ff5f
testq %rax, %rax
je 0x3f9a1
movq %rbp, 0x30(%rsp)
movq %rax, %rbp
addq $0x18, %rbp
testl %r15d, %r15d
js 0x3fa03
leaq 0x18(%r13), %rsi
movl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
movq 0x4(%r13), %rdx
andq %r15, %rdx
movq %rax, 0x28(%rsp)
movq %rbp, %rdi
callq 0xe5a0
movq 0x4(%r13), %rdi
andq %r15, %rdi
addq %rbp, %rdi
andq 0x4(%r12), %r15
addq $0x18, %r12
movq %r12, %rsi
movq %r15, %rdx
callq 0xe5a0
movq 0x28(%rsp), %rsi
movb $0x0, (%rbp,%r14)
movq 0x8(%rsp), %r13
jmp 0x3faea
movl $0x0, 0x20(%rsp)
movl $0x6, %r15d
movq 0x8(%rsp), %r13
jmp 0x3fafb
leaq 0x18(%r13), %rdi
movl %r9d, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
leaq 0x18(%r12), %rsi
testl %r9d, %r9d
js 0x3fa39
addq %rax, %rdi
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
callq 0xe5a0
movq 0x4(%r13), %rax
movl 0x4(%r12), %ecx
addl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andq $-0x80000000, %rax # imm = 0x80000000
orq %rcx, %rax
movq %rax, 0x4(%r13)
movb $0x0, 0x18(%r13,%rcx)
jmp 0x3fa66
movq 0x4(%r13), %rdi
movl %edi, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
leaq 0x18(%r13), %rsi
movq %rax, %r14
testl %edi, %edi
js 0x3fa86
testl %edx, %edx
je 0x3fa90
andl $0x7fffffff, %edi # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movzbl (%rsi,%rcx), %edx
movw %dx, (%rbp,%rcx,2)
incq %rcx
cmpq %rcx, %rdi
jne 0x3fa26
jmp 0x3fa90
leaq (%rdi,%rax,2), %rdi
addl %r8d, %r8d
movslq %r8d, %rdx
callq 0xe5a0
movq 0x4(%r13), %rax
movl 0x4(%r12), %ecx
addl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andq $-0x80000000, %rax # imm = 0x80000000
orq %rcx, %rax
movq %rax, 0x4(%r13)
movq 0x8(%rsp), %r15
movq 0x18(%rsp), %rsi
movq 0x18(%r15), %rdi
movq %rbp, %rdx
callq 0x1ccb2
movq 0x10(%rsp), %r14
jmp 0x3fb25
addl %edx, %edx
movq %rbp, %rdi
callq 0xe5a0
movl 0x4(%r13), %eax
addl %eax, %eax
addq %rax, %rbp
movq 0x4(%r12), %rax
movl %eax, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
addq $0x18, %r12
testl %eax, %eax
js 0x3fad5
testl %edx, %edx
movq 0x8(%rsp), %r13
movq %r14, %rsi
je 0x3faea
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movzbl (%r12,%rcx), %edx
movw %dx, (%rbp,%rcx,2)
incq %rcx
cmpq %rcx, %rax
jne 0x3fac1
jmp 0x3faea
addl %edx, %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0xe5a0
movq 0x8(%rsp), %r13
movq %r14, %rsi
movq %rsi, 0x20(%rsp)
movq $-0x7, %r15
movq 0x30(%rsp), %rbp
movq 0x20(%rsp), %r14
movq 0x10(%rsp), %rsi
movq 0x18(%r13), %rdi
movq %rbx, %rdx
callq 0x1ccb2
movq 0x18(%rsp), %rsi
movq 0x18(%r13), %rdi
movq %rbp, %rdx
callq 0x1ccb2
movq %r15, %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rbx, %rdx
callq 0x33970
movq %rdx, %rbx
movq %rax, 0x10(%rsp)
cmpl $0x6, %ebx
jne 0x3f84f
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbp, %rdx
jmp 0x3fb8d
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x33970
movq %rdx, %rbp
movq %rax, 0x18(%rsp)
cmpl $0x6, %ebp
jne 0x3f85c
movq 0x10(%rsp), %rsi
movq 0x18(%r15), %rdi
movq %rbx, %rdx
callq 0x1ccb2
movl $0x6, %ebx
xorl %r14d, %r14d
jmp 0x3fb25
|
JS_ConcatString:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbp, r8
mov r14, rcx
mov rbx, rdx
mov r15, rdi
mov [rsp+68h+var_58], rsi
mov [rsp+68h+var_50], rcx
cmp ebx, 0FFFFFFF9h
jnz loc_3FB3A
loc_3F84F:
mov eax, 0FFFFFFF9h
cmp ebp, eax
jnz loc_3FB62
loc_3F85C:
mov r12, [rsp+68h+var_50]
mov rax, [r12+4]
test eax, 7FFFFFFFh
jz loc_3FA6B
mov [rsp+68h+var_60], r15
mov r13, [rsp+68h+var_58]
cmp dword ptr [r13+0], 1
jnz short loc_3F8D3
xor eax, [r13+4]
js short loc_3F8D3
mov rax, [rsp+68h+var_60]
mov rax, [rax+18h]
mov rdi, r13
call qword ptr [rax+20h]
mov r9, [r13+4]
mov r8d, 7FFFFFFFh
movsxd rsi, r9d
mov edi, r9d
and edi, r8d
mov rdx, [r12+4]
and r8d, edx
add edi, r8d
mov ecx, edx
shr ecx, 1Fh
shl edi, cl
movsxd rcx, edi
sar rsi, 1Fh
add rcx, rsi
add rcx, 19h
cmp rax, rcx
jnb loc_3F9B9
loc_3F8D3:
mov rax, [r13+4]
mov ecx, 7FFFFFFFh
mov r14d, eax
and r14d, ecx
mov r15, [r12+4]
and ecx, r15d
add r14, rcx
cmp r14d, 40000000h
jb short loc_3F920
lea rsi, aInvalidStringL; "invalid string length"
mov r13, [rsp+68h+var_60]
mov rdi, r13
xor eax, eax
call JS_ThrowRangeError
mov [rsp+68h+var_48], 0
mov r15d, 6
jmp loc_3FAFB
loc_3F920:
or r15d, eax
mov edx, r15d
shr edx, 1Fh
mov rdi, [rsp+68h+var_60]
mov esi, r14d
call js_alloc_string
test rax, rax
jz short loc_3F9A1
mov [rsp+68h+var_38], rbp
mov rbp, rax
add rbp, 18h
test r15d, r15d
js loc_3FA03
lea rsi, [r13+18h]
mov r15d, 7FFFFFFFh
mov rdx, [r13+4]
and rdx, r15
mov [rsp+68h+var_40], rax
mov rdi, rbp
call _memcpy
mov rdi, [r13+4]
and rdi, r15
add rdi, rbp
and r15, [r12+4]
add r12, 18h
mov rsi, r12
mov rdx, r15
call _memcpy
mov rsi, [rsp+68h+var_40]
mov byte ptr [rbp+r14+0], 0
mov r13, [rsp+68h+var_60]
jmp loc_3FAEA
loc_3F9A1:
mov dword ptr [rsp+68h+var_48], 0
mov r15d, 6
mov r13, [rsp+68h+var_60]
jmp loc_3FAFB
loc_3F9B9:
lea rdi, [r13+18h]
mov eax, r9d
and eax, 7FFFFFFFh
lea rsi, [r12+18h]
test r9d, r9d
js short loc_3FA39
add rdi, rax
and edx, 7FFFFFFFh
call _memcpy
mov rax, [r13+4]
mov ecx, [r12+4]
add ecx, eax
and ecx, 7FFFFFFFh
and rax, 0FFFFFFFF80000000h
or rax, rcx
mov [r13+4], rax
mov byte ptr [r13+rcx+18h], 0
jmp short loc_3FA66
loc_3FA03:
mov rdi, [r13+4]
mov edx, edi
and edx, 7FFFFFFFh
lea rsi, [r13+18h]
mov r14, rax
test edi, edi
js short loc_3FA86
test edx, edx
jz short loc_3FA90
and edi, 7FFFFFFFh
xor ecx, ecx
loc_3FA26:
movzx edx, byte ptr [rsi+rcx]
mov [rbp+rcx*2+0], dx
inc rcx
cmp rdi, rcx
jnz short loc_3FA26
jmp short loc_3FA90
loc_3FA39:
lea rdi, [rdi+rax*2]
add r8d, r8d
movsxd rdx, r8d
call _memcpy
mov rax, [r13+4]
mov ecx, [r12+4]
add ecx, eax
and ecx, 7FFFFFFFh
and rax, 0FFFFFFFF80000000h
or rax, rcx
mov [r13+4], rax
loc_3FA66:
mov r15, [rsp+68h+var_60]
loc_3FA6B:
mov rsi, [rsp+68h+var_50]
mov rdi, [r15+18h]
mov rdx, rbp
call JS_FreeValueRT
mov r14, [rsp+68h+var_58]
jmp loc_3FB25
loc_3FA86:
add edx, edx
mov rdi, rbp
call _memcpy
loc_3FA90:
mov eax, [r13+4]
add eax, eax
add rbp, rax
mov rax, [r12+4]
mov edx, eax
and edx, 7FFFFFFFh
add r12, 18h
test eax, eax
js short loc_3FAD5
test edx, edx
mov r13, [rsp+68h+var_60]
mov rsi, r14
jz short loc_3FAEA
and eax, 7FFFFFFFh
xor ecx, ecx
loc_3FAC1:
movzx edx, byte ptr [r12+rcx]
mov [rbp+rcx*2+0], dx
inc rcx
cmp rax, rcx
jnz short loc_3FAC1
jmp short loc_3FAEA
loc_3FAD5:
add edx, edx
mov rdi, rbp
mov rsi, r12
call _memcpy
mov r13, [rsp+68h+var_60]
mov rsi, r14
loc_3FAEA:
mov [rsp+68h+var_48], rsi
mov r15, 0FFFFFFFFFFFFFFF9h
mov rbp, [rsp+68h+var_38]
loc_3FAFB:
mov r14, [rsp+68h+var_48]
mov rsi, [rsp+68h+var_58]
mov rdi, [r13+18h]
mov rdx, rbx
call JS_FreeValueRT
mov rsi, [rsp+68h+var_50]
mov rdi, [r13+18h]
mov rdx, rbp
call JS_FreeValueRT
mov rbx, r15
loc_3FB25:
mov rax, r14
mov rdx, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3FB3A:
mov rdi, r15
mov rdx, rbx
call JS_ToStringFree
mov rbx, rdx
mov [rsp+68h+var_58], rax
cmp ebx, 6
jnz loc_3F84F
mov rdi, [r15+18h]
mov rsi, r14
mov rdx, rbp
jmp short loc_3FB8D
loc_3FB62:
mov rdi, r15
mov rsi, r14
mov rdx, rbp
call JS_ToStringFree
mov rbp, rdx
mov [rsp+68h+var_50], rax
cmp ebp, 6
jnz loc_3F85C
mov rsi, [rsp+68h+var_58]
mov rdi, [r15+18h]
mov rdx, rbx
loc_3FB8D:
call JS_FreeValueRT
mov ebx, 6
xor r14d, r14d
jmp short loc_3FB25
|
_DWORD * JS_ConcatString(
long long a1,
_DWORD *a2,
long long a3,
_DWORD *a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rbp
long long v16; // rbx
long long v18; // rax
unsigned long long v19; // rax
long long v20; // rax
long long v21; // r15
long long v22; // r14
long long v23; // r13
int v24; // r15d
long long v25; // rax
long long v26; // rbp
long long v27; // rsi
_DWORD *v28; // rdi
long long v29; // rax
_DWORD *v30; // rsi
long long v31; // rax
long long v32; // rcx
long long v33; // rdi
_DWORD *v34; // rsi
long long v35; // r14
long long v36; // rdi
long long v37; // rcx
long long v38; // r14
long long v39; // rbp
long long v40; // rax
_DWORD *v41; // r12
long long v42; // rax
long long v43; // rcx
unsigned long long v45; // rax
long long v46; // rdi
_DWORD *v47; // rsi
long long v48; // rdx
unsigned long long v49; // rax
char v50; // [rsp+0h] [rbp-68h]
_DWORD *v52; // [rsp+10h] [rbp-58h]
_DWORD *v53; // [rsp+18h] [rbp-50h]
long long v54; // [rsp+20h] [rbp-48h]
long long v55; // [rsp+28h] [rbp-40h]
long long v56; // [rsp+30h] [rbp-38h]
v14 = a5;
v16 = a3;
v52 = a2;
v53 = a4;
if ( (_DWORD)a3 != -7 )
{
v45 = JS_ToStringFree(a1, a2, a3, a7, a8, a9, a10, a11, a12, a13, a14, (long long)a4, a5, a6);
v16 = a3;
v52 = (_DWORD *)v45;
if ( (_DWORD)a3 == 6 )
{
v46 = *(_QWORD *)(a1 + 24);
v47 = a4;
v48 = v14;
LABEL_36:
JS_FreeValueRT(v46, v47, v48);
return 0LL;
}
}
if ( (_DWORD)v14 != -7 )
{
v49 = JS_ToStringFree(a1, a4, v14, a7, a8, a9, a10, a11, a12, a13, a14, (long long)a4, a5, a6);
v14 = a3;
v53 = (_DWORD *)v49;
if ( (_DWORD)a3 == 6 )
{
v47 = v52;
v46 = *(_QWORD *)(a1 + 24);
v48 = v16;
goto LABEL_36;
}
}
v18 = *(_QWORD *)(v53 + 1);
if ( (v18 & 0x7FFFFFFF) == 0 )
goto LABEL_21;
if ( *v52 == 1 && (int)(v52[1] ^ v18) >= 0 )
{
v19 = (*(long long ( **)(_DWORD *))(*(_QWORD *)(a1 + 24) + 32LL))(v52);
a6 = *(_QWORD *)(v52 + 1);
a3 = *(_QWORD *)(v53 + 1);
a5 = a3 & 0x7FFFFFFF;
if ( v19 >= ((long long)(int)a6 >> 31) + (int)(((a3 & 0x7FFFFFFF) + (a6 & 0x7FFFFFFF)) << ((int)a3 < 0)) + 25 )
{
v28 = v52 + 6;
v29 = a6 & 0x7FFFFFFF;
v30 = v53 + 6;
if ( (int)a6 < 0 )
{
memcpy((char *)v28 + 2 * v29, v30, 2 * (int)a3);
*(_QWORD *)(v52 + 1) = ((unsigned int)*(_QWORD *)(v52 + 1) + v53[1]) & 0x7FFFFFFF | *(_QWORD *)(v52 + 1) & 0xFFFFFFFF80000000LL;
}
else
{
memcpy((char *)v28 + v29, v30, a3 & 0x7FFFFFFF);
v31 = *(_QWORD *)(v52 + 1);
v32 = ((_DWORD)v31 + v53[1]) & 0x7FFFFFFF;
*(_QWORD *)(v52 + 1) = v32 | v31 & 0xFFFFFFFF80000000LL;
*((_BYTE *)v52 + v32 + 24) = 0;
}
LABEL_21:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v53, v14);
return v52;
}
}
v20 = *(_QWORD *)(v52 + 1);
v21 = *(_QWORD *)(v53 + 1);
v22 = (v21 & 0x7FFFFFFF) + (v20 & 0x7FFFFFFF);
if ( (unsigned int)v22 < 0x40000000 )
{
v24 = v20 | v21;
v25 = js_alloc_string(a1, (unsigned int)v22, (unsigned int)v24 >> 31);
if ( v25 )
{
v56 = v14;
v26 = v25 + 24;
if ( v24 < 0 )
{
v33 = *(_QWORD *)(v52 + 1);
v34 = v52 + 6;
v35 = v25;
if ( (int)v33 < 0 )
{
memcpy(v25 + 24, v34, (unsigned int)(2 * v33));
}
else if ( (v33 & 0x7FFFFFFF) != 0 )
{
v36 = v33 & 0x7FFFFFFF;
v37 = 0LL;
do
{
*(_WORD *)(v26 + 2 * v37) = *((unsigned __int8 *)v34 + v37);
++v37;
}
while ( v36 != v37 );
}
v39 = (unsigned int)(2 * v52[1]) + v26;
v40 = *(_QWORD *)(v53 + 1);
v41 = v53 + 6;
if ( (int)v40 < 0 )
{
memcpy(v39, v41, (unsigned int)(2 * v40));
v23 = a1;
v27 = v35;
}
else
{
v23 = a1;
v27 = v35;
if ( (v40 & 0x7FFFFFFF) != 0 )
{
v42 = v40 & 0x7FFFFFFF;
v43 = 0LL;
do
{
*(_WORD *)(v39 + 2 * v43) = *((unsigned __int8 *)v41 + v43);
++v43;
}
while ( v42 != v43 );
}
}
}
else
{
v55 = v25;
memcpy(v25 + 24, v52 + 6, *(_QWORD *)(v52 + 1) & 0x7FFFFFFFLL);
memcpy(v26 + (*(_QWORD *)(v52 + 1) & 0x7FFFFFFFLL), v53 + 6, *(_QWORD *)(v53 + 1) & 0x7FFFFFFFLL);
v27 = v55;
*(_BYTE *)(v26 + v22) = 0;
v23 = a1;
}
v54 = v27;
v14 = v56;
}
else
{
LODWORD(v54) = 0;
v23 = a1;
}
}
else
{
v23 = a1;
JS_ThrowRangeError(
a1,
(long long)"invalid string length",
a3,
v21 & 0x7FFFFFFF,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v50);
v54 = 0LL;
}
v38 = v54;
JS_FreeValueRT(*(_QWORD *)(v23 + 24), v52, v16);
JS_FreeValueRT(*(_QWORD *)(v23 + 24), v53, v14);
return (_DWORD *)v38;
}
|
JS_ConcatString:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBP,R8
MOV R14,RCX
MOV RBX,RDX
MOV R15,RDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x18],RCX
CMP EBX,-0x7
JNZ 0x0013fb3a
LAB_0013f84f:
MOV EAX,0xfffffff9
CMP EBP,EAX
JNZ 0x0013fb62
LAB_0013f85c:
MOV R12,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [R12 + 0x4]
TEST EAX,0x7fffffff
JZ 0x0013fa6b
MOV qword ptr [RSP + 0x8],R15
MOV R13,qword ptr [RSP + 0x10]
CMP dword ptr [R13],0x1
JNZ 0x0013f8d3
XOR EAX,dword ptr [R13 + 0x4]
JS 0x0013f8d3
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV RDI,R13
CALL qword ptr [RAX + 0x20]
MOV R9,qword ptr [R13 + 0x4]
MOV R8D,0x7fffffff
MOVSXD RSI,R9D
MOV EDI,R9D
AND EDI,R8D
MOV RDX,qword ptr [R12 + 0x4]
AND R8D,EDX
ADD EDI,R8D
MOV ECX,EDX
SHR ECX,0x1f
SHL EDI,CL
MOVSXD RCX,EDI
SAR RSI,0x1f
ADD RCX,RSI
ADD RCX,0x19
CMP RAX,RCX
JNC 0x0013f9b9
LAB_0013f8d3:
MOV RAX,qword ptr [R13 + 0x4]
MOV ECX,0x7fffffff
MOV R14D,EAX
AND R14D,ECX
MOV R15,qword ptr [R12 + 0x4]
AND ECX,R15D
ADD R14,RCX
CMP R14D,0x40000000
JC 0x0013f920
LEA RSI,[0x19d266]
MOV R13,qword ptr [RSP + 0x8]
MOV RDI,R13
XOR EAX,EAX
CALL 0x0011fec9
MOV qword ptr [RSP + 0x20],0x0
MOV R15D,0x6
JMP 0x0013fafb
LAB_0013f920:
OR R15D,EAX
MOV EDX,R15D
SHR EDX,0x1f
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,R14D
CALL 0x0011ff5f
TEST RAX,RAX
JZ 0x0013f9a1
MOV qword ptr [RSP + 0x30],RBP
MOV RBP,RAX
ADD RBP,0x18
TEST R15D,R15D
JS 0x0013fa03
LEA RSI,[R13 + 0x18]
MOV R15D,0x7fffffff
MOV RDX,qword ptr [R13 + 0x4]
AND RDX,R15
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,RBP
CALL 0x0010e5a0
MOV RDI,qword ptr [R13 + 0x4]
AND RDI,R15
ADD RDI,RBP
AND R15,qword ptr [R12 + 0x4]
ADD R12,0x18
MOV RSI,R12
MOV RDX,R15
CALL 0x0010e5a0
MOV RSI,qword ptr [RSP + 0x28]
MOV byte ptr [RBP + R14*0x1],0x0
MOV R13,qword ptr [RSP + 0x8]
JMP 0x0013faea
LAB_0013f9a1:
MOV dword ptr [RSP + 0x20],0x0
MOV R15D,0x6
MOV R13,qword ptr [RSP + 0x8]
JMP 0x0013fafb
LAB_0013f9b9:
LEA RDI,[R13 + 0x18]
MOV EAX,R9D
AND EAX,0x7fffffff
LEA RSI,[R12 + 0x18]
TEST R9D,R9D
JS 0x0013fa39
ADD RDI,RAX
AND EDX,0x7fffffff
CALL 0x0010e5a0
MOV RAX,qword ptr [R13 + 0x4]
MOV ECX,dword ptr [R12 + 0x4]
ADD ECX,EAX
AND ECX,0x7fffffff
AND RAX,-0x80000000
OR RAX,RCX
MOV qword ptr [R13 + 0x4],RAX
MOV byte ptr [R13 + RCX*0x1 + 0x18],0x0
JMP 0x0013fa66
LAB_0013fa03:
MOV RDI,qword ptr [R13 + 0x4]
MOV EDX,EDI
AND EDX,0x7fffffff
LEA RSI,[R13 + 0x18]
MOV R14,RAX
TEST EDI,EDI
JS 0x0013fa86
TEST EDX,EDX
JZ 0x0013fa90
AND EDI,0x7fffffff
XOR ECX,ECX
LAB_0013fa26:
MOVZX EDX,byte ptr [RSI + RCX*0x1]
MOV word ptr [RBP + RCX*0x2],DX
INC RCX
CMP RDI,RCX
JNZ 0x0013fa26
JMP 0x0013fa90
LAB_0013fa39:
LEA RDI,[RDI + RAX*0x2]
ADD R8D,R8D
MOVSXD RDX,R8D
CALL 0x0010e5a0
MOV RAX,qword ptr [R13 + 0x4]
MOV ECX,dword ptr [R12 + 0x4]
ADD ECX,EAX
AND ECX,0x7fffffff
AND RAX,-0x80000000
OR RAX,RCX
MOV qword ptr [R13 + 0x4],RAX
LAB_0013fa66:
MOV R15,qword ptr [RSP + 0x8]
LAB_0013fa6b:
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [R15 + 0x18]
MOV RDX,RBP
CALL 0x0011ccb2
MOV R14,qword ptr [RSP + 0x10]
JMP 0x0013fb25
LAB_0013fa86:
ADD EDX,EDX
MOV RDI,RBP
CALL 0x0010e5a0
LAB_0013fa90:
MOV EAX,dword ptr [R13 + 0x4]
ADD EAX,EAX
ADD RBP,RAX
MOV RAX,qword ptr [R12 + 0x4]
MOV EDX,EAX
AND EDX,0x7fffffff
ADD R12,0x18
TEST EAX,EAX
JS 0x0013fad5
TEST EDX,EDX
MOV R13,qword ptr [RSP + 0x8]
MOV RSI,R14
JZ 0x0013faea
AND EAX,0x7fffffff
XOR ECX,ECX
LAB_0013fac1:
MOVZX EDX,byte ptr [R12 + RCX*0x1]
MOV word ptr [RBP + RCX*0x2],DX
INC RCX
CMP RAX,RCX
JNZ 0x0013fac1
JMP 0x0013faea
LAB_0013fad5:
ADD EDX,EDX
MOV RDI,RBP
MOV RSI,R12
CALL 0x0010e5a0
MOV R13,qword ptr [RSP + 0x8]
MOV RSI,R14
LAB_0013faea:
MOV qword ptr [RSP + 0x20],RSI
MOV R15,-0x7
MOV RBP,qword ptr [RSP + 0x30]
LAB_0013fafb:
MOV R14,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [R13 + 0x18]
MOV RDX,RBX
CALL 0x0011ccb2
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [R13 + 0x18]
MOV RDX,RBP
CALL 0x0011ccb2
MOV RBX,R15
LAB_0013fb25:
MOV RAX,R14
MOV RDX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013fb3a:
MOV RDI,R15
MOV RDX,RBX
CALL 0x00133970
MOV RBX,RDX
MOV qword ptr [RSP + 0x10],RAX
CMP EBX,0x6
JNZ 0x0013f84f
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R14
MOV RDX,RBP
JMP 0x0013fb8d
LAB_0013fb62:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBP
CALL 0x00133970
MOV RBP,RDX
MOV qword ptr [RSP + 0x18],RAX
CMP EBP,0x6
JNZ 0x0013f85c
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [R15 + 0x18]
MOV RDX,RBX
LAB_0013fb8d:
CALL 0x0011ccb2
MOV EBX,0x6
XOR R14D,R14D
JMP 0x0013fb25
|
int1 [16]
JS_ConcatString(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int1 auVar1 [16];
ulong uVar2;
ulong uVar3;
void *pvVar4;
uint uVar5;
uint uVar6;
long lVar7;
uint uVar8;
int8 uVar9;
int1 auVar10 [16];
int1 auVar11 [16];
int *local_58;
long local_50;
ulong local_48;
auVar11._8_8_ = param_5;
auVar11._0_8_ = param_4;
auVar10._8_8_ = param_3;
auVar10._0_8_ = param_2;
if (((int)param_3 == -7) ||
(auVar10 = JS_ToStringFree(param_1,param_2,param_3), auVar10._8_4_ != 6)) {
local_58 = auVar10._0_8_;
if (((int)param_5 == -7) ||
(auVar11 = JS_ToStringFree(param_1,param_4,param_5), auVar11._8_4_ != 6)) {
local_50 = auVar11._0_8_;
if ((*(ulong *)(local_50 + 4) & 0x7fffffff) == 0) {
LAB_0013fa6b:
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_50,auVar11._8_8_);
return auVar10;
}
if ((*local_58 == 1) && (-1 < (int)((uint)*(ulong *)(local_50 + 4) ^ local_58[1]))) {
uVar2 = (**(code **)(*(long *)(param_1 + 0x18) + 0x20))(local_58);
uVar6 = (uint)*(int8 *)(local_58 + 1);
uVar8 = (uint)*(ulong *)(local_50 + 4);
uVar5 = uVar8 & 0x7fffffff;
if ((long)(int)((uVar6 & 0x7fffffff) + uVar5 <<
((byte)(*(ulong *)(local_50 + 4) >> 0x1f) & 1)) + ((long)(int)uVar6 >> 0x1f)
+ 0x19U <= uVar2) {
if ((int)uVar6 < 0) {
memcpy((void *)((long)local_58 + (ulong)(uVar6 & 0x7fffffff) * 2 + 0x18),
(void *)(local_50 + 0x18),(long)(int)(uVar5 * 2));
*(ulong *)(local_58 + 1) =
*(ulong *)(local_58 + 1) & 0xffffffff80000000 |
(ulong)(*(int *)(local_50 + 4) + (int)*(ulong *)(local_58 + 1) & 0x7fffffff);
}
else {
memcpy((void *)((long)local_58 + (ulong)(uVar6 & 0x7fffffff) + 0x18),
(void *)(local_50 + 0x18),(ulong)(uVar8 & 0x7fffffff));
uVar2 = (ulong)(*(int *)(local_50 + 4) + (int)*(ulong *)(local_58 + 1) & 0x7fffffff);
*(ulong *)(local_58 + 1) = *(ulong *)(local_58 + 1) & 0xffffffff80000000 | uVar2;
*(int1 *)((long)local_58 + uVar2 + 0x18) = 0;
}
goto LAB_0013fa6b;
}
}
uVar8 = (uint)*(int8 *)(local_50 + 4);
lVar7 = (ulong)((uint)*(int8 *)(local_58 + 1) & 0x7fffffff) +
(ulong)(uVar8 & 0x7fffffff);
if ((uint)lVar7 < 0x40000000) {
uVar8 = uVar8 | (uint)*(int8 *)(local_58 + 1);
uVar2 = js_alloc_string(param_1,lVar7,uVar8 >> 0x1f);
if (uVar2 == 0) {
local_48 = local_48 & 0xffffffff00000000;
uVar9 = 6;
}
else {
pvVar4 = (void *)(uVar2 + 0x18);
if ((int)uVar8 < 0) {
uVar8 = (uint)*(ulong *)(local_58 + 1);
if ((int)uVar8 < 0) {
memcpy(pvVar4,local_58 + 6,(ulong)(uVar8 * 2));
}
else if ((*(ulong *)(local_58 + 1) & 0x7fffffff) != 0) {
uVar3 = 0;
do {
*(ushort *)((long)pvVar4 + uVar3 * 2) =
(ushort)*(byte *)((long)(local_58 + 6) + uVar3);
uVar3 = uVar3 + 1;
} while ((uVar8 & 0x7fffffff) != uVar3);
}
pvVar4 = (void *)((long)pvVar4 + (ulong)(uint)(local_58[1] * 2));
uVar8 = (uint)*(ulong *)(local_50 + 4);
if ((int)uVar8 < 0) {
memcpy(pvVar4,(void *)(local_50 + 0x18),(ulong)(uVar8 * 2));
}
else if ((*(ulong *)(local_50 + 4) & 0x7fffffff) != 0) {
uVar3 = 0;
do {
*(ushort *)((long)pvVar4 + uVar3 * 2) = (ushort)*(byte *)(local_50 + 0x18 + uVar3);
uVar3 = uVar3 + 1;
} while ((uVar8 & 0x7fffffff) != uVar3);
}
}
else {
memcpy(pvVar4,local_58 + 6,*(ulong *)(local_58 + 1) & 0x7fffffff);
memcpy((void *)((*(ulong *)(local_58 + 1) & 0x7fffffff) + (long)pvVar4),
(void *)(local_50 + 0x18),*(ulong *)(local_50 + 4) & 0x7fffffff);
*(int1 *)((long)pvVar4 + lVar7) = 0;
}
uVar9 = 0xfffffffffffffff9;
local_48 = uVar2;
}
}
else {
JS_ThrowRangeError(param_1,"invalid string length");
local_48 = 0;
uVar9 = 6;
}
auVar1._8_8_ = uVar9;
auVar1._0_8_ = local_48;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_58,auVar10._8_8_);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_50,auVar11._8_8_);
return auVar1;
}
uVar9 = *(int8 *)(param_1 + 0x18);
auVar11 = auVar10;
}
else {
uVar9 = *(int8 *)(param_1 + 0x18);
}
JS_FreeValueRT(uVar9,auVar11._0_8_,auVar11._8_8_);
return ZEXT816(6) << 0x40;
}
|
|
64,762 |
JS_ConcatString
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ConcatString(JSContext *ctx, JSValue op1, JSValue op2)
{
JSValue ret;
JSString *p1, *p2;
if (unlikely(JS_VALUE_GET_TAG(op1) != JS_TAG_STRING)) {
op1 = JS_ToStringFree(ctx, op1);
if (JS_IsException(op1)) {
JS_FreeValue(ctx, op2);
return JS_EXCEPTION;
}
}
if (unlikely(JS_VALUE_GET_TAG(op2) != JS_TAG_STRING)) {
op2 = JS_ToStringFree(ctx, op2);
if (JS_IsException(op2)) {
JS_FreeValue(ctx, op1);
return JS_EXCEPTION;
}
}
p1 = JS_VALUE_GET_STRING(op1);
p2 = JS_VALUE_GET_STRING(op2);
/* XXX: could also check if p1 is empty */
if (p2->len == 0) {
goto ret_op1;
}
if (p1->header.ref_count == 1 && p1->is_wide_char == p2->is_wide_char
&& js_malloc_usable_size(ctx, p1) >= sizeof(*p1) + ((p1->len + p2->len) << p2->is_wide_char) + 1 - p1->is_wide_char) {
/* Concatenate in place in available space at the end of p1 */
if (p1->is_wide_char) {
memcpy(p1->u.str16 + p1->len, p2->u.str16, p2->len << 1);
p1->len += p2->len;
} else {
memcpy(p1->u.str8 + p1->len, p2->u.str8, p2->len);
p1->len += p2->len;
p1->u.str8[p1->len] = '\0';
}
ret_op1:
JS_FreeValue(ctx, op2);
return op1;
}
ret = JS_ConcatString1(ctx, p1, p2);
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
return ret;
}
|
O3
|
c
|
JS_ConcatString:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %rbx
cmpl $-0x7, %ebp
jne 0x4140e
movl $0xfffffff9, %eax # imm = 0xFFFFFFF9
cmpl %eax, %r14d
jne 0x4144a
movq 0x4(%r15), %rdx
testl $0x7fffffff, %edx # imm = 0x7FFFFFFF
je 0x41320
cmpl $0x1, (%rbx)
movq 0x4(%rbx), %r13
jne 0x4119a
movl %r13d, %eax
xorl %edx, %eax
js 0x4119a
movq %rdi, %r12
movq 0x18(%rdi), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x4(%rbx), %r13
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
movslq %r13d, %rsi
movl %r13d, %edi
andl %r8d, %edi
movq 0x4(%r15), %rdx
andl %edx, %r8d
addl %r8d, %edi
movl %edx, %ecx
shrl $0x1f, %ecx
shll %cl, %edi
movslq %edi, %rcx
sarq $0x1f, %rsi
addq %rsi, %rcx
addq $0x19, %rcx
cmpq %rcx, %rax
jae 0x41277
movq %r12, %rdi
movq %rbp, 0x10(%rsp)
movq %r14, %rbp
movl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
movl %r13d, %eax
andl %r14d, %eax
andl %edx, %r14d
addq %rax, %r14
cmpl $0x40000000, %r14d # imm = 0x40000000
jb 0x411e9
leaq 0x5f072(%rip), %rsi # 0xa0236
movq $0x0, (%rsp)
xorl %eax, %eax
movq %rdi, %r14
callq 0x205f0
movq %r14, %r8
movl $0x6, %r12d
movq 0x10(%rsp), %r13
jmp 0x413af
orl %edx, %r13d
movl %r13d, %edx
shrl $0x1f, %edx
movq %rdi, 0x8(%rsp)
movl %r14d, %esi
callq 0x20686
testq %rax, %rax
je 0x4125a
movq %rax, %r12
addq $0x18, %r12
testl %r13d, %r13d
movq %rax, (%rsp)
js 0x412be
leaq 0x18(%rbx), %rsi
movl $0x7fffffff, %r13d # imm = 0x7FFFFFFF
movq 0x4(%rbx), %rdx
andq %r13, %rdx
movq %r12, %rdi
callq 0xe5a0
movq 0x4(%rbx), %rdi
andq %r13, %rdi
addq %r12, %rdi
leaq 0x18(%r15), %rsi
andq 0x4(%r15), %r13
movq %r13, %rdx
callq 0xe5a0
movb $0x0, (%r12,%r14)
movq 0x10(%rsp), %r13
jmp 0x413a3
movl $0x6, %r12d
movq $0x0, (%rsp)
movq 0x10(%rsp), %r13
movq 0x8(%rsp), %r8
jmp 0x413af
leaq 0x18(%rbx), %rdi
movl %r13d, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
leaq 0x18(%r15), %rsi
testl %r13d, %r13d
js 0x412f1
addq %rax, %rdi
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
callq 0xe5a0
movq 0x4(%rbx), %rax
movl 0x4(%r15), %ecx
addl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andq $-0x80000000, %rax # imm = 0x80000000
orq %rcx, %rax
movq %rax, 0x4(%rbx)
movb $0x0, 0x18(%rbx,%rcx)
jmp 0x4131d
movq 0x4(%rbx), %rdi
movl %edi, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
leaq 0x18(%rbx), %rsi
testl %edi, %edi
js 0x4134b
testl %edx, %edx
je 0x41355
andl $0x7fffffff, %edi # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movzbl (%rsi,%rcx), %edx
movw %dx, (%r12,%rcx,2)
incq %rcx
cmpq %rcx, %rdi
jne 0x412de
jmp 0x41355
leaq (%rdi,%rax,2), %rdi
addl %r8d, %r8d
movslq %r8d, %rdx
callq 0xe5a0
movq 0x4(%rbx), %rax
movl 0x4(%r15), %ecx
addl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andq $-0x80000000, %rax # imm = 0x80000000
orq %rcx, %rax
movq %rax, 0x4(%rbx)
movq %r12, %rdi
cmpl $-0x9, %r14d
jb 0x41343
movq 0x18(%rdi), %rdi
movl (%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r15)
cmpl $0x1, %eax
jg 0x41343
movq %r15, %rsi
movq %r14, %rdx
callq 0x20d90
movq %rbp, %r12
jmp 0x413f9
addl %edx, %edx
movq %r12, %rdi
callq 0xe5a0
movl 0x4(%rbx), %eax
addl %eax, %eax
addq %rax, %r12
movq 0x4(%r15), %rax
movl %eax, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
leaq 0x18(%r15), %rsi
testl %eax, %eax
movq 0x10(%rsp), %r13
js 0x41399
testl %edx, %edx
movq 0x8(%rsp), %r8
je 0x413a8
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movzbl (%rsi,%rcx), %edx
movw %dx, (%r12,%rcx,2)
incq %rcx
cmpq %rcx, %rax
jne 0x41386
jmp 0x413a8
addl %edx, %edx
movq %r12, %rdi
callq 0xe5a0
movq 0x8(%rsp), %r8
movq $-0x7, %r12
movq 0x18(%r8), %rdi
cmpl $-0x9, %r13d
jb 0x413d7
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %eax
jg 0x413d7
movq %rbx, %rsi
movq %r13, %rdx
movq %r8, %rbx
callq 0x20d90
movq 0x18(%rbx), %rdi
cmpl $-0x9, %ebp
jb 0x413f5
movl (%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r15)
cmpl $0x1, %eax
jg 0x413f5
movq %r15, %rsi
movq %rbp, %rdx
callq 0x20d90
movq (%rsp), %rbx
movq %rbx, %rax
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r13
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x3479d
movq %rdx, %rbp
cmpl $0x6, %ebp
jne 0x4148e
movl $0x6, %r12d
cmpl $-0x9, %r14d
jb 0x41487
movq 0x18(%r13), %rdi
movl (%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r15)
cmpl $0x1, %eax
jg 0x41487
movq %r15, %rsi
movq %r14, %rdx
jmp 0x41482
movq %rdi, %r13
movq %r15, %rsi
movq %r14, %rdx
callq 0x3479d
movq %rdx, %r14
cmpl $0x6, %r14d
jne 0x41499
movl $0x6, %r12d
cmpl $-0x9, %ebp
jb 0x41487
movq 0x18(%r13), %rdi
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %eax
jg 0x41487
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x20d90
xorl %ebx, %ebx
jmp 0x413f9
movq %rax, %rbx
movq %r13, %rdi
jmp 0x41121
movq %rax, %r15
movq %r13, %rdi
jmp 0x4112f
|
JS_ConcatString:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, r8
mov r15, rcx
mov rbp, rdx
mov rbx, rsi
cmp ebp, 0FFFFFFF9h
jnz loc_4140E
loc_41121:
mov eax, 0FFFFFFF9h
cmp r14d, eax
jnz loc_4144A
loc_4112F:
mov rdx, [r15+4]
test edx, 7FFFFFFFh
jz loc_41320
cmp dword ptr [rbx], 1
mov r13, [rbx+4]
jnz short loc_4119A
mov eax, r13d
xor eax, edx
js short loc_4119A
mov r12, rdi
mov rax, [rdi+18h]
mov rdi, rbx
call qword ptr [rax+20h]
mov r13, [rbx+4]
mov r8d, 7FFFFFFFh
movsxd rsi, r13d
mov edi, r13d
and edi, r8d
mov rdx, [r15+4]
and r8d, edx
add edi, r8d
mov ecx, edx
shr ecx, 1Fh
shl edi, cl
movsxd rcx, edi
sar rsi, 1Fh
add rcx, rsi
add rcx, 19h
cmp rax, rcx
jnb loc_41277
mov rdi, r12
loc_4119A:
mov [rsp+48h+var_38], rbp
mov rbp, r14
mov r14d, 7FFFFFFFh
mov eax, r13d
and eax, r14d
and r14d, edx
add r14, rax
cmp r14d, 40000000h
jb short loc_411E9
lea rsi, aInvalidStringL; "invalid string length"
mov [rsp+48h+var_48], 0
xor eax, eax
mov r14, rdi
call JS_ThrowRangeError
mov r8, r14
mov r12d, 6
mov r13, [rsp+48h+var_38]
jmp loc_413AF
loc_411E9:
or r13d, edx
mov edx, r13d
shr edx, 1Fh
mov [rsp+48h+var_40], rdi
mov esi, r14d
call js_alloc_string
test rax, rax
jz short loc_4125A
mov r12, rax
add r12, 18h
test r13d, r13d
mov [rsp+48h+var_48], rax
js loc_412BE
lea rsi, [rbx+18h]
mov r13d, 7FFFFFFFh
mov rdx, [rbx+4]
and rdx, r13
mov rdi, r12
call _memcpy
mov rdi, [rbx+4]
and rdi, r13
add rdi, r12
lea rsi, [r15+18h]
and r13, [r15+4]
mov rdx, r13
call _memcpy
mov byte ptr [r12+r14], 0
mov r13, [rsp+48h+var_38]
jmp loc_413A3
loc_4125A:
mov r12d, 6
mov [rsp+48h+var_48], 0
mov r13, [rsp+48h+var_38]
mov r8, [rsp+48h+var_40]
jmp loc_413AF
loc_41277:
lea rdi, [rbx+18h]
mov eax, r13d
and eax, 7FFFFFFFh
lea rsi, [r15+18h]
test r13d, r13d
js short loc_412F1
add rdi, rax
and edx, 7FFFFFFFh
call _memcpy
mov rax, [rbx+4]
mov ecx, [r15+4]
add ecx, eax
and ecx, 7FFFFFFFh
and rax, 0FFFFFFFF80000000h
or rax, rcx
mov [rbx+4], rax
mov byte ptr [rbx+rcx+18h], 0
jmp short loc_4131D
loc_412BE:
mov rdi, [rbx+4]
mov edx, edi
and edx, 7FFFFFFFh
lea rsi, [rbx+18h]
test edi, edi
js short loc_4134B
test edx, edx
jz short loc_41355
and edi, 7FFFFFFFh
xor ecx, ecx
loc_412DE:
movzx edx, byte ptr [rsi+rcx]
mov [r12+rcx*2], dx
inc rcx
cmp rdi, rcx
jnz short loc_412DE
jmp short loc_41355
loc_412F1:
lea rdi, [rdi+rax*2]
add r8d, r8d
movsxd rdx, r8d
call _memcpy
mov rax, [rbx+4]
mov ecx, [r15+4]
add ecx, eax
and ecx, 7FFFFFFFh
and rax, 0FFFFFFFF80000000h
or rax, rcx
mov [rbx+4], rax
loc_4131D:
mov rdi, r12
loc_41320:
cmp r14d, 0FFFFFFF7h
jb short loc_41343
mov rdi, [rdi+18h]
mov eax, [r15]
lea ecx, [rax-1]
mov [r15], ecx
cmp eax, 1
jg short loc_41343
mov rsi, r15
mov rdx, r14
call js_free_value_rt
loc_41343:
mov r12, rbp
jmp loc_413F9
loc_4134B:
add edx, edx
mov rdi, r12
call _memcpy
loc_41355:
mov eax, [rbx+4]
add eax, eax
add r12, rax
mov rax, [r15+4]
mov edx, eax
and edx, 7FFFFFFFh
lea rsi, [r15+18h]
test eax, eax
mov r13, [rsp+48h+var_38]
js short loc_41399
test edx, edx
mov r8, [rsp+48h+var_40]
jz short loc_413A8
and eax, 7FFFFFFFh
xor ecx, ecx
loc_41386:
movzx edx, byte ptr [rsi+rcx]
mov [r12+rcx*2], dx
inc rcx
cmp rax, rcx
jnz short loc_41386
jmp short loc_413A8
loc_41399:
add edx, edx
mov rdi, r12
call _memcpy
loc_413A3:
mov r8, [rsp+48h+var_40]
loc_413A8:
mov r12, 0FFFFFFFFFFFFFFF9h
loc_413AF:
mov rdi, [r8+18h]
cmp r13d, 0FFFFFFF7h
jb short loc_413D7
mov eax, [rbx]
lea ecx, [rax-1]
mov [rbx], ecx
cmp eax, 1
jg short loc_413D7
mov rsi, rbx
mov rdx, r13
mov rbx, r8
call js_free_value_rt
mov rdi, [rbx+18h]
loc_413D7:
cmp ebp, 0FFFFFFF7h
jb short loc_413F5
mov eax, [r15]
lea ecx, [rax-1]
mov [r15], ecx
cmp eax, 1
jg short loc_413F5
mov rsi, r15
mov rdx, rbp
call js_free_value_rt
loc_413F5:
mov rbx, [rsp+48h+var_48]
loc_413F9:
mov rax, rbx
mov rdx, r12
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4140E:
mov r13, rdi
mov rsi, rbx
mov rdx, rbp
call JS_ToStringFree
mov rbp, rdx
cmp ebp, 6
jnz short loc_4148E
mov r12d, 6
cmp r14d, 0FFFFFFF7h
jb short loc_41487
mov rdi, [r13+18h]
mov eax, [r15]
lea ecx, [rax-1]
mov [r15], ecx
cmp eax, 1
jg short loc_41487
mov rsi, r15
mov rdx, r14
jmp short loc_41482
loc_4144A:
mov r13, rdi
mov rsi, r15
mov rdx, r14
call JS_ToStringFree
mov r14, rdx
cmp r14d, 6
jnz short loc_41499
mov r12d, 6
cmp ebp, 0FFFFFFF7h
jb short loc_41487
mov rdi, [r13+18h]
mov eax, [rbx]
lea ecx, [rax-1]
mov [rbx], ecx
cmp eax, 1
jg short loc_41487
mov rsi, rbx
mov rdx, rbp
loc_41482:
call js_free_value_rt
loc_41487:
xor ebx, ebx
jmp loc_413F9
loc_4148E:
mov rbx, rax
mov rdi, r13
jmp loc_41121
loc_41499:
mov r15, rax
mov rdi, r13
jmp loc_4112F
|
unsigned long long JS_ConcatString(
long long a1,
int *a2,
long long a3,
unsigned 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)
{
long long v14; // r14
unsigned long long v15; // r15
long long v16; // rbp
unsigned long long v17; // rbx
long long v18; // rdx
long long v19; // r13
long long v20; // r12
unsigned long long v21; // rax
long long v22; // rbp
long long v23; // r14
long long v24; // r9
long long v25; // r8
long long v26; // r13
int v27; // r13d
long long v28; // rax
long long v29; // r12
unsigned long long v30; // rdi
long long v31; // rax
unsigned long long v32; // rsi
long long v33; // rax
long long v34; // rcx
long long v35; // rdi
unsigned long long v36; // rsi
long long v37; // rdi
long long v38; // rcx
long long v39; // rdi
int v40; // eax
long long v41; // rcx
long long v42; // r12
long long v43; // rax
unsigned long long v44; // rsi
long long v45; // rax
long long v46; // rcx
long long v47; // rdi
int v48; // eax
long long v49; // rcx
_QWORD *v50; // rsi
long long v51; // rbx
int v52; // eax
long long v53; // rcx
unsigned long long v55; // rax
long long v56; // rdx
long long v57; // rdi
int v58; // eax
long long v59; // rcx
_QWORD *v60; // rsi
long long v61; // rdx
unsigned long long v62; // rax
long long v63; // rdx
int v64; // eax
long long v65; // [rsp+0h] [rbp-48h]
long long v66; // [rsp+8h] [rbp-40h]
long long v67; // [rsp+10h] [rbp-38h]
v14 = a5;
v15 = a4;
v16 = a3;
v17 = (unsigned long long)a2;
if ( (_DWORD)a3 != -7 )
{
v55 = JS_ToStringFree(a1, a2, a3, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6);
v16 = v56;
if ( (_DWORD)v56 == 6 )
{
if ( (unsigned int)v14 < 0xFFFFFFF7 )
return 0LL;
v57 = *(_QWORD *)(a1 + 24);
v58 = *(_DWORD *)v15;
v59 = (unsigned int)(*(_DWORD *)v15 - 1);
*(_DWORD *)v15 = v59;
if ( v58 > 1 )
return 0LL;
v60 = (_QWORD *)v15;
v61 = v14;
goto LABEL_50;
}
v17 = v55;
}
if ( (_DWORD)v14 == -7 )
goto LABEL_3;
v62 = JS_ToStringFree(a1, (int *)v15, v14, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6);
v14 = v63;
if ( (_DWORD)v63 == 6 )
{
if ( (unsigned int)v16 < 0xFFFFFFF7 )
return 0LL;
v57 = *(_QWORD *)(a1 + 24);
v64 = *(_DWORD *)v17;
v59 = (unsigned int)(*(_DWORD *)v17 - 1);
*(_DWORD *)v17 = v59;
if ( v64 > 1 )
return 0LL;
v60 = (_QWORD *)v17;
v61 = v16;
LABEL_50:
js_free_value_rt(v57, v60, v61, v59, a5, a6);
return 0LL;
}
v15 = v62;
LABEL_3:
v18 = *(_QWORD *)(v15 + 4);
if ( (v18 & 0x7FFFFFFF) != 0 )
{
v19 = *(_QWORD *)(v17 + 4);
if ( *(_DWORD *)v17 != 1
|| (int)(v18 ^ v19) < 0
|| (v20 = a1,
v21 = (*(long long ( **)(unsigned long long))(*(_QWORD *)(a1 + 24) + 32LL))(v17),
v19 = *(_QWORD *)(v17 + 4),
v18 = *(_QWORD *)(v15 + 4),
a5 = v18 & 0x7FFFFFFF,
a4 = ((long long)(int)v19 >> 31) + (int)(((v18 & 0x7FFFFFFF) + (v19 & 0x7FFFFFFF)) << ((int)v18 < 0)) + 25,
v21 < a4) )
{
v67 = v16;
v22 = v14;
v23 = (v19 & 0x7FFFFFFF) + (v18 & 0x7FFFFFFF);
if ( (unsigned int)v23 < 0x40000000 )
{
v27 = v18 | v19;
v66 = a1;
v28 = js_alloc_string(a1, (unsigned int)v23, (unsigned int)v27 >> 31);
if ( v28 )
{
v29 = v28 + 24;
v65 = v28;
if ( v27 < 0 )
{
v35 = *(_QWORD *)(v17 + 4);
v36 = v17 + 24;
if ( (int)v35 < 0 )
{
memcpy(v28 + 24, v36, (unsigned int)(2 * v35));
}
else if ( (v35 & 0x7FFFFFFF) != 0 )
{
v37 = v35 & 0x7FFFFFFF;
v38 = 0LL;
do
{
*(_WORD *)(v29 + 2 * v38) = *(unsigned __int8 *)(v36 + v38);
++v38;
}
while ( v37 != v38 );
}
v42 = (unsigned int)(2 * *(_DWORD *)(v17 + 4)) + v29;
v43 = *(_QWORD *)(v15 + 4);
v44 = v15 + 24;
v26 = v67;
if ( (int)v43 >= 0 )
{
v25 = v66;
if ( (v43 & 0x7FFFFFFF) != 0 )
{
v45 = v43 & 0x7FFFFFFF;
v46 = 0LL;
do
{
*(_WORD *)(v42 + 2 * v46) = *(unsigned __int8 *)(v44 + v46);
++v46;
}
while ( v45 != v46 );
}
goto LABEL_34;
}
memcpy(v42, v44, (unsigned int)(2 * v43));
}
else
{
memcpy(v28 + 24, v17 + 24, *(_QWORD *)(v17 + 4) & 0x7FFFFFFFLL);
memcpy(v29 + (*(_QWORD *)(v17 + 4) & 0x7FFFFFFFLL), v15 + 24, *(_QWORD *)(v15 + 4) & 0x7FFFFFFFLL);
*(_BYTE *)(v29 + v23) = 0;
v26 = v67;
}
v25 = v66;
}
else
{
v65 = 0LL;
v26 = v67;
v25 = a1;
}
}
else
{
JS_ThrowRangeError(
a1,
(long long)"invalid string length",
v18,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
0);
v25 = a1;
v26 = v67;
}
LABEL_34:
v47 = *(_QWORD *)(v25 + 24);
if ( (unsigned int)v26 >= 0xFFFFFFF7 )
{
v48 = *(_DWORD *)v17;
v49 = (unsigned int)(*(_DWORD *)v17 - 1);
*(_DWORD *)v17 = v49;
if ( v48 <= 1 )
{
v50 = (_QWORD *)v17;
v51 = v25;
js_free_value_rt(v47, v50, v26, v49, v25, v24);
v47 = *(_QWORD *)(v51 + 24);
}
}
if ( (unsigned int)v22 >= 0xFFFFFFF7 )
{
v52 = *(_DWORD *)v15;
v53 = (unsigned int)(*(_DWORD *)v15 - 1);
*(_DWORD *)v15 = v53;
if ( v52 <= 1 )
js_free_value_rt(v47, (_QWORD *)v15, v22, v53, v25, v24);
}
return v65;
}
v30 = v17 + 24;
v31 = v19 & 0x7FFFFFFF;
v32 = v15 + 24;
if ( (int)v19 < 0 )
{
memcpy(v30 + 2 * v31, v32, 2 * (int)v18);
*(_QWORD *)(v17 + 4) = ((unsigned int)*(_QWORD *)(v17 + 4) + *(_DWORD *)(v15 + 4)) & 0x7FFFFFFF | *(_QWORD *)(v17 + 4) & 0xFFFFFFFF80000000LL;
}
else
{
memcpy(v31 + v30, v32, v18 & 0x7FFFFFFF);
v33 = *(_QWORD *)(v17 + 4);
v34 = ((_DWORD)v33 + *(_DWORD *)(v15 + 4)) & 0x7FFFFFFF;
*(_QWORD *)(v17 + 4) = v34 | v33 & 0xFFFFFFFF80000000LL;
*(_BYTE *)(v17 + v34 + 24) = 0;
}
a1 = v20;
}
if ( (unsigned int)v14 >= 0xFFFFFFF7 )
{
v39 = *(_QWORD *)(a1 + 24);
v40 = *(_DWORD *)v15;
v41 = (unsigned int)(*(_DWORD *)v15 - 1);
*(_DWORD *)v15 = v41;
if ( v40 <= 1 )
js_free_value_rt(v39, (_QWORD *)v15, v14, v41, a5, a6);
}
return v17;
}
|
JS_ConcatString:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,R8
MOV R15,RCX
MOV RBP,RDX
MOV RBX,RSI
CMP EBP,-0x7
JNZ 0x0014140e
LAB_00141121:
MOV EAX,0xfffffff9
CMP R14D,EAX
JNZ 0x0014144a
LAB_0014112f:
MOV RDX,qword ptr [R15 + 0x4]
TEST EDX,0x7fffffff
JZ 0x00141320
CMP dword ptr [RBX],0x1
MOV R13,qword ptr [RBX + 0x4]
JNZ 0x0014119a
MOV EAX,R13D
XOR EAX,EDX
JS 0x0014119a
MOV R12,RDI
MOV RAX,qword ptr [RDI + 0x18]
MOV RDI,RBX
CALL qword ptr [RAX + 0x20]
MOV R13,qword ptr [RBX + 0x4]
MOV R8D,0x7fffffff
MOVSXD RSI,R13D
MOV EDI,R13D
AND EDI,R8D
MOV RDX,qword ptr [R15 + 0x4]
AND R8D,EDX
ADD EDI,R8D
MOV ECX,EDX
SHR ECX,0x1f
SHL EDI,CL
MOVSXD RCX,EDI
SAR RSI,0x1f
ADD RCX,RSI
ADD RCX,0x19
CMP RAX,RCX
JNC 0x00141277
MOV RDI,R12
LAB_0014119a:
MOV qword ptr [RSP + 0x10],RBP
MOV RBP,R14
MOV R14D,0x7fffffff
MOV EAX,R13D
AND EAX,R14D
AND R14D,EDX
ADD R14,RAX
CMP R14D,0x40000000
JC 0x001411e9
LEA RSI,[0x1a0236]
MOV qword ptr [RSP],0x0
XOR EAX,EAX
MOV R14,RDI
CALL 0x001205f0
MOV R8,R14
MOV R12D,0x6
MOV R13,qword ptr [RSP + 0x10]
JMP 0x001413af
LAB_001411e9:
OR R13D,EDX
MOV EDX,R13D
SHR EDX,0x1f
MOV qword ptr [RSP + 0x8],RDI
MOV ESI,R14D
CALL 0x00120686
TEST RAX,RAX
JZ 0x0014125a
MOV R12,RAX
ADD R12,0x18
TEST R13D,R13D
MOV qword ptr [RSP],RAX
JS 0x001412be
LEA RSI,[RBX + 0x18]
MOV R13D,0x7fffffff
MOV RDX,qword ptr [RBX + 0x4]
AND RDX,R13
MOV RDI,R12
CALL 0x0010e5a0
MOV RDI,qword ptr [RBX + 0x4]
AND RDI,R13
ADD RDI,R12
LEA RSI,[R15 + 0x18]
AND R13,qword ptr [R15 + 0x4]
MOV RDX,R13
CALL 0x0010e5a0
MOV byte ptr [R12 + R14*0x1],0x0
MOV R13,qword ptr [RSP + 0x10]
JMP 0x001413a3
LAB_0014125a:
MOV R12D,0x6
MOV qword ptr [RSP],0x0
MOV R13,qword ptr [RSP + 0x10]
MOV R8,qword ptr [RSP + 0x8]
JMP 0x001413af
LAB_00141277:
LEA RDI,[RBX + 0x18]
MOV EAX,R13D
AND EAX,0x7fffffff
LEA RSI,[R15 + 0x18]
TEST R13D,R13D
JS 0x001412f1
ADD RDI,RAX
AND EDX,0x7fffffff
CALL 0x0010e5a0
MOV RAX,qword ptr [RBX + 0x4]
MOV ECX,dword ptr [R15 + 0x4]
ADD ECX,EAX
AND ECX,0x7fffffff
AND RAX,-0x80000000
OR RAX,RCX
MOV qword ptr [RBX + 0x4],RAX
MOV byte ptr [RBX + RCX*0x1 + 0x18],0x0
JMP 0x0014131d
LAB_001412be:
MOV RDI,qword ptr [RBX + 0x4]
MOV EDX,EDI
AND EDX,0x7fffffff
LEA RSI,[RBX + 0x18]
TEST EDI,EDI
JS 0x0014134b
TEST EDX,EDX
JZ 0x00141355
AND EDI,0x7fffffff
XOR ECX,ECX
LAB_001412de:
MOVZX EDX,byte ptr [RSI + RCX*0x1]
MOV word ptr [R12 + RCX*0x2],DX
INC RCX
CMP RDI,RCX
JNZ 0x001412de
JMP 0x00141355
LAB_001412f1:
LEA RDI,[RDI + RAX*0x2]
ADD R8D,R8D
MOVSXD RDX,R8D
CALL 0x0010e5a0
MOV RAX,qword ptr [RBX + 0x4]
MOV ECX,dword ptr [R15 + 0x4]
ADD ECX,EAX
AND ECX,0x7fffffff
AND RAX,-0x80000000
OR RAX,RCX
MOV qword ptr [RBX + 0x4],RAX
LAB_0014131d:
MOV RDI,R12
LAB_00141320:
CMP R14D,-0x9
JC 0x00141343
MOV RDI,qword ptr [RDI + 0x18]
MOV EAX,dword ptr [R15]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R15],ECX
CMP EAX,0x1
JG 0x00141343
MOV RSI,R15
MOV RDX,R14
CALL 0x00120d90
LAB_00141343:
MOV R12,RBP
JMP 0x001413f9
LAB_0014134b:
ADD EDX,EDX
MOV RDI,R12
CALL 0x0010e5a0
LAB_00141355:
MOV EAX,dword ptr [RBX + 0x4]
ADD EAX,EAX
ADD R12,RAX
MOV RAX,qword ptr [R15 + 0x4]
MOV EDX,EAX
AND EDX,0x7fffffff
LEA RSI,[R15 + 0x18]
TEST EAX,EAX
MOV R13,qword ptr [RSP + 0x10]
JS 0x00141399
TEST EDX,EDX
MOV R8,qword ptr [RSP + 0x8]
JZ 0x001413a8
AND EAX,0x7fffffff
XOR ECX,ECX
LAB_00141386:
MOVZX EDX,byte ptr [RSI + RCX*0x1]
MOV word ptr [R12 + RCX*0x2],DX
INC RCX
CMP RAX,RCX
JNZ 0x00141386
JMP 0x001413a8
LAB_00141399:
ADD EDX,EDX
MOV RDI,R12
CALL 0x0010e5a0
LAB_001413a3:
MOV R8,qword ptr [RSP + 0x8]
LAB_001413a8:
MOV R12,-0x7
LAB_001413af:
MOV RDI,qword ptr [R8 + 0x18]
CMP R13D,-0x9
JC 0x001413d7
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX],ECX
CMP EAX,0x1
JG 0x001413d7
MOV RSI,RBX
MOV RDX,R13
MOV RBX,R8
CALL 0x00120d90
MOV RDI,qword ptr [RBX + 0x18]
LAB_001413d7:
CMP EBP,-0x9
JC 0x001413f5
MOV EAX,dword ptr [R15]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R15],ECX
CMP EAX,0x1
JG 0x001413f5
MOV RSI,R15
MOV RDX,RBP
CALL 0x00120d90
LAB_001413f5:
MOV RBX,qword ptr [RSP]
LAB_001413f9:
MOV RAX,RBX
MOV RDX,R12
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014140e:
MOV R13,RDI
MOV RSI,RBX
MOV RDX,RBP
CALL 0x0013479d
MOV RBP,RDX
CMP EBP,0x6
JNZ 0x0014148e
MOV R12D,0x6
CMP R14D,-0x9
JC 0x00141487
MOV RDI,qword ptr [R13 + 0x18]
MOV EAX,dword ptr [R15]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R15],ECX
CMP EAX,0x1
JG 0x00141487
MOV RSI,R15
MOV RDX,R14
JMP 0x00141482
LAB_0014144a:
MOV R13,RDI
MOV RSI,R15
MOV RDX,R14
CALL 0x0013479d
MOV R14,RDX
CMP R14D,0x6
JNZ 0x00141499
MOV R12D,0x6
CMP EBP,-0x9
JC 0x00141487
MOV RDI,qword ptr [R13 + 0x18]
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX],ECX
CMP EAX,0x1
JG 0x00141487
MOV RSI,RBX
MOV RDX,RBP
LAB_00141482:
CALL 0x00120d90
LAB_00141487:
XOR EBX,EBX
JMP 0x001413f9
LAB_0014148e:
MOV RBX,RAX
MOV RDI,R13
JMP 0x00141121
LAB_00141499:
MOV R15,RAX
MOV RDI,R13
JMP 0x0014112f
|
int1 [16]
JS_ConcatString(long param_1,int8 param_2,int8 param_3,int *param_4,int8 param_5)
{
int iVar1;
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
uint uVar5;
ulong uVar6;
int *piVar7;
int8 uVar8;
void *pvVar9;
uint uVar10;
long lVar11;
int *piVar12;
int1 auVar13 [16];
int1 auVar14 [16];
long local_48;
auVar14._8_8_ = param_5;
auVar14._0_8_ = param_4;
auVar13._8_8_ = param_3;
auVar13._0_8_ = param_2;
if (((int)param_3 == -7) ||
(auVar13 = JS_ToStringFree(param_1,param_2,param_3), auVar13._8_4_ != 6)) {
piVar7 = auVar13._0_8_;
if (((uint)param_5 == 0xfffffff9) ||
(auVar14 = JS_ToStringFree(param_1,param_4,param_5), auVar14._8_4_ != 6)) {
piVar12 = auVar14._0_8_;
uVar5 = (uint)*(ulong *)(piVar12 + 1);
if ((*(ulong *)(piVar12 + 1) & 0x7fffffff) == 0) {
LAB_00141320:
if (auVar14._8_4_ < 0xfffffff7) {
return auVar13;
}
uVar8 = *(int8 *)(param_1 + 0x18);
iVar1 = *piVar12;
*piVar12 = iVar1 + -1;
if (1 < iVar1) {
return auVar13;
}
js_free_value_rt(uVar8,piVar12,auVar14._8_8_);
return auVar13;
}
uVar10 = (uint)*(int8 *)(piVar7 + 1);
if ((*piVar7 == 1) && (-1 < (int)(uVar10 ^ uVar5))) {
uVar6 = (**(code **)(*(long *)(param_1 + 0x18) + 0x20))(piVar7);
uVar10 = (uint)*(int8 *)(piVar7 + 1);
uVar5 = (uint)*(ulong *)(piVar12 + 1);
if ((long)(int)((uVar10 & 0x7fffffff) + (uVar5 & 0x7fffffff) <<
((byte)(*(ulong *)(piVar12 + 1) >> 0x1f) & 1)) + ((long)(int)uVar10 >> 0x1f)
+ 0x19U <= uVar6) {
if ((int)uVar10 < 0) {
memcpy((void *)((long)piVar7 + (ulong)(uVar10 & 0x7fffffff) * 2 + 0x18),piVar12 + 6,
(long)(int)((uVar5 & 0x7fffffff) * 2));
*(ulong *)(piVar7 + 1) =
*(ulong *)(piVar7 + 1) & 0xffffffff80000000 |
(ulong)(piVar12[1] + (int)*(ulong *)(piVar7 + 1) & 0x7fffffff);
}
else {
memcpy((void *)((long)piVar7 + (ulong)(uVar10 & 0x7fffffff) + 0x18),piVar12 + 6,
(ulong)(uVar5 & 0x7fffffff));
uVar6 = (ulong)(piVar12[1] + (int)*(ulong *)(piVar7 + 1) & 0x7fffffff);
*(ulong *)(piVar7 + 1) = *(ulong *)(piVar7 + 1) & 0xffffffff80000000 | uVar6;
*(int1 *)((long)piVar7 + uVar6 + 0x18) = 0;
}
goto LAB_00141320;
}
}
lVar11 = (ulong)(uVar5 & 0x7fffffff) + (ulong)(uVar10 & 0x7fffffff);
if ((uint)lVar11 < 0x40000000) {
local_48 = js_alloc_string(param_1,lVar11,(uVar10 | uVar5) >> 0x1f);
if (local_48 == 0) {
uVar8 = 6;
local_48 = 0;
}
else {
pvVar9 = (void *)(local_48 + 0x18);
if ((int)(uVar10 | uVar5) < 0) {
uVar5 = (uint)*(ulong *)(piVar7 + 1);
if ((int)uVar5 < 0) {
memcpy(pvVar9,piVar7 + 6,(ulong)(uVar5 * 2));
}
else if ((*(ulong *)(piVar7 + 1) & 0x7fffffff) != 0) {
uVar6 = 0;
do {
*(ushort *)((long)pvVar9 + uVar6 * 2) =
(ushort)*(byte *)((long)(piVar7 + 6) + uVar6);
uVar6 = uVar6 + 1;
} while ((uVar5 & 0x7fffffff) != uVar6);
}
pvVar9 = (void *)((long)pvVar9 + (ulong)(uint)(piVar7[1] * 2));
uVar5 = (uint)*(ulong *)(piVar12 + 1);
if ((int)uVar5 < 0) {
memcpy(pvVar9,piVar12 + 6,(ulong)(uVar5 * 2));
}
else if ((*(ulong *)(piVar12 + 1) & 0x7fffffff) != 0) {
uVar6 = 0;
do {
*(ushort *)((long)pvVar9 + uVar6 * 2) =
(ushort)*(byte *)((long)(piVar12 + 6) + uVar6);
uVar6 = uVar6 + 1;
} while ((uVar5 & 0x7fffffff) != uVar6);
}
}
else {
memcpy(pvVar9,piVar7 + 6,*(ulong *)(piVar7 + 1) & 0x7fffffff);
memcpy((void *)((*(ulong *)(piVar7 + 1) & 0x7fffffff) + (long)pvVar9),piVar12 + 6,
*(ulong *)(piVar12 + 1) & 0x7fffffff);
*(int1 *)((long)pvVar9 + lVar11) = 0;
}
uVar8 = 0xfffffffffffffff9;
}
}
else {
local_48 = 0;
JS_ThrowRangeError(param_1,"invalid string length");
uVar8 = 6;
}
auVar4._8_8_ = uVar8;
auVar4._0_8_ = local_48;
auVar3._8_8_ = uVar8;
auVar3._0_8_ = local_48;
auVar2._8_8_ = uVar8;
auVar2._0_8_ = local_48;
uVar8 = *(int8 *)(param_1 + 0x18);
if ((0xfffffff6 < auVar13._8_4_) && (iVar1 = *piVar7, *piVar7 = iVar1 + -1, iVar1 < 2)) {
js_free_value_rt(uVar8,piVar7,auVar13._8_8_);
uVar8 = *(int8 *)(param_1 + 0x18);
}
if (auVar14._8_4_ < 0xfffffff7) {
return auVar2;
}
iVar1 = *piVar12;
*piVar12 = iVar1 + -1;
if (1 < iVar1) {
return auVar3;
}
js_free_value_rt(uVar8,piVar12,auVar14._8_8_);
return auVar4;
}
if (auVar13._8_4_ < 0xfffffff7) goto LAB_00141487;
uVar8 = *(int8 *)(param_1 + 0x18);
iVar1 = *piVar7;
*piVar7 = iVar1 + -1;
}
else {
if ((uint)param_5 < 0xfffffff7) goto LAB_00141487;
uVar8 = *(int8 *)(param_1 + 0x18);
iVar1 = *param_4;
*param_4 = iVar1 + -1;
auVar13 = auVar14;
}
if (iVar1 < 2) {
js_free_value_rt(uVar8,auVar13._0_8_,auVar13._8_8_);
}
LAB_00141487:
return ZEXT816(6) << 0x40;
}
|
|
64,763 |
minja::Value::operator+(minja::Value const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value operator+(const Value& rhs) const {
if (is_string() || rhs.is_string()) {
return to_str() + rhs.to_str();
} else if (is_number_integer() && rhs.is_number_integer()) {
return get<int64_t>() + rhs.get<int64_t>();
} else if (is_array() && rhs.is_array()) {
auto res = Value::array();
for (const auto& item : *array_) res.push_back(item);
for (const auto& item : *rhs.array_) res.push_back(item);
return res;
} else {
return get<double>() + rhs.get<double>();
}
}
|
O2
|
cpp
|
minja::Value::operator+(minja::Value const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb 0x40(%rsi), %al
cmpb $0x3, %al
je 0x701eb
movb 0x40(%r14), %cl
cmpb $0x3, %cl
jne 0x70256
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x70108
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x70108
leaq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x3914b
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x65bfc
leaq 0x10(%rsp), %rdi
callq 0x241b8
leaq 0x48(%rsp), %rdi
callq 0x241b8
leaq 0x68(%rsp), %rdi
callq 0x241b8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addb $-0x5, %al
addb $-0x5, %cl
orb %al, %cl
cmpb $0x1, %cl
ja 0x7028a
movq %r15, %rdi
callq 0x62c54
movq %rax, %r15
movq %r14, %rdi
callq 0x62c54
addq %r15, %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x62d0a
jmp 0x70244
cmpq $0x0, 0x10(%r15)
je 0x702dd
cmpq $0x0, 0x10(%r14)
je 0x702dd
xorpd %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movapd %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x69060
leaq 0x30(%rsp), %rdi
callq 0x68872
movq 0x10(%r15), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x7030f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x690cc
addq $0x50, %r15
jmp 0x702c7
movq %r15, %rdi
callq 0x62d28
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x62d28
addsd 0x8(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x62dde
jmp 0x70244
movq 0x10(%r14), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x70244
movq %rbx, %rdi
movq %r14, %rsi
callq 0x690cc
addq $0x50, %r14
jmp 0x7031a
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x68872
jmp 0x7037d
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241b8
jmp 0x70355
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x241b8
jmp 0x70364
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x241b8
jmp 0x7037d
jmp 0x70372
movq %rax, %r14
movq %rbx, %rdi
callq 0x62c1e
movq %r14, %rdi
callq 0x23f80
nop
|
_ZNK5minja5ValueplERKS0_:
push r15
push r14
push r12
push rbx
sub rsp, 88h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov al, [rsi+40h]
cmp al, 3
jz short loc_701EB
mov cl, [r14+40h]
cmp cl, 3
jnz short loc_70256
loc_701EB:
lea rdi, [rsp+0A8h+var_40]; this
mov rsi, r15; minja::Value *
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
lea rdi, [rsp+0A8h+var_60]; this
mov rsi, r14; minja::Value *
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
lea rdi, [rsp+0A8h+var_98]
lea rsi, [rsp+0A8h+var_40]
lea rdx, [rsp+0A8h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rsi, [rsp+0A8h+var_98]
mov rdi, rbx
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
lea rdi, [rsp+0A8h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_70244:
mov rax, rbx
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
retn
loc_70256:
add al, 0FBh
add cl, 0FBh
or cl, al
cmp cl, 1
ja short loc_7028A
mov rdi, r15
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r15, rax
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
add rax, r15
lea rsi, [rsp+0A8h+var_98]; __int64 *
mov [rsi], rax
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKl; minja::Value::Value(long const&)
jmp short loc_70244
loc_7028A:
cmp qword ptr [r15+10h], 0
jz short loc_702DD
cmp qword ptr [r14+10h], 0
jz short loc_702DD
xorpd xmm0, xmm0
lea rsi, [rsp+0A8h+var_78]
movapd xmmword ptr [rsi], xmm0
and qword ptr [rsi+10h], 0
mov rdi, rbx
call _ZN5minja5Value5arrayESt6vectorIS0_SaIS0_EE; minja::Value::array(std::vector<minja::Value>)
lea rdi, [rsp+0A8h+var_78]
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
mov rax, [r15+10h]
mov r15, [rax]
mov r12, [rax+8]
loc_702C7:
cmp r15, r12
jz short loc_7030F
mov rdi, rbx; this
mov rsi, r15; minja::Value *
call _ZN5minja5Value9push_backERKS0_; minja::Value::push_back(minja::Value const&)
add r15, 50h ; 'P'
jmp short loc_702C7
loc_702DD:
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+0A8h+var_A0], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
addsd xmm0, [rsp+0A8h+var_A0]
lea rsi, [rsp+0A8h+var_98]; double *
movsd qword ptr [rsi], xmm0
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKd; minja::Value::Value(double const&)
jmp loc_70244
loc_7030F:
mov rax, [r14+10h]
mov r14, [rax]
mov r15, [rax+8]
loc_7031A:
cmp r14, r15
jz loc_70244
mov rdi, rbx; this
mov rsi, r14; minja::Value *
call _ZN5minja5Value9push_backERKS0_; minja::Value::push_back(minja::Value const&)
add r14, 50h ; 'P'
jmp short loc_7031A
mov r14, rax
lea rdi, [rsp+arg_28]
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
jmp short loc_7037D
mov r14, rax
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_70355
mov r14, rax
loc_70355:
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_70364
mov r14, rax
loc_70364:
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7037D
jmp short $+2
loc_70372:
mov r14, rax
mov rdi, rbx; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_7037D:
mov rdi, r14
call __Unwind_Resume
|
minja::Value * minja::Value::operator+(
minja::Value *this,
minja::Value *a2,
const minja::Value ***a3,
double a4)
{
char v5; // al
char v6; // cl
long long v8; // r15
const minja::Value **v9; // rax
const minja::Value *v10; // r15
const minja::Value *v11; // r12
const minja::Value **v12; // rax
const minja::Value *v13; // r14
const minja::Value *v14; // r15
long long v15[4]; // [rsp+10h] [rbp-98h] BYREF
__int128 v16; // [rsp+30h] [rbp-78h] BYREF
long long v17; // [rsp+40h] [rbp-68h]
_QWORD v18[4]; // [rsp+48h] [rbp-60h] BYREF
_QWORD v19[8]; // [rsp+68h] [rbp-40h] BYREF
v5 = *((_BYTE *)a2 + 64);
if ( v5 == 3 || (v6 = *((_BYTE *)a3 + 64), v6 == 3) )
{
minja::Value::to_str[abi:cxx11]((std::__cxx11 *)v19, a2, a4);
minja::Value::to_str[abi:cxx11]((std::__cxx11 *)v18, (minja::Value *)a3, a4);
std::operator+<char>((long long)v15, v19, v18);
minja::Value::Value((long long)this, (long long)v15);
std::string::~string(v15);
std::string::~string(v18);
std::string::~string(v19);
}
else if ( (unsigned __int8)((v5 - 5) | (v6 - 5)) > 1u )
{
if ( *((_QWORD *)a2 + 2) && a3[2] )
{
v16 = 0LL;
v17 = 0LL;
minja::Value::array((long long)this, (long long *)&v16);
std::vector<minja::Value>::~vector((long long)&v16);
v9 = (const minja::Value **)*((_QWORD *)a2 + 2);
v10 = *v9;
v11 = v9[1];
while ( v10 != v11 )
{
minja::Value::push_back(this, v10);
v10 = (const minja::Value *)((char *)v10 + 80);
}
v12 = a3[2];
v13 = *v12;
v14 = v12[1];
while ( v13 != v14 )
{
minja::Value::push_back(this, v13);
v13 = (const minja::Value *)((char *)v13 + 80);
}
}
else
{
minja::Value::get<double>(a2);
minja::Value::get<double>((minja::Value *)a3);
*(double *)v15 = a4 + a4;
minja::Value::Value(this, (const double *)v15);
}
}
else
{
v8 = minja::Value::get<long>(a2);
v15[0] = v8 + minja::Value::get<long>((minja::Value *)a3);
minja::Value::Value(this, v15);
}
return this;
}
|
operator+:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
CMP AL,0x3
JZ 0x001701eb
MOV CL,byte ptr [R14 + 0x40]
CMP CL,0x3
JNZ 0x00170256
LAB_001701eb:
LEA RDI,[RSP + 0x68]
MOV RSI,R15
CALL 0x00170108
LAB_001701f8:
LEA RDI,[RSP + 0x48]
MOV RSI,R14
CALL 0x00170108
LAB_00170205:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x68]
LEA RDX,[RSP + 0x48]
CALL 0x0013914b
LAB_00170219:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00165bfc
LAB_00170226:
LEA RDI,[RSP + 0x10]
CALL 0x001241b8
LEA RDI,[RSP + 0x48]
CALL 0x001241b8
LEA RDI,[RSP + 0x68]
CALL 0x001241b8
LAB_00170244:
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00170256:
ADD AL,0xfb
ADD CL,0xfb
OR CL,AL
CMP CL,0x1
JA 0x0017028a
MOV RDI,R15
CALL 0x00162c54
MOV R15,RAX
MOV RDI,R14
CALL 0x00162c54
ADD RAX,R15
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RAX
MOV RDI,RBX
CALL 0x00162d0a
JMP 0x00170244
LAB_0017028a:
CMP qword ptr [R15 + 0x10],0x0
JZ 0x001702dd
CMP qword ptr [R14 + 0x10],0x0
JZ 0x001702dd
XORPD XMM0,XMM0
LEA RSI,[RSP + 0x30]
MOVAPD xmmword ptr [RSI],XMM0
AND qword ptr [RSI + 0x10],0x0
LAB_001702aa:
MOV RDI,RBX
CALL 0x00169060
LEA RDI,[RSP + 0x30]
CALL 0x00168872
MOV RAX,qword ptr [R15 + 0x10]
MOV R15,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
LAB_001702c7:
CMP R15,R12
JZ 0x0017030f
LAB_001702cc:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001690cc
LAB_001702d7:
ADD R15,0x50
JMP 0x001702c7
LAB_001702dd:
MOV RDI,R15
CALL 0x00162d28
MOVSD qword ptr [RSP + 0x8],XMM0
MOV RDI,R14
CALL 0x00162d28
ADDSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x10]
MOVSD qword ptr [RSI],XMM0
MOV RDI,RBX
CALL 0x00162dde
JMP 0x00170244
LAB_0017030f:
MOV RAX,qword ptr [R14 + 0x10]
MOV R14,qword ptr [RAX]
MOV R15,qword ptr [RAX + 0x8]
LAB_0017031a:
CMP R14,R15
JZ 0x00170244
LAB_00170323:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001690cc
LAB_0017032e:
ADD R14,0x50
JMP 0x0017031a
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
Value * __thiscall minja::Value::operator+(Value *this,Value *param_1)
{
Value *pVVar1;
long lVar2;
long lVar3;
Value *in_RDX;
Value *pVVar4;
double dVar5;
double local_98 [4];
int8 local_78;
int8 uStack_70;
int8 local_68;
string local_60 [32];
string local_40 [32];
if ((param_1[0x40] == (Value)0x3) || (in_RDX[0x40] == (Value)0x3)) {
to_str_abi_cxx11_();
/* try { // try from 001701f8 to 00170204 has its CatchHandler @ 00170361 */
to_str_abi_cxx11_();
/* try { // try from 00170205 to 00170218 has its CatchHandler @ 00170352 */
std::operator+((string *)local_98,local_40);
/* try { // try from 00170219 to 00170225 has its CatchHandler @ 00170343 */
Value(this,(string *)local_98);
std::__cxx11::string::~string((string *)local_98);
std::__cxx11::string::~string(local_60);
std::__cxx11::string::~string(local_40);
}
else if ((byte)((char)in_RDX[0x40] - 5U | (char)param_1[0x40] - 5U) < 2) {
lVar2 = get<long>(param_1);
lVar3 = get<long>(in_RDX);
local_98[0] = (double)(lVar3 + lVar2);
Value(this,(long *)local_98);
}
else if ((*(long *)(param_1 + 0x10) == 0) || (*(long *)(in_RDX + 0x10) == 0)) {
dVar5 = get<double>(param_1);
local_98[0] = get<double>(in_RDX);
local_98[0] = local_98[0] + dVar5;
Value(this,local_98);
}
else {
local_78 = 0;
uStack_70 = 0;
local_68 = 0;
/* try { // try from 001702aa to 001702b1 has its CatchHandler @ 00170334 */
array(this);
std::vector<minja::Value,std::allocator<minja::Value>>::~vector
((vector<minja::Value,std::allocator<minja::Value>> *)&local_78);
pVVar1 = (Value *)(*(int8 **)(param_1 + 0x10))[1];
for (pVVar4 = (Value *)**(int8 **)(param_1 + 0x10); pVVar4 != pVVar1;
pVVar4 = pVVar4 + 0x50) {
/* try { // try from 001702cc to 001702d6 has its CatchHandler @ 00170372 */
push_back(this,pVVar4);
}
pVVar1 = (Value *)(*(int8 **)(in_RDX + 0x10))[1];
for (pVVar4 = (Value *)**(int8 **)(in_RDX + 0x10); pVVar4 != pVVar1;
pVVar4 = pVVar4 + 0x50) {
/* try { // try from 00170323 to 0017032d has its CatchHandler @ 00170370 */
push_back(this,pVVar4);
}
}
return this;
}
|
|
64,764 |
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>::type_name() const
|
monkey531[P]llama/common/json.hpp
|
JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
case value_t::string:
return "string";
case value_t::boolean:
return "boolean";
case value_t::binary:
return "binary";
case value_t::discarded:
return "discarded";
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
default:
return "number";
}
}
|
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>::type_name() const:
movzbl (%rdi), %eax
cmpq $0x9, %rax
ja 0x3d7f0
leaq 0x69b9c(%rip), %rcx # 0xa7384
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x6c0d7(%rip), %rax # 0xa98ce
retq
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv:
movzx eax, byte ptr [rdi]
cmp rax, 9
ja short loc_3D7F0
lea rcx, unk_A7384
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_3D7F0:
lea rax, aNumber; "number"
retn
|
const char * nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(
unsigned __int8 *a1)
{
unsigned long long v1; // rax
v1 = *a1;
if ( v1 > 9 )
return "number";
else
return (char *)dword_A7384 + dword_A7384[v1];
}
|
type_name:
MOVZX EAX,byte ptr [RDI]
CMP RAX,0x9
JA 0x0013d7f0
LEA RCX,[0x1a7384]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_0013d7f0:
LEA RAX,[0x1a98ce]
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>::type_name() const */
char * __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>
::type_name(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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)
{
if ((ulong)(byte)*this < 10) {
return &DAT_001a7384 + *(int *)(&DAT_001a7384 + (ulong)(byte)*this * 4);
}
return "number";
}
|
|
64,765 |
testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
|
giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc
|
AssertionResult EqFailure(const char* lhs_expression,
const char* rhs_expression,
const std::string& lhs_value,
const std::string& rhs_value, bool ignoring_case) {
Message msg;
msg << "Expected equality of these values:";
msg << "\n " << lhs_expression;
if (lhs_value != lhs_expression) {
msg << "\n Which is: " << lhs_value;
}
msg << "\n " << rhs_expression;
if (rhs_value != rhs_expression) {
msg << "\n Which is: " << rhs_value;
}
if (ignoring_case) {
msg << "\nIgnoring case";
}
if (!lhs_value.empty() && !rhs_value.empty()) {
const std::vector<std::string> lhs_lines = SplitEscapedString(lhs_value);
const std::vector<std::string> rhs_lines = SplitEscapedString(rhs_value);
if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
msg << "\nWith diff:\n"
<< edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
}
}
return AssertionFailure() << msg;
}
|
O1
|
cpp
|
testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1cd64
movq (%rbx), %rdi
addq $0x10, %rdi
leaq 0x24d4b(%rip), %rsi # 0x42b20
movl $0x22, %edx
callq 0x85b0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x24d54(%rip), %rsi # 0x42b43
movl $0x3, %edx
callq 0x85b0
movq 0x8(%rsp), %rbx
addq $0x10, %rbx
testq %r13, %r13
je 0x1de17
movq %r13, %rdi
callq 0x8200
movq %rax, %rdx
movq %r13, %rsi
jmp 0x1de23
movl $0x6, %edx
leaq 0x227c6(%rip), %rsi # 0x405e9
movq %rbx, %rdi
callq 0x85b0
movq %r15, %rdi
movq %r13, %rsi
callq 0x8160
testl %eax, %eax
je 0x1de69
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x24cfd(%rip), %rsi # 0x42b47
movl $0xf, %edx
callq 0x85b0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x85b0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x24cca(%rip), %rsi # 0x42b43
movl $0x3, %edx
callq 0x85b0
movq 0x8(%rsp), %rbx
addq $0x10, %rbx
testq %r12, %r12
je 0x1dea1
movq %r12, %rdi
callq 0x8200
movq %rax, %rdx
movq %r12, %rsi
jmp 0x1dead
movl $0x6, %edx
leaq 0x2273c(%rip), %rsi # 0x405e9
movq %rbx, %rdi
callq 0x85b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x8160
testl %eax, %eax
je 0x1def3
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x24c73(%rip), %rsi # 0x42b47
movl $0xf, %edx
callq 0x85b0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x85b0
testb %bpl, %bpl
je 0x1df12
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x24c4f(%rip), %rsi # 0x42b57
movl $0xe, %edx
callq 0x85b0
cmpq $0x0, 0x8(%r15)
movq 0x30(%rsp), %rbx
je 0x1dfe1
cmpq $0x0, 0x8(%r14)
je 0x1dfe1
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x1e0b4
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x1e0b4
movq 0x58(%rsp), %rax
subq 0x50(%rsp), %rax
cmpq $0x20, %rax
ja 0x1df67
movq 0x40(%rsp), %rax
subq 0x38(%rsp), %rax
cmpq $0x21, %rax
jb 0x1dfcd
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x24bef(%rip), %rsi # 0x42b66
movl $0xc, %edx
callq 0x85b0
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movl $0x2, %ecx
callq 0x1d71a
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x85b0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dfcd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0x38(%rsp), %rdi
callq 0x3244c
leaq 0x50(%rsp), %rdi
callq 0x3244c
leaq 0x18(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x32184
movq %rbx, %rdi
movq %rax, %rsi
callq 0xefc4
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x1e01e
movq %r14, %rdi
callq 0xde4a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1e02e
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e065
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x1e065
jmp 0x1e062
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3244c
jmp 0x1e074
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3244c
jmp 0x1e09c
jmp 0x1e099
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x1e09c
movq %r14, %rdi
callq 0xde4a
jmp 0x1e09c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1e0ac
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8990
|
_ZN7testing8internal9EqFailureEPKcS2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_b:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov ebp, r9d
mov r14, r8
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov [rsp+98h+var_68], rdi
lea rbx, [rsp+98h+var_90]
mov rdi, rbx; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rdi, [rbx]
add rdi, 10h
lea rsi, aExpectedEquali; "Expected equality of these values:"
mov edx, 22h ; '"'
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, asc_42B43; "\n "
mov edx, 3
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [rsp+98h+var_90]
add rbx, 10h
test r13, r13
jz short loc_1DE17
mov rdi, r13
call _strlen
mov rdx, rax
mov rsi, r13
jmp short loc_1DE23
loc_1DE17:
mov edx, 6
lea rsi, aNull; "(null)"
loc_1DE23:
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, r15
mov rsi, r13
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_1DE69
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, aWhichIs; "\n Which is: "
mov edx, 0Fh
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+98h+var_90]
add rdi, 10h
mov rsi, [r15]
mov rdx, [r15+8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_1DE69:
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, asc_42B43; "\n "
mov edx, 3
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [rsp+98h+var_90]
add rbx, 10h
test r12, r12
jz short loc_1DEA1
mov rdi, r12
call _strlen
mov rdx, rax
mov rsi, r12
jmp short loc_1DEAD
loc_1DEA1:
mov edx, 6
lea rsi, aNull; "(null)"
loc_1DEAD:
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, r14
mov rsi, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_1DEF3
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, aWhichIs; "\n Which is: "
mov edx, 0Fh
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+98h+var_90]
add rdi, 10h
mov rsi, [r14]
mov rdx, [r14+8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_1DEF3:
test bpl, bpl
jz short loc_1DF12
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, aIgnoringCase; "\nIgnoring case"
mov edx, 0Eh
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_1DF12:
cmp qword ptr [r15+8], 0
mov rbx, [rsp+98h+var_68]
jz loc_1DFE1
cmp qword ptr [r14+8], 0
jz loc_1DFE1
lea rdi, [rsp+98h+var_48]; int
mov rsi, r15; int
call _ZN7testing8internal12_GLOBAL__N_118SplitEscapedStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::`anonymous namespace'::SplitEscapedString(std::string const&)
lea rdi, [rsp+98h+var_60]; int
mov rsi, r14; int
call _ZN7testing8internal12_GLOBAL__N_118SplitEscapedStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::`anonymous namespace'::SplitEscapedString(std::string const&)
mov rax, [rsp+98h+var_40]
sub rax, qword ptr [rsp+98h+var_48]
cmp rax, 20h ; ' '
ja short loc_1DF67
mov rax, [rsp+98h+var_58]
sub rax, qword ptr [rsp+98h+var_60]
cmp rax, 21h ; '!'
jb short loc_1DFCD
loc_1DF67:
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, aWithDiff; "\nWith diff:\n"
mov edx, 0Ch
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdi, [rsp+98h+var_88]
lea rsi, [rsp+98h+var_48]
lea rdx, [rsp+98h+var_60]
mov ecx, 2
call _ZN7testing8internal13edit_distance17CreateUnifiedDiffERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS8_EESC_m; testing::internal::edit_distance::CreateUnifiedDiff(std::vector<std::string> const&,std::vector<std::string> const&,ulong)
mov rdi, [rsp+98h+var_90]
add rdi, 10h
mov rsi, [rsp+98h+var_88]
mov rdx, [rsp+98h+var_80]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+98h+var_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1DFCD
mov rsi, [rsp+98h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DFCD:
lea rdi, [rsp+98h+var_60]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+98h+var_48]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_1DFE1:
lea r14, [rsp+98h+var_80]
mov byte ptr [r14-8], 0
mov qword ptr [r14], 0
lea rdi, [rsp+98h+var_88]; this
lea rsi, [rsp+98h+var_90]
call _ZN7testing15AssertionResultlsINS_7MessageEEERS0_RKT_; testing::AssertionResult::operator<<<testing::Message>(testing::Message const&)
mov rdi, rbx
mov rsi, rax
call _ZN7testing15AssertionResultC2ERKS0_; testing::AssertionResult::AssertionResult(testing::AssertionResult const&)
mov rsi, [rsp+98h+var_80]
test rsi, rsi
jz short loc_1E01E
mov rdi, r14
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_1E01E:
mov rdi, [rsp+98h+var_90]
test rdi, rdi
jz short loc_1E02E
mov rax, [rdi]
call qword ptr [rax+8]
loc_1E02E:
mov rax, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rax, [rsp+arg_18]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1E065
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1E065
jmp short $+2
loc_1E062:
mov rbx, rax
loc_1E065:
lea rdi, [rsp+arg_30]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_1E074
mov rbx, rax
loc_1E074:
lea rdi, [rsp+arg_48]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_1E09C
jmp short loc_1E099
mov rbx, rax
mov rsi, [rsp+arg_10]
test rsi, rsi
jz short loc_1E09C
mov rdi, r14
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
jmp short loc_1E09C
loc_1E099:
mov rbx, rax
loc_1E09C:
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_1E0AC
mov rax, [rdi]
call qword ptr [rax+8]
loc_1E0AC:
mov rdi, rbx
call __Unwind_Resume
|
testing::AssertionResult * testing::internal::EqFailure(
testing::AssertionResult *a1,
const char *a2,
const char *a3,
_QWORD *a4,
_QWORD *a5,
char a6)
{
const char *v10; // r13
long long v11; // rbx
long long v12; // rdx
long long v13; // rbx
long long v14; // rdx
const char *v15; // rsi
int v16; // edx
int v17; // ecx
int v18; // r8d
int v19; // r9d
testing::AssertionResult *v20; // rbx
int v21; // edx
int v22; // ecx
int v23; // r8d
int v24; // r9d
const testing::AssertionResult *v25; // rax
void *v27; // [rsp+0h] [rbp-98h]
void *v28; // [rsp+0h] [rbp-98h]
long long v29; // [rsp+8h] [rbp-90h] BYREF
long long *v30; // [rsp+10h] [rbp-88h] BYREF
long long v31; // [rsp+18h] [rbp-80h] BYREF
long long v32; // [rsp+20h] [rbp-78h] BYREF
testing::AssertionResult *v33; // [rsp+30h] [rbp-68h]
int v34[2]; // [rsp+38h] [rbp-60h] BYREF
long long v35; // [rsp+40h] [rbp-58h]
int v36[2]; // [rsp+50h] [rbp-48h] BYREF
long long v37; // [rsp+58h] [rbp-40h]
v10 = a2;
v33 = a1;
testing::Message::Message((testing::Message *)&v29);
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "Expected equality of these values:", 34LL);
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\n ", 3LL);
v11 = v29 + 16;
if ( a2 )
{
v12 = strlen(a2);
}
else
{
v12 = 6LL;
a2 = "(null)";
}
std::__ostream_insert<char,std::char_traits<char>>(v11, a2, v12);
if ( (unsigned int)std::string::compare(a4, v10) )
{
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\n Which is: ", 15LL);
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, *a4, a4[1]);
}
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\n ", 3LL);
v13 = v29 + 16;
if ( a3 )
{
v14 = strlen(a3);
v15 = a3;
}
else
{
v14 = 6LL;
v15 = "(null)";
}
std::__ostream_insert<char,std::char_traits<char>>(v13, v15, v14);
if ( (unsigned int)std::string::compare(a5, a3) )
{
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\n Which is: ", 15LL);
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, *a5, a5[1]);
}
if ( a6 )
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\nIgnoring case", 14LL);
v20 = v33;
if ( a4[1] && a5[1] )
{
testing::internal::`anonymous namespace'::SplitEscapedString(
(int)v36,
(int)a4,
v16,
v17,
v18,
v19,
v27,
v29,
(long long)v30);
testing::internal::`anonymous namespace'::SplitEscapedString(
(int)v34,
(int)a5,
v21,
v22,
v23,
v24,
v28,
v29,
(long long)v30);
if ( (unsigned long long)(v37 - *(_QWORD *)v36) > 0x20 || (unsigned long long)(v35 - *(_QWORD *)v34) >= 0x21 )
{
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\nWith diff:\n", 12LL);
testing::internal::edit_distance::CreateUnifiedDiff(
(long long)&v30,
(long long *)v36,
(long long *)v34,
(char *)&dword_0 + 2);
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, v30, v31);
if ( v30 != &v32 )
operator delete(v30, v32 + 1);
}
std::vector<std::string>::~vector(v34);
std::vector<std::string>::~vector(v36);
}
LOBYTE(v30) = 0;
v25 = (const testing::AssertionResult *)testing::AssertionResult::operator<<<testing::Message>(
(testing::AssertionResult *)&v30,
(long long)v27,
v29,
(int)v30,
0LL);
testing::AssertionResult::AssertionResult(v20, v25);
if ( v31 )
std::default_delete<std::string>::operator()((long long)&v31, v31);
if ( v29 )
(*(void ( **)(long long))(*(_QWORD *)v29 + 8LL))(v29);
return v20;
}
|
EqFailure:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV EBP,R9D
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOV R13,RSI
MOV qword ptr [RSP + 0x30],RDI
LEA RBX,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0011cd64
MOV RDI,qword ptr [RBX]
ADD RDI,0x10
LAB_0011ddce:
LEA RSI,[0x142b20]
MOV EDX,0x22
CALL 0x001085b0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LEA RSI,[0x142b43]
MOV EDX,0x3
CALL 0x001085b0
MOV RBX,qword ptr [RSP + 0x8]
ADD RBX,0x10
TEST R13,R13
JZ 0x0011de17
MOV RDI,R13
CALL 0x00108200
MOV RDX,RAX
MOV RSI,R13
JMP 0x0011de23
LAB_0011de17:
MOV EDX,0x6
LEA RSI,[0x1405e9]
LAB_0011de23:
MOV RDI,RBX
CALL 0x001085b0
MOV RDI,R15
MOV RSI,R13
CALL 0x00108160
TEST EAX,EAX
JZ 0x0011de69
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LEA RSI,[0x142b47]
MOV EDX,0xf
CALL 0x001085b0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
CALL 0x001085b0
LAB_0011de69:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LEA RSI,[0x142b43]
MOV EDX,0x3
CALL 0x001085b0
MOV RBX,qword ptr [RSP + 0x8]
ADD RBX,0x10
TEST R12,R12
JZ 0x0011dea1
MOV RDI,R12
CALL 0x00108200
MOV RDX,RAX
MOV RSI,R12
JMP 0x0011dead
LAB_0011dea1:
MOV EDX,0x6
LEA RSI,[0x1405e9]
LAB_0011dead:
MOV RDI,RBX
CALL 0x001085b0
MOV RDI,R14
MOV RSI,R12
CALL 0x00108160
TEST EAX,EAX
JZ 0x0011def3
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LEA RSI,[0x142b47]
MOV EDX,0xf
CALL 0x001085b0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
CALL 0x001085b0
LAB_0011def3:
TEST BPL,BPL
JZ 0x0011df12
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LEA RSI,[0x142b57]
MOV EDX,0xe
CALL 0x001085b0
LAB_0011df12:
CMP qword ptr [R15 + 0x8],0x0
MOV RBX,qword ptr [RSP + 0x30]
JZ 0x0011dfe1
CMP qword ptr [R14 + 0x8],0x0
JZ 0x0011dfe1
LAB_0011df2d:
LEA RDI,[RSP + 0x50]
MOV RSI,R15
CALL 0x0011e0b4
LAB_0011df3a:
LEA RDI,[RSP + 0x38]
MOV RSI,R14
CALL 0x0011e0b4
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr [RSP + 0x50]
CMP RAX,0x20
JA 0x0011df67
MOV RAX,qword ptr [RSP + 0x40]
SUB RAX,qword ptr [RSP + 0x38]
CMP RAX,0x21
JC 0x0011dfcd
LAB_0011df67:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LAB_0011df70:
LEA RSI,[0x142b66]
MOV EDX,0xc
CALL 0x001085b0
LAB_0011df81:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x50]
LEA RDX,[RSP + 0x38]
MOV ECX,0x2
CALL 0x0011d71a
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
LAB_0011dfad:
CALL 0x001085b0
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0011dfcd
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001084e0
LAB_0011dfcd:
LEA RDI,[RSP + 0x38]
CALL 0x0013244c
LEA RDI,[RSP + 0x50]
CALL 0x0013244c
LAB_0011dfe1:
LEA R14,[RSP + 0x18]
MOV byte ptr [R14 + -0x8],0x0
MOV qword ptr [R14],0x0
LAB_0011dff2:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x8]
CALL 0x00132184
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0010efc4
LAB_0011e00c:
MOV RSI,qword ptr [RSP + 0x18]
TEST RSI,RSI
JZ 0x0011e01e
MOV RDI,R14
CALL 0x0010de4a
LAB_0011e01e:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0011e02e
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0011e02e:
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::EqFailure(char const*, char const*, std::__cxx11::string const&,
std::__cxx11::string const&, bool) */
AssertionResult * __thiscall
testing::internal::EqFailure
(internal *this,char *param_1,char *param_2,string *param_3,string *param_4,bool param_5)
{
internal *this_00;
int iVar1;
size_t sVar2;
AssertionResult *pAVar3;
ostream *poVar4;
long *local_90;
edit_distance local_88;
int7 uStack_87;
string *local_80;
long local_78 [2];
internal *local_68;
long local_60;
long local_58;
long local_48;
long local_40;
local_68 = this;
Message::Message((Message *)&local_90);
/* try { // try from 0011ddce to 0011df11 has its CatchHandler @ 0011e099 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),"Expected equality of these values:",0x22);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)(local_90 + 2),"\n ",3);
poVar4 = (ostream *)(local_90 + 2);
if (param_1 == (char *)0x0) {
sVar2 = 6;
param_1 = "(null)";
}
else {
sVar2 = strlen(param_1);
}
std::__ostream_insert<char,std::char_traits<char>>(poVar4,param_1,sVar2);
iVar1 = std::__cxx11::string::compare((char *)param_3);
if (iVar1 != 0) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),"\n Which is: ",0xf);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),*(char **)param_3,*(long *)(param_3 + 8));
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)(local_90 + 2),"\n ",3);
poVar4 = (ostream *)(local_90 + 2);
if (param_2 == (char *)0x0) {
sVar2 = 6;
param_2 = "(null)";
}
else {
sVar2 = strlen(param_2);
}
std::__ostream_insert<char,std::char_traits<char>>(poVar4,param_2,sVar2);
iVar1 = std::__cxx11::string::compare((char *)param_4);
if (iVar1 != 0) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),"\n Which is: ",0xf);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),*(char **)param_4,*(long *)(param_4 + 8));
}
if (param_5) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),"\nIgnoring case",0xe);
}
this_00 = local_68;
if ((*(long *)(param_3 + 8) != 0) && (*(long *)(param_4 + 8) != 0)) {
/* try { // try from 0011df2d to 0011df39 has its CatchHandler @ 0011e080 */
(anonymous_namespace)::SplitEscapedString((_anonymous_namespace_ *)&local_48,param_3);
/* try { // try from 0011df3a to 0011df46 has its CatchHandler @ 0011e071 */
(anonymous_namespace)::SplitEscapedString((_anonymous_namespace_ *)&local_60,param_4);
if ((0x20 < (ulong)(local_40 - local_48)) || (0x20 < (ulong)(local_58 - local_60))) {
/* try { // try from 0011df70 to 0011df80 has its CatchHandler @ 0011e062 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),"\nWith diff:\n",0xc);
/* try { // try from 0011df81 to 0011df99 has its CatchHandler @ 0011e060 */
edit_distance::CreateUnifiedDiff(&local_88,(vector *)&local_48,(vector *)&local_60,2);
/* try { // try from 0011dfad to 0011dfb1 has its CatchHandler @ 0011e040 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),(char *)CONCAT71(uStack_87,local_88),(long)local_80);
if ((long *)CONCAT71(uStack_87,local_88) != local_78) {
operator_delete((long *)CONCAT71(uStack_87,local_88),local_78[0] + 1);
}
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_60);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_48);
}
local_88 = (edit_distance)0x0;
local_80 = (string *)0x0;
/* try { // try from 0011dff2 to 0011e00b has its CatchHandler @ 0011e082 */
pAVar3 = AssertionResult::operator<<((AssertionResult *)&local_88,(Message *)&local_90);
AssertionResult::AssertionResult((AssertionResult *)this_00,pAVar3);
if (local_80 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_80,local_80);
}
if (local_90 != (long *)0x0) {
(**(code **)(*local_90 + 8))();
}
return (AssertionResult *)this_00;
}
|
|
64,766 |
set_dynamic
|
eloqsql/mysys/array.c
|
my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element, uint idx)
{
if (idx >= array->elements)
{
if (idx >= array->max_element && allocate_dynamic(array, idx))
return TRUE;
bzero((uchar*) (array->buffer+array->elements*array->size_of_element),
(idx - array->elements)*array->size_of_element);
array->elements=idx+1;
}
memcpy(array->buffer+(idx * array->size_of_element),element,
(size_t) array->size_of_element);
return FALSE;
}
|
O0
|
c
|
set_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x3195a
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x31915
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x31990
movsbl %al, %eax
cmpl $0x0, %eax
je 0x31915
movb $0x1, -0x1(%rbp)
jmp 0x31987
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x251e0
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
callq 0x252e0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
|
set_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+8]
jb short loc_3195A
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jb short loc_31915
mov rdi, [rbp+var_10]
mov esi, [rbp+var_1C]
call allocate_dynamic
movsx eax, al
cmp eax, 0
jz short loc_31915
mov [rbp+var_1], 1
jmp short loc_31987
loc_31915:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
add rdi, rax
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
sub eax, [rcx+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
mov ecx, [rbp+var_1C]
add ecx, 1
mov rax, [rbp+var_10]
mov [rax+8], ecx
loc_3195A:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
add rdi, rax
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov eax, [rax+14h]
mov edx, eax
call _memcpy
mov [rbp+var_1], 0
loc_31987:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char set_dynamic(long long a1, long long a2, unsigned int a3)
{
if ( a3 < *(_DWORD *)(a1 + 8) )
goto LABEL_6;
if ( a3 < *(_DWORD *)(a1 + 12) || !(unsigned __int8)allocate_dynamic(a1, a3) )
{
memset(
(unsigned int)(*(_DWORD *)(a1 + 20) * *(_DWORD *)(a1 + 8)) + *(_QWORD *)a1,
0LL,
*(_DWORD *)(a1 + 20) * (a3 - *(_DWORD *)(a1 + 8)));
*(_DWORD *)(a1 + 8) = a3 + 1;
LABEL_6:
memcpy(*(_DWORD *)(a1 + 20) * a3 + *(_QWORD *)a1, a2, *(unsigned int *)(a1 + 20));
return 0;
}
return 1;
}
|
set_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x8]
JC 0x0013195a
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JC 0x00131915
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x1c]
CALL 0x00131990
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00131915
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00131987
LAB_00131915:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
SUB EAX,dword ptr [RCX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x001251e0
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x8],ECX
LAB_0013195a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV EDX,EAX
CALL 0x001252e0
MOV byte ptr [RBP + -0x1],0x0
LAB_00131987:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 set_dynamic(long *param_1,void *param_2,uint param_3)
{
char cVar1;
if (*(uint *)(param_1 + 1) <= param_3) {
if ((*(uint *)((long)param_1 + 0xc) <= param_3) &&
(cVar1 = allocate_dynamic(param_1), cVar1 != '\0')) {
return 1;
}
memset((void *)(*param_1 + (ulong)(uint)((int)param_1[1] * *(int *)((long)param_1 + 0x14))),0,
(ulong)((param_3 - (int)param_1[1]) * *(int *)((long)param_1 + 0x14)));
*(uint *)(param_1 + 1) = param_3 + 1;
}
memcpy((void *)(*param_1 + (ulong)(param_3 * *(int *)((long)param_1 + 0x14))),param_2,
(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
|
|
64,767 |
set_dynamic
|
eloqsql/mysys/array.c
|
my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element, uint idx)
{
if (idx >= array->elements)
{
if (idx >= array->max_element && allocate_dynamic(array, idx))
return TRUE;
bzero((uchar*) (array->buffer+array->elements*array->size_of_element),
(idx - array->elements)*array->size_of_element);
array->elements=idx+1;
}
memcpy(array->buffer+(idx * array->size_of_element),element,
(size_t) array->size_of_element);
return FALSE;
}
|
O3
|
c
|
set_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %eax
cmpl %edx, %eax
ja 0x2c492
cmpl %r14d, 0xc(%r15)
ja 0x2c46f
movq %r15, %rdi
movl %r14d, %esi
callq 0x2c4b5
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2c4aa
movl 0x8(%r15), %eax
movl 0x14(%r15), %ecx
movl %r14d, %edx
subl %eax, %edx
imull %ecx, %edx
movl %ecx, %edi
imull %eax, %edi
addq (%r15), %rdi
xorl %esi, %esi
callq 0x241e0
leal 0x1(%r14), %eax
movl %eax, 0x8(%r15)
movl 0x14(%r15), %edx
imull %edx, %r14d
addq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24300
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
set_dynamic:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, edx
mov rbx, rsi
mov r15, rdi
mov eax, [rdi+8]
cmp eax, edx
ja short loc_2C492
cmp [r15+0Ch], r14d
ja short loc_2C46F
mov rdi, r15
mov esi, r14d
call allocate_dynamic
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_2C4AA
mov eax, [r15+8]
loc_2C46F:
mov ecx, [r15+14h]
mov edx, r14d
sub edx, eax
imul edx, ecx
mov edi, ecx
imul edi, eax
add rdi, [r15]
xor esi, esi
call _memset
lea eax, [r14+1]
mov [r15+8], eax
loc_2C492:
mov edx, [r15+14h]
imul r14d, edx
add r14, [r15]
mov rdi, r14
mov rsi, rbx
call _memcpy
xor eax, eax
loc_2C4AA:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
char set_dynamic(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // eax
char dynamic; // cl
char result; // al
v4 = *(_DWORD *)(a1 + 8);
if ( v4 <= a3 )
{
if ( *(_DWORD *)(a1 + 12) <= a3 )
{
dynamic = allocate_dynamic(a1, a3);
result = 1;
if ( dynamic )
return result;
v4 = *(_DWORD *)(a1 + 8);
}
memset(*(_QWORD *)a1 + v4 * *(_DWORD *)(a1 + 20), 0LL, *(_DWORD *)(a1 + 20) * (a3 - v4));
*(_DWORD *)(a1 + 8) = a3 + 1;
}
memcpy(*(_QWORD *)a1 + *(_DWORD *)(a1 + 20) * a3, a2, *(unsigned int *)(a1 + 20));
return 0;
}
|
set_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,EDX
MOV RBX,RSI
MOV R15,RDI
MOV EAX,dword ptr [RDI + 0x8]
CMP EAX,EDX
JA 0x0012c492
CMP dword ptr [R15 + 0xc],R14D
JA 0x0012c46f
MOV RDI,R15
MOV ESI,R14D
CALL 0x0012c4b5
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x0012c4aa
MOV EAX,dword ptr [R15 + 0x8]
LAB_0012c46f:
MOV ECX,dword ptr [R15 + 0x14]
MOV EDX,R14D
SUB EDX,EAX
IMUL EDX,ECX
MOV EDI,ECX
IMUL EDI,EAX
ADD RDI,qword ptr [R15]
XOR ESI,ESI
CALL 0x001241e0
LEA EAX,[R14 + 0x1]
MOV dword ptr [R15 + 0x8],EAX
LAB_0012c492:
MOV EDX,dword ptr [R15 + 0x14]
IMUL R14D,EDX
ADD R14,qword ptr [R15]
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124300
XOR EAX,EAX
LAB_0012c4aa:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 set_dynamic(long *param_1,void *param_2,uint param_3)
{
char cVar1;
uint uVar2;
uVar2 = *(uint *)(param_1 + 1);
if (uVar2 <= param_3) {
if (*(uint *)((long)param_1 + 0xc) <= param_3) {
cVar1 = allocate_dynamic(param_1);
if (cVar1 != '\0') {
return 1;
}
uVar2 = *(uint *)(param_1 + 1);
}
memset((void *)((ulong)(*(int *)((long)param_1 + 0x14) * uVar2) + *param_1),0,
(ulong)((param_3 - uVar2) * *(int *)((long)param_1 + 0x14)));
*(uint *)(param_1 + 1) = param_3 + 1;
}
memcpy((void *)((ulong)(param_3 * *(uint *)((long)param_1 + 0x14)) + *param_1),param_2,
(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
|
|
64,768 |
postprocess_cpu_params(cpu_params&, cpu_params const*)
|
monkey531[P]llama/common/common.cpp
|
void postprocess_cpu_params(cpu_params& cpuparams, const cpu_params* role_model) {
int32_t n_set = 0;
if (cpuparams.n_threads < 0) {
// Assuming everything about cpuparams is invalid
if (role_model != nullptr) {
cpuparams = *role_model;
} else {
cpuparams.n_threads = cpu_get_num_math();
}
}
for (int32_t i = 0; i < GGML_MAX_N_THREADS; i++) {
if (cpuparams.cpumask[i]) {
n_set++;
}
}
if (n_set && n_set < cpuparams.n_threads) {
// Not enough set bits, may experience performance issues.
LOG_WRN("Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n", n_set, cpuparams.n_threads);
}
}
|
O0
|
cpp
|
postprocess_cpu_params(cpu_params&, cpu_params const*):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jge 0xeddfe
cmpq $0x0, 0x8(%rsp)
je 0xeddee
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl $0x214, %edx # imm = 0x214
callq 0x5a120
jmp 0xeddfc
callq 0xedb30
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
jmp 0xeddfe
movl $0x0, (%rsp)
cmpl $0x200, (%rsp) # imm = 0x200
jge 0xede36
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
testb $0x1, 0x4(%rax,%rcx)
je 0xede29
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xede2b
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xede05
cmpl $0x0, 0x4(%rsp)
je 0xede84
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xede84
jmp 0xede4c
xorl %eax, %eax
leaq 0x1b77a3(%rip), %rcx # 0x2a55f8
cmpl (%rcx), %eax
jg 0xede80
callq 0x1c0120
movq %rax, %rdi
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl (%rax), %r8d
movl $0x3, %esi
leaq 0x1237ce(%rip), %rdx # 0x211647
movb $0x0, %al
callq 0x1c0210
jmp 0xede82
jmp 0xede84
addq $0x18, %rsp
retq
nopl (%rax)
|
_Z22postprocess_cpu_paramsR10cpu_paramsPKS_:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov [rsp+18h+var_14], 0
mov rax, [rsp+18h+var_8]
cmp dword ptr [rax], 0
jge short loc_EDDFE
cmp [rsp+18h+var_10], 0
jz short loc_EDDEE
mov rsi, [rsp+18h+var_10]
mov rdi, [rsp+18h+var_8]
mov edx, 214h
call _memcpy
jmp short loc_EDDFC
loc_EDDEE:
call _Z16cpu_get_num_mathv; cpu_get_num_math(void)
mov ecx, eax
mov rax, [rsp+18h+var_8]
mov [rax], ecx
loc_EDDFC:
jmp short $+2
loc_EDDFE:
mov [rsp+18h+var_18], 0
loc_EDE05:
cmp [rsp+18h+var_18], 200h
jge short loc_EDE36
mov rax, [rsp+18h+var_8]
movsxd rcx, [rsp+18h+var_18]
test byte ptr [rax+rcx+4], 1
jz short loc_EDE29
mov eax, [rsp+18h+var_14]
add eax, 1
mov [rsp+18h+var_14], eax
loc_EDE29:
jmp short $+2
loc_EDE2B:
mov eax, [rsp+18h+var_18]
add eax, 1
mov [rsp+18h+var_18], eax
jmp short loc_EDE05
loc_EDE36:
cmp [rsp+18h+var_14], 0
jz short loc_EDE84
mov eax, [rsp+18h+var_14]
mov rcx, [rsp+18h+var_8]
cmp eax, [rcx]
jge short loc_EDE84
jmp short $+2
loc_EDE4C:
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_EDE80
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov ecx, [rsp+18h+var_14]
mov rax, [rsp+18h+var_8]
mov r8d, [rax]
mov esi, 3
lea rdx, aNotEnoughSetBi; "Not enough set bits in CPU mask (%d) to"...
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_EDE80:
jmp short $+2
loc_EDE82:
jmp short $+2
loc_EDE84:
add rsp, 18h
retn
|
long long postprocess_cpu_params(cpu_params *a1, const cpu_params *a2)
{
long long result; // rax
int num_math; // ecx
int v4; // eax
int v5; // r9d
int i; // [rsp+0h] [rbp-18h]
unsigned int v7; // [rsp+4h] [rbp-14h]
v7 = 0;
result = (long long)a1;
if ( *(int *)a1 < 0 )
{
if ( a2 )
{
result = memcpy(a1, a2, 532LL);
}
else
{
num_math = cpu_get_num_math();
result = (long long)a1;
*(_DWORD *)a1 = num_math;
}
}
for ( i = 0; i < 512; ++i )
{
if ( (*((_BYTE *)a1 + i + 4) & 1) != 0 )
++v7;
result = (unsigned int)(i + 1);
}
if ( v7 )
{
result = v7;
if ( (signed int)v7 < *(_DWORD *)a1 )
{
result = 0LL;
if ( common_log_verbosity_thold >= 0 )
{
v4 = common_log_main();
return common_log_add(
v4,
3,
(unsigned int)"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
v7,
*(_DWORD *)a1,
v5);
}
}
}
return result;
}
|
postprocess_cpu_params:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV dword ptr [RSP + 0x4],0x0
MOV RAX,qword ptr [RSP + 0x10]
CMP dword ptr [RAX],0x0
JGE 0x001eddfe
CMP qword ptr [RSP + 0x8],0x0
JZ 0x001eddee
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x10]
MOV EDX,0x214
CALL 0x0015a120
JMP 0x001eddfc
LAB_001eddee:
CALL 0x001edb30
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX],ECX
LAB_001eddfc:
JMP 0x001eddfe
LAB_001eddfe:
MOV dword ptr [RSP],0x0
LAB_001ede05:
CMP dword ptr [RSP],0x200
JGE 0x001ede36
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,dword ptr [RSP]
TEST byte ptr [RAX + RCX*0x1 + 0x4],0x1
JZ 0x001ede29
MOV EAX,dword ptr [RSP + 0x4]
ADD EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
LAB_001ede29:
JMP 0x001ede2b
LAB_001ede2b:
MOV EAX,dword ptr [RSP]
ADD EAX,0x1
MOV dword ptr [RSP],EAX
JMP 0x001ede05
LAB_001ede36:
CMP dword ptr [RSP + 0x4],0x0
JZ 0x001ede84
MOV EAX,dword ptr [RSP + 0x4]
MOV RCX,qword ptr [RSP + 0x10]
CMP EAX,dword ptr [RCX]
JGE 0x001ede84
JMP 0x001ede4c
LAB_001ede4c:
XOR EAX,EAX
LEA RCX,[0x3a55f8]
CMP EAX,dword ptr [RCX]
JG 0x001ede80
CALL 0x002c0120
MOV RDI,RAX
MOV ECX,dword ptr [RSP + 0x4]
MOV RAX,qword ptr [RSP + 0x10]
MOV R8D,dword ptr [RAX]
MOV ESI,0x3
LEA RDX,[0x311647]
MOV AL,0x0
CALL 0x002c0210
LAB_001ede80:
JMP 0x001ede82
LAB_001ede82:
JMP 0x001ede84
LAB_001ede84:
ADD RSP,0x18
RET
|
/* postprocess_cpu_params(cpu_params&, cpu_params const*) */
void postprocess_cpu_params(cpu_params *param_1,cpu_params *param_2)
{
int4 uVar1;
int8 uVar2;
int local_18;
int local_14;
local_14 = 0;
if (*(int *)param_1 < 0) {
if (param_2 == (cpu_params *)0x0) {
uVar1 = cpu_get_num_math();
*(int4 *)param_1 = uVar1;
}
else {
memcpy(param_1,param_2,0x214);
}
}
for (local_18 = 0; local_18 < 0x200; local_18 = local_18 + 1) {
if (((byte)param_1[(long)local_18 + 4] & 1) != 0) {
local_14 = local_14 + 1;
}
}
if (((local_14 != 0) && (local_14 < *(int *)param_1)) && (-1 < common_log_verbosity_thold)) {
uVar2 = common_log_main();
common_log_add(uVar2,3,
"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
local_14,*(int4 *)param_1);
}
return;
}
|
|
64,769 |
find_or_create_table_share(PFS_thread*, bool, TABLE_SHARE const*)
|
eloqsql/storage/perfschema/pfs_instr_class.cc
|
PFS_table_share* find_or_create_table_share(PFS_thread *thread,
bool temporary,
const TABLE_SHARE *share)
{
/* See comments in register_mutex_class */
PFS_table_share_key key;
LF_PINS *pins= get_table_share_hash_pins(thread);
if (unlikely(pins == NULL))
{
global_table_share_container.m_lost++;
return NULL;
}
const char *schema_name= share->db.str;
size_t schema_name_length= share->db.length;
const char *table_name= share->table_name.str;
size_t table_name_length= share->table_name.length;
set_table_share_key(&key, temporary,
schema_name, schema_name_length,
table_name, table_name_length);
PFS_table_share **entry;
uint retry_count= 0;
const uint retry_max= 3;
bool enabled= true;
bool timed= true;
PFS_table_share *pfs;
pfs_dirty_state dirty_state;
search:
entry= reinterpret_cast<PFS_table_share**>
(lf_hash_search(&table_share_hash, pins,
key.m_hash_key, key.m_key_length));
if (entry && (entry != MY_ERRPTR))
{
pfs= *entry;
pfs->inc_refcount() ;
if (compare_keys(pfs, share) != 0)
{
/*
Some DDL was detected.
- keep the lock stats, they are unaffected
- destroy the index stats, indexes changed.
- adjust the expected key count
- recreate index stats
*/
pfs->destroy_index_stats();
pfs->m_key_count= share->keys;
for (uint index= 0; index < pfs->m_key_count; index++)
{
(void)pfs->find_or_create_index_stat(share, index);
}
}
lf_hash_search_unpin(pins);
return pfs;
}
lf_hash_search_unpin(pins);
if (retry_count == 0)
{
lookup_setup_object(thread,
OBJECT_TYPE_TABLE,
schema_name, static_cast<uint>(schema_name_length),
table_name, static_cast<uint>(table_name_length),
&enabled, &timed);
/*
Even when enabled is false, a record is added in the dictionary:
- It makes enabling a table already in the table cache possible,
- It improves performances for the next time a TABLE_SHARE is reloaded
in the table cache.
*/
}
pfs= global_table_share_container.allocate(& dirty_state);
if (pfs != NULL)
{
pfs->m_key= key;
pfs->m_schema_name= &pfs->m_key.m_hash_key[1];
pfs->m_schema_name_length= static_cast<uint>(schema_name_length);
pfs->m_table_name= &pfs->m_key.m_hash_key[schema_name_length + 2];
pfs->m_table_name_length= static_cast<uint>(table_name_length);
pfs->m_enabled= enabled;
pfs->m_timed= timed;
pfs->init_refcount();
pfs->destroy_lock_stat();
pfs->destroy_index_stats();
pfs->m_key_count= share->keys;
int res;
pfs->m_lock.dirty_to_allocated(& dirty_state);
res= lf_hash_insert(&table_share_hash, pins, &pfs);
if (likely(res == 0))
{
/* Create table share index stats. */
for (uint index= 0; index < pfs->m_key_count; index++)
{
(void)pfs->find_or_create_index_stat(share, index);
}
return pfs;
}
global_table_share_container.deallocate(pfs);
if (res > 0)
{
/* Duplicate insert by another thread */
if (++retry_count > retry_max)
{
/* Avoid infinite loops */
global_table_share_container.m_lost++;
return NULL;
}
goto search;
}
/* OOM in lf_hash_insert */
global_table_share_container.m_lost++;
return NULL;
}
return NULL;
}
|
O0
|
cpp
|
find_or_create_table_share(PFS_thread*, bool, TABLE_SHARE const*):
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movb %sil, %al
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movq %rdi, -0x1a0(%rbp)
andb $0x1, %al
movb %al, -0x1a1(%rbp)
movq %rdx, -0x1b0(%rbp)
movq -0x1a0(%rbp), %rdi
callq 0x419b0
movq %rax, -0x1b8(%rbp)
cmpq $0x0, -0x1b8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x43ae1
leaq 0x39c738(%rip), %rax # 0x3e01f8
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x39c72a(%rip), %rax # 0x3e01f8
movq %rcx, (%rax)
movq $0x0, -0x198(%rbp)
jmp 0x43f64
movq -0x1b0(%rbp), %rax
movq 0x2a0(%rax), %rax
movq %rax, -0x1c0(%rbp)
movq -0x1b0(%rbp), %rax
movq 0x2a8(%rax), %rax
movq %rax, -0x1c8(%rbp)
movq -0x1b0(%rbp), %rax
movq 0x2b0(%rax), %rax
movq %rax, -0x1d0(%rbp)
movq -0x1b0(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0x1d8(%rbp)
movb -0x1a1(%rbp), %al
movq -0x1c0(%rbp), %rdx
movq -0x1c8(%rbp), %rcx
movq -0x1d0(%rbp), %r8
movq -0x1d8(%rbp), %r9
leaq -0x190(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x43fa0
movl $0x0, -0x1e4(%rbp)
movl $0x3, -0x1e8(%rbp)
movb $0x1, -0x1e9(%rbp)
movb $0x1, -0x1ea(%rbp)
movq -0x1b8(%rbp), %rsi
leaq -0x190(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x3c919e(%rip), %rdi # 0x40cd40
callq 0x5da70
movq %rax, -0x1e0(%rbp)
cmpq $0x0, -0x1e0(%rbp)
je 0x43caa
movl $0x1, %eax
cmpq %rax, -0x1e0(%rbp)
je 0x43caa
movq -0x1e0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1f8(%rbp)
movq -0x1f8(%rbp), %rdi
callq 0x3dc70
movq -0x1f8(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
callq 0x440e0
cmpl $0x0, %eax
je 0x43c74
movq -0x1f8(%rbp), %rdi
callq 0x41ef0
movq -0x1b0(%rbp), %rax
movl 0x3a0(%rax), %ecx
movq -0x1f8(%rbp), %rax
movl %ecx, 0x1ac(%rax)
movl $0x0, -0x200(%rbp)
movl -0x200(%rbp), %eax
movq -0x1f8(%rbp), %rcx
cmpl 0x1ac(%rcx), %eax
jae 0x43c72
movq -0x1f8(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
movl -0x200(%rbp), %edx
callq 0x41cc0
movl -0x200(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x200(%rbp)
jmp 0x43c33
jmp 0x43c74
jmp 0x43c76
jmp 0x43c78
jmp 0x43c7a
movq -0x1b8(%rbp), %rcx
movq $0x0, -0x208(%rbp)
movq -0x208(%rbp), %rax
xchgq %rax, 0x10(%rcx)
movq -0x1f8(%rbp), %rax
movq %rax, -0x198(%rbp)
jmp 0x43f64
jmp 0x43cac
jmp 0x43cae
jmp 0x43cb0
movq -0x1b8(%rbp), %rcx
movq $0x0, -0x210(%rbp)
movq -0x210(%rbp), %rax
xchgq %rax, 0x10(%rcx)
cmpl $0x0, -0x1e4(%rbp)
jne 0x43d1f
movq -0x1a0(%rbp), %rdi
movq -0x1c0(%rbp), %rdx
movq -0x1c8(%rbp), %rax
movl %eax, %ecx
movq -0x1d0(%rbp), %r8
movq -0x1d8(%rbp), %rax
movl %eax, %r9d
movl $0x4, %esi
leaq -0x1e9(%rbp), %r10
leaq -0x1ea(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x495d0
leaq 0x39c4d2(%rip), %rdi # 0x3e01f8
leaq -0x1fc(%rbp), %rsi
callq 0x45870
movq %rax, -0x1f8(%rbp)
cmpq $0x0, -0x1f8(%rbp)
je 0x43f59
movq -0x1f8(%rbp), %rdi
addq $0x8, %rdi
leaq -0x190(%rbp), %rsi
movl $0x188, %edx # imm = 0x188
callq 0x26280
movq -0x1f8(%rbp), %rcx
addq $0x8, %rcx
addq $0x1, %rcx
movq -0x1f8(%rbp), %rax
movq %rcx, 0x190(%rax)
movq -0x1c8(%rbp), %rax
movl %eax, %ecx
movq -0x1f8(%rbp), %rax
movl %ecx, 0x198(%rax)
movq -0x1f8(%rbp), %rcx
addq $0x8, %rcx
movq -0x1c8(%rbp), %rax
addq $0x2, %rax
addq %rax, %rcx
movq -0x1f8(%rbp), %rax
movq %rcx, 0x1a0(%rax)
movq -0x1d8(%rbp), %rax
movl %eax, %ecx
movq -0x1f8(%rbp), %rax
movl %ecx, 0x1a8(%rax)
movb -0x1e9(%rbp), %cl
movq -0x1f8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
movb -0x1ea(%rbp), %cl
movq -0x1f8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x5(%rax)
movq -0x1f8(%rbp), %rdi
callq 0x45c20
movq -0x1f8(%rbp), %rdi
callq 0x41c00
movq -0x1f8(%rbp), %rdi
callq 0x41ef0
movq -0x1b0(%rbp), %rax
movl 0x3a0(%rax), %ecx
movq -0x1f8(%rbp), %rax
movl %ecx, 0x1ac(%rax)
movq -0x1f8(%rbp), %rdi
leaq -0x1fc(%rbp), %rsi
callq 0x2ca70
movq -0x1b8(%rbp), %rsi
leaq 0x3c8ee8(%rip), %rdi # 0x40cd40
leaq -0x1f8(%rbp), %rdx
callq 0x5ca50
movl %eax, -0x214(%rbp)
cmpl $0x0, -0x214(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x43eda
movl $0x0, -0x218(%rbp)
movl -0x218(%rbp), %eax
movq -0x1f8(%rbp), %rcx
cmpl 0x1ac(%rcx), %eax
jae 0x43ec7
movq -0x1f8(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
movl -0x218(%rbp), %edx
callq 0x41cc0
movl -0x218(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x218(%rbp)
jmp 0x43e88
movq -0x1f8(%rbp), %rax
movq %rax, -0x198(%rbp)
jmp 0x43f64
movq -0x1f8(%rbp), %rsi
leaq 0x39c310(%rip), %rdi # 0x3e01f8
callq 0x45c50
cmpl $0x0, -0x214(%rbp)
jle 0x43f34
movl -0x1e4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e4(%rbp)
cmpl $0x3, %eax
jbe 0x43f2f
leaq 0x39c2e7(%rip), %rax # 0x3e01f8
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x39c2d9(%rip), %rax # 0x3e01f8
movq %rcx, (%rax)
movq $0x0, -0x198(%rbp)
jmp 0x43f64
jmp 0x43b8a
leaq 0x39c2bd(%rip), %rax # 0x3e01f8
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x39c2af(%rip), %rax # 0x3e01f8
movq %rcx, (%rax)
movq $0x0, -0x198(%rbp)
jmp 0x43f64
movq $0x0, -0x198(%rbp)
movq -0x198(%rbp), %rax
movq %rax, -0x220(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x43f94
movq -0x220(%rbp), %rax
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
callq 0x26360
nopl (%rax)
|
_Z26find_or_create_table_shareP10PFS_threadbPK11TABLE_SHARE:
push rbp
mov rbp, rsp
sub rsp, 230h
mov al, sil
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_1A0], rdi
and al, 1
mov [rbp+var_1A1], al
mov [rbp+var_1B0], rdx
mov rdi, [rbp+var_1A0]; PFS_thread *
call _Z25get_table_share_hash_pinsP10PFS_thread; get_table_share_hash_pins(PFS_thread *)
mov [rbp+var_1B8], rax
cmp [rbp+var_1B8], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_43AE1
lea rax, global_table_share_container
mov rcx, [rax]
add rcx, 1
lea rax, global_table_share_container
mov [rax], rcx
mov [rbp+var_198], 0
jmp loc_43F64
loc_43AE1:
mov rax, [rbp+var_1B0]
mov rax, [rax+2A0h]
mov [rbp+var_1C0], rax
mov rax, [rbp+var_1B0]
mov rax, [rax+2A8h]
mov [rbp+var_1C8], rax
mov rax, [rbp+var_1B0]
mov rax, [rax+2B0h]
mov [rbp+var_1D0], rax
mov rax, [rbp+var_1B0]
mov rax, [rax+2B8h]
mov [rbp+var_1D8], rax
mov al, [rbp+var_1A1]
mov rdx, [rbp+var_1C0]
mov rcx, [rbp+var_1C8]
mov r8, [rbp+var_1D0]
mov r9, [rbp+var_1D8]
lea rdi, [rbp+var_190]
and al, 1
movzx esi, al
call _ZL19set_table_share_keyP19PFS_table_share_keybPKcmS2_m; set_table_share_key(PFS_table_share_key *,bool,char const*,ulong,char const*,ulong)
mov [rbp+var_1E4], 0
mov [rbp+var_1E8], 3
mov [rbp+var_1E9], 1
mov [rbp+var_1EA], 1
loc_43B8A:
mov rsi, [rbp+var_1B8]
lea rdx, [rbp+var_190]
mov ecx, [rbp+var_C]
lea rdi, table_share_hash
call lf_hash_search
mov [rbp+var_1E0], rax
cmp [rbp+var_1E0], 0
jz loc_43CAA
mov eax, 1
cmp [rbp+var_1E0], rax
jz loc_43CAA
mov rax, [rbp+var_1E0]
mov rax, [rax]
mov [rbp+var_1F8], rax
mov rdi, [rbp+var_1F8]; this
call _ZN15PFS_table_share12inc_refcountEv; PFS_table_share::inc_refcount(void)
mov rdi, [rbp+var_1F8]
mov rsi, [rbp+var_1B0]
call _ZL12compare_keysP15PFS_table_sharePK11TABLE_SHARE; compare_keys(PFS_table_share *,TABLE_SHARE const*)
cmp eax, 0
jz short loc_43C74
mov rdi, [rbp+var_1F8]; this
call _ZN15PFS_table_share19destroy_index_statsEv; PFS_table_share::destroy_index_stats(void)
mov rax, [rbp+var_1B0]
mov ecx, [rax+3A0h]
mov rax, [rbp+var_1F8]
mov [rax+1ACh], ecx
mov [rbp+var_200], 0
loc_43C33:
mov eax, [rbp+var_200]
mov rcx, [rbp+var_1F8]
cmp eax, [rcx+1ACh]
jnb short loc_43C72
mov rdi, [rbp+var_1F8]
mov rsi, [rbp+var_1B0]
mov edx, [rbp+var_200]
call _ZN15PFS_table_share25find_or_create_index_statEPK11TABLE_SHAREj; PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*,uint)
mov eax, [rbp+var_200]
add eax, 1
mov [rbp+var_200], eax
jmp short loc_43C33
loc_43C72:
jmp short $+2
loc_43C74:
jmp short $+2
loc_43C76:
jmp short $+2
loc_43C78:
jmp short $+2
loc_43C7A:
mov rcx, [rbp+var_1B8]
mov [rbp+var_208], 0
mov rax, [rbp+var_208]
xchg rax, [rcx+10h]
mov rax, [rbp+var_1F8]
mov [rbp+var_198], rax
jmp loc_43F64
loc_43CAA:
jmp short $+2
loc_43CAC:
jmp short $+2
loc_43CAE:
jmp short $+2
loc_43CB0:
mov rcx, [rbp+var_1B8]
mov [rbp+var_210], 0
mov rax, [rbp+var_210]
xchg rax, [rcx+10h]
cmp [rbp+var_1E4], 0
jnz short loc_43D1F
mov rdi, [rbp+var_1A0]
mov rdx, [rbp+var_1C0]
mov rax, [rbp+var_1C8]
mov ecx, eax
mov r8, [rbp+var_1D0]
mov rax, [rbp+var_1D8]
mov r9d, eax
mov esi, 4
lea r10, [rbp+var_1E9]
lea rax, [rbp+var_1EA]
mov [rsp+230h+var_230], r10
mov [rsp+230h+var_228], rax
call _Z19lookup_setup_objectP10PFS_thread16enum_object_typePKciS3_iPbS4_; lookup_setup_object(PFS_thread *,enum_object_type,char const*,int,char const*,int,bool *,bool *)
loc_43D1F:
lea rdi, global_table_share_container
lea rsi, [rbp+var_1FC]
call _ZN29PFS_buffer_scalable_containerI15PFS_table_shareLi4096ELi4096E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE8allocateEP15pfs_dirty_state; PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>::allocate(pfs_dirty_state *)
mov [rbp+var_1F8], rax
cmp [rbp+var_1F8], 0
jz loc_43F59
mov rdi, [rbp+var_1F8]
add rdi, 8
lea rsi, [rbp+var_190]
mov edx, 188h
call _memcpy
mov rcx, [rbp+var_1F8]
add rcx, 8
add rcx, 1
mov rax, [rbp+var_1F8]
mov [rax+190h], rcx
mov rax, [rbp+var_1C8]
mov ecx, eax
mov rax, [rbp+var_1F8]
mov [rax+198h], ecx
mov rcx, [rbp+var_1F8]
add rcx, 8
mov rax, [rbp+var_1C8]
add rax, 2
add rcx, rax
mov rax, [rbp+var_1F8]
mov [rax+1A0h], rcx
mov rax, [rbp+var_1D8]
mov ecx, eax
mov rax, [rbp+var_1F8]
mov [rax+1A8h], ecx
mov cl, [rbp+var_1E9]
mov rax, [rbp+var_1F8]
and cl, 1
mov [rax+4], cl
mov cl, [rbp+var_1EA]
mov rax, [rbp+var_1F8]
and cl, 1
mov [rax+5], cl
mov rdi, [rbp+var_1F8]; this
call _ZN15PFS_table_share13init_refcountEv; PFS_table_share::init_refcount(void)
mov rdi, [rbp+var_1F8]; this
call _ZN15PFS_table_share17destroy_lock_statEv; PFS_table_share::destroy_lock_stat(void)
mov rdi, [rbp+var_1F8]; this
call _ZN15PFS_table_share19destroy_index_statsEv; PFS_table_share::destroy_index_stats(void)
mov rax, [rbp+var_1B0]
mov ecx, [rax+3A0h]
mov rax, [rbp+var_1F8]
mov [rax+1ACh], ecx
mov rdi, [rbp+var_1F8]
lea rsi, [rbp+var_1FC]
call _ZN8pfs_lock18dirty_to_allocatedEPK15pfs_dirty_state; pfs_lock::dirty_to_allocated(pfs_dirty_state const*)
mov rsi, [rbp+var_1B8]
lea rdi, table_share_hash
lea rdx, [rbp+var_1F8]
call lf_hash_insert
mov [rbp+var_214], eax
cmp [rbp+var_214], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_43EDA
mov [rbp+var_218], 0
loc_43E88:
mov eax, [rbp+var_218]
mov rcx, [rbp+var_1F8]
cmp eax, [rcx+1ACh]
jnb short loc_43EC7
mov rdi, [rbp+var_1F8]
mov rsi, [rbp+var_1B0]
mov edx, [rbp+var_218]
call _ZN15PFS_table_share25find_or_create_index_statEPK11TABLE_SHAREj; PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*,uint)
mov eax, [rbp+var_218]
add eax, 1
mov [rbp+var_218], eax
jmp short loc_43E88
loc_43EC7:
mov rax, [rbp+var_1F8]
mov [rbp+var_198], rax
jmp loc_43F64
loc_43EDA:
mov rsi, [rbp+var_1F8]
lea rdi, global_table_share_container
call _ZN29PFS_buffer_scalable_containerI15PFS_table_shareLi4096ELi4096E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE10deallocateEPS0_; PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>::deallocate(PFS_table_share*)
cmp [rbp+var_214], 0
jle short loc_43F34
mov eax, [rbp+var_1E4]
add eax, 1
mov [rbp+var_1E4], eax
cmp eax, 3
jbe short loc_43F2F
lea rax, global_table_share_container
mov rcx, [rax]
add rcx, 1
lea rax, global_table_share_container
mov [rax], rcx
mov [rbp+var_198], 0
jmp short loc_43F64
loc_43F2F:
jmp loc_43B8A
loc_43F34:
lea rax, global_table_share_container
mov rcx, [rax]
add rcx, 1
lea rax, global_table_share_container
mov [rax], rcx
mov [rbp+var_198], 0
jmp short loc_43F64
loc_43F59:
mov [rbp+var_198], 0
loc_43F64:
mov rax, [rbp+var_198]
mov [rbp+var_220], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_43F94
mov rax, [rbp+var_220]
add rsp, 230h
pop rbp
retn
loc_43F94:
call ___stack_chk_fail
|
PFS_table_share * find_or_create_table_share(PFS_thread *a1, char a2, long long a3)
{
unsigned int v3; // edx
unsigned int i; // [rsp+18h] [rbp-218h]
int v6; // [rsp+1Ch] [rbp-214h]
unsigned int j; // [rsp+30h] [rbp-200h]
int v8; // [rsp+34h] [rbp-1FCh] BYREF
PFS_table_share *v9; // [rsp+38h] [rbp-1F8h] BYREF
char v10; // [rsp+46h] [rbp-1EAh] BYREF
char v11; // [rsp+47h] [rbp-1E9h] BYREF
int v12; // [rsp+48h] [rbp-1E8h]
int v13; // [rsp+4Ch] [rbp-1E4h]
PFS_table_share **v14; // [rsp+50h] [rbp-1E0h]
long long v15; // [rsp+58h] [rbp-1D8h]
long long v16; // [rsp+60h] [rbp-1D0h]
long long v17; // [rsp+68h] [rbp-1C8h]
long long v18; // [rsp+70h] [rbp-1C0h]
long long table_share_hash_pins; // [rsp+78h] [rbp-1B8h]
long long v20; // [rsp+80h] [rbp-1B0h]
char v21; // [rsp+8Fh] [rbp-1A1h]
PFS_thread *v22; // [rsp+90h] [rbp-1A0h]
_BYTE v24[388]; // [rsp+A0h] [rbp-190h] BYREF
unsigned int v25; // [rsp+224h] [rbp-Ch]
unsigned long long v26; // [rsp+228h] [rbp-8h]
v26 = __readfsqword(0x28u);
v22 = a1;
v21 = a2 & 1;
v20 = a3;
table_share_hash_pins = get_table_share_hash_pins(a1);
if ( table_share_hash_pins )
{
v18 = *(_QWORD *)(v20 + 672);
v17 = *(_QWORD *)(v20 + 680);
v16 = *(_QWORD *)(v20 + 688);
v15 = *(_QWORD *)(v20 + 696);
set_table_share_key(v24, v21 & 1, v18, v17, v16, v15);
v13 = 0;
v12 = 3;
v11 = 1;
v10 = 1;
while ( 1 )
{
v14 = (PFS_table_share **)lf_hash_search(&table_share_hash, table_share_hash_pins, v24, v25);
if ( (unsigned long long)v14 >= 2 )
break;
_InterlockedExchange64((volatile long long *)(table_share_hash_pins + 16), 0LL);
if ( !v13 )
lookup_setup_object((_DWORD)v22, 4, v18, v17, v16, v15, (long long)&v11, (long long)&v10);
v9 = (PFS_table_share *)PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>::allocate(
global_table_share_container,
&v8);
if ( !v9 )
return 0LL;
memcpy((char *)v9 + 8, v24, 392LL);
*((_QWORD *)v9 + 50) = (char *)v9 + 9;
*((_DWORD *)v9 + 102) = v17;
*((_QWORD *)v9 + 52) = (char *)v9 + v17 + 10;
*((_DWORD *)v9 + 106) = v15;
*((_BYTE *)v9 + 4) = v11 & 1;
*((_BYTE *)v9 + 5) = v10 & 1;
PFS_table_share::init_refcount(v9);
PFS_table_share::destroy_lock_stat(v9);
PFS_table_share::destroy_index_stats(v9);
*((_DWORD *)v9 + 107) = *(_DWORD *)(v20 + 928);
pfs_lock::dirty_to_allocated(v9, &v8, v3);
v6 = lf_hash_insert(&table_share_hash, table_share_hash_pins, &v9);
if ( !v6 )
{
for ( i = 0; i < *((_DWORD *)v9 + 107); ++i )
PFS_table_share::find_or_create_index_stat((long long)v9, v20, i);
return v9;
}
PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>::deallocate(
global_table_share_container,
v9);
if ( v6 <= 0 )
{
++global_table_share_container[0];
return 0LL;
}
if ( (unsigned int)++v13 > 3 )
{
++global_table_share_container[0];
return 0LL;
}
}
v9 = *v14;
PFS_table_share::inc_refcount(v9);
if ( (unsigned int)compare_keys(v9, v20) )
{
PFS_table_share::destroy_index_stats(v9);
*((_DWORD *)v9 + 107) = *(_DWORD *)(v20 + 928);
for ( j = 0; j < *((_DWORD *)v9 + 107); ++j )
PFS_table_share::find_or_create_index_stat((long long)v9, v20, j);
}
_InterlockedExchange64((volatile long long *)(table_share_hash_pins + 16), 0LL);
return v9;
}
else
{
++global_table_share_container[0];
return 0LL;
}
}
|
find_or_create_table_share:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x230
MOV AL,SIL
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV qword ptr [RBP + -0x1a0],RDI
AND AL,0x1
MOV byte ptr [RBP + -0x1a1],AL
MOV qword ptr [RBP + -0x1b0],RDX
MOV RDI,qword ptr [RBP + -0x1a0]
CALL 0x001419b0
MOV qword ptr [RBP + -0x1b8],RAX
CMP qword ptr [RBP + -0x1b8],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00143ae1
LEA RAX,[0x4e01f8]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0x4e01f8]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBP + -0x198],0x0
JMP 0x00143f64
LAB_00143ae1:
MOV RAX,qword ptr [RBP + -0x1b0]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV qword ptr [RBP + -0x1c0],RAX
MOV RAX,qword ptr [RBP + -0x1b0]
MOV RAX,qword ptr [RAX + 0x2a8]
MOV qword ptr [RBP + -0x1c8],RAX
MOV RAX,qword ptr [RBP + -0x1b0]
MOV RAX,qword ptr [RAX + 0x2b0]
MOV qword ptr [RBP + -0x1d0],RAX
MOV RAX,qword ptr [RBP + -0x1b0]
MOV RAX,qword ptr [RAX + 0x2b8]
MOV qword ptr [RBP + -0x1d8],RAX
MOV AL,byte ptr [RBP + -0x1a1]
MOV RDX,qword ptr [RBP + -0x1c0]
MOV RCX,qword ptr [RBP + -0x1c8]
MOV R8,qword ptr [RBP + -0x1d0]
MOV R9,qword ptr [RBP + -0x1d8]
LEA RDI,[RBP + -0x190]
AND AL,0x1
MOVZX ESI,AL
CALL 0x00143fa0
MOV dword ptr [RBP + -0x1e4],0x0
MOV dword ptr [RBP + -0x1e8],0x3
MOV byte ptr [RBP + -0x1e9],0x1
MOV byte ptr [RBP + -0x1ea],0x1
LAB_00143b8a:
MOV RSI,qword ptr [RBP + -0x1b8]
LEA RDX,[RBP + -0x190]
MOV ECX,dword ptr [RBP + -0xc]
LEA RDI,[0x50cd40]
CALL 0x0015da70
MOV qword ptr [RBP + -0x1e0],RAX
CMP qword ptr [RBP + -0x1e0],0x0
JZ 0x00143caa
MOV EAX,0x1
CMP qword ptr [RBP + -0x1e0],RAX
JZ 0x00143caa
MOV RAX,qword ptr [RBP + -0x1e0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x1f8],RAX
MOV RDI,qword ptr [RBP + -0x1f8]
CALL 0x0013dc70
MOV RDI,qword ptr [RBP + -0x1f8]
MOV RSI,qword ptr [RBP + -0x1b0]
CALL 0x001440e0
CMP EAX,0x0
JZ 0x00143c74
MOV RDI,qword ptr [RBP + -0x1f8]
CALL 0x00141ef0
MOV RAX,qword ptr [RBP + -0x1b0]
MOV ECX,dword ptr [RAX + 0x3a0]
MOV RAX,qword ptr [RBP + -0x1f8]
MOV dword ptr [RAX + 0x1ac],ECX
MOV dword ptr [RBP + -0x200],0x0
LAB_00143c33:
MOV EAX,dword ptr [RBP + -0x200]
MOV RCX,qword ptr [RBP + -0x1f8]
CMP EAX,dword ptr [RCX + 0x1ac]
JNC 0x00143c72
MOV RDI,qword ptr [RBP + -0x1f8]
MOV RSI,qword ptr [RBP + -0x1b0]
MOV EDX,dword ptr [RBP + -0x200]
CALL 0x00141cc0
MOV EAX,dword ptr [RBP + -0x200]
ADD EAX,0x1
MOV dword ptr [RBP + -0x200],EAX
JMP 0x00143c33
LAB_00143c72:
JMP 0x00143c74
LAB_00143c74:
JMP 0x00143c76
LAB_00143c76:
JMP 0x00143c78
LAB_00143c78:
JMP 0x00143c7a
LAB_00143c7a:
MOV RCX,qword ptr [RBP + -0x1b8]
MOV qword ptr [RBP + -0x208],0x0
MOV RAX,qword ptr [RBP + -0x208]
XCHG qword ptr [RCX + 0x10],RAX
MOV RAX,qword ptr [RBP + -0x1f8]
MOV qword ptr [RBP + -0x198],RAX
JMP 0x00143f64
LAB_00143caa:
JMP 0x00143cac
LAB_00143cac:
JMP 0x00143cae
LAB_00143cae:
JMP 0x00143cb0
LAB_00143cb0:
MOV RCX,qword ptr [RBP + -0x1b8]
MOV qword ptr [RBP + -0x210],0x0
MOV RAX,qword ptr [RBP + -0x210]
XCHG qword ptr [RCX + 0x10],RAX
CMP dword ptr [RBP + -0x1e4],0x0
JNZ 0x00143d1f
MOV RDI,qword ptr [RBP + -0x1a0]
MOV RDX,qword ptr [RBP + -0x1c0]
MOV RAX,qword ptr [RBP + -0x1c8]
MOV ECX,EAX
MOV R8,qword ptr [RBP + -0x1d0]
MOV RAX,qword ptr [RBP + -0x1d8]
MOV R9D,EAX
MOV ESI,0x4
LEA R10,[RBP + -0x1e9]
LEA RAX,[RBP + -0x1ea]
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001495d0
LAB_00143d1f:
LEA RDI,[0x4e01f8]
LEA RSI,[RBP + -0x1fc]
CALL 0x00145870
MOV qword ptr [RBP + -0x1f8],RAX
CMP qword ptr [RBP + -0x1f8],0x0
JZ 0x00143f59
MOV RDI,qword ptr [RBP + -0x1f8]
ADD RDI,0x8
LEA RSI,[RBP + -0x190]
MOV EDX,0x188
CALL 0x00126280
MOV RCX,qword ptr [RBP + -0x1f8]
ADD RCX,0x8
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x1f8]
MOV qword ptr [RAX + 0x190],RCX
MOV RAX,qword ptr [RBP + -0x1c8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x1f8]
MOV dword ptr [RAX + 0x198],ECX
MOV RCX,qword ptr [RBP + -0x1f8]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x1c8]
ADD RAX,0x2
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x1f8]
MOV qword ptr [RAX + 0x1a0],RCX
MOV RAX,qword ptr [RBP + -0x1d8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x1f8]
MOV dword ptr [RAX + 0x1a8],ECX
MOV CL,byte ptr [RBP + -0x1e9]
MOV RAX,qword ptr [RBP + -0x1f8]
AND CL,0x1
MOV byte ptr [RAX + 0x4],CL
MOV CL,byte ptr [RBP + -0x1ea]
MOV RAX,qword ptr [RBP + -0x1f8]
AND CL,0x1
MOV byte ptr [RAX + 0x5],CL
MOV RDI,qword ptr [RBP + -0x1f8]
CALL 0x00145c20
MOV RDI,qword ptr [RBP + -0x1f8]
CALL 0x00141c00
MOV RDI,qword ptr [RBP + -0x1f8]
CALL 0x00141ef0
MOV RAX,qword ptr [RBP + -0x1b0]
MOV ECX,dword ptr [RAX + 0x3a0]
MOV RAX,qword ptr [RBP + -0x1f8]
MOV dword ptr [RAX + 0x1ac],ECX
MOV RDI,qword ptr [RBP + -0x1f8]
LEA RSI,[RBP + -0x1fc]
CALL 0x0012ca70
MOV RSI,qword ptr [RBP + -0x1b8]
LEA RDI,[0x50cd40]
LEA RDX,[RBP + -0x1f8]
CALL 0x0015ca50
MOV dword ptr [RBP + -0x214],EAX
CMP dword ptr [RBP + -0x214],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00143eda
MOV dword ptr [RBP + -0x218],0x0
LAB_00143e88:
MOV EAX,dword ptr [RBP + -0x218]
MOV RCX,qword ptr [RBP + -0x1f8]
CMP EAX,dword ptr [RCX + 0x1ac]
JNC 0x00143ec7
MOV RDI,qword ptr [RBP + -0x1f8]
MOV RSI,qword ptr [RBP + -0x1b0]
MOV EDX,dword ptr [RBP + -0x218]
CALL 0x00141cc0
MOV EAX,dword ptr [RBP + -0x218]
ADD EAX,0x1
MOV dword ptr [RBP + -0x218],EAX
JMP 0x00143e88
LAB_00143ec7:
MOV RAX,qword ptr [RBP + -0x1f8]
MOV qword ptr [RBP + -0x198],RAX
JMP 0x00143f64
LAB_00143eda:
MOV RSI,qword ptr [RBP + -0x1f8]
LEA RDI,[0x4e01f8]
CALL 0x00145c50
CMP dword ptr [RBP + -0x214],0x0
JLE 0x00143f34
MOV EAX,dword ptr [RBP + -0x1e4]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1e4],EAX
CMP EAX,0x3
JBE 0x00143f2f
LEA RAX,[0x4e01f8]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0x4e01f8]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBP + -0x198],0x0
JMP 0x00143f64
LAB_00143f2f:
JMP 0x00143b8a
LAB_00143f34:
LEA RAX,[0x4e01f8]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0x4e01f8]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBP + -0x198],0x0
JMP 0x00143f64
LAB_00143f59:
MOV qword ptr [RBP + -0x198],0x0
LAB_00143f64:
MOV RAX,qword ptr [RBP + -0x198]
MOV qword ptr [RBP + -0x220],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00143f94
MOV RAX,qword ptr [RBP + -0x220]
ADD RSP,0x230
POP RBP
RET
LAB_00143f94:
CALL 0x00126360
|
/* find_or_create_table_share(PFS_thread*, bool, TABLE_SHARE const*) */
PFS_table_share * find_or_create_table_share(PFS_thread *param_1,bool param_2,TABLE_SHARE *param_3)
{
int iVar1;
long in_FS_OFFSET;
uint local_220;
uint local_208;
pfs_dirty_state local_204 [4];
PFS_table_share *local_200;
byte local_1f2;
byte local_1f1 [5];
uint local_1ec;
int8 *local_1e8;
ulong local_1e0;
char *local_1d8;
ulong local_1d0;
char *local_1c8;
long local_1c0;
TABLE_SHARE *local_1b8;
byte local_1a9;
PFS_thread *local_1a8;
PFS_table_share *local_1a0;
PFS_table_share_key local_198 [388];
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1b8 = param_3;
local_1a9 = param_2;
local_1a8 = param_1;
local_1c0 = get_table_share_hash_pins(param_1);
if (local_1c0 == 0) {
global_table_share_container = global_table_share_container + 1;
local_1a0 = (PFS_table_share *)0x0;
}
else {
local_1c8 = *(char **)(local_1b8 + 0x2a0);
local_1d0 = *(ulong *)(local_1b8 + 0x2a8);
local_1d8 = *(char **)(local_1b8 + 0x2b0);
local_1e0 = *(ulong *)(local_1b8 + 0x2b8);
set_table_share_key(local_198,(bool)(local_1a9 & 1),local_1c8,local_1d0,local_1d8,local_1e0);
local_1ec = 0;
local_1f1[1] = 3;
local_1f1[2] = 0;
local_1f1[3] = 0;
local_1f1[4] = 0;
local_1f1[0] = 1;
local_1f2 = 1;
do {
local_1e8 = (int8 *)lf_hash_search(table_share_hash,local_1c0,local_198,local_14);
if ((local_1e8 != (int8 *)0x0) && (local_1e8 != (int8 *)0x1)) {
local_200 = (PFS_table_share *)*local_1e8;
PFS_table_share::inc_refcount(local_200);
iVar1 = compare_keys(local_200,local_1b8);
if (iVar1 != 0) {
PFS_table_share::destroy_index_stats(local_200);
*(int4 *)(local_200 + 0x1ac) = *(int4 *)(local_1b8 + 0x3a0);
for (local_208 = 0; local_208 < *(uint *)(local_200 + 0x1ac); local_208 = local_208 + 1) {
PFS_table_share::find_or_create_index_stat(local_200,local_1b8,local_208);
}
}
LOCK();
*(int8 *)(local_1c0 + 0x10) = 0;
UNLOCK();
local_1a0 = local_200;
goto LAB_00143f64;
}
LOCK();
*(int8 *)(local_1c0 + 0x10) = 0;
UNLOCK();
if (local_1ec == 0) {
lookup_setup_object(local_1a8,4,local_1c8,local_1d0 & 0xffffffff,local_1d8,
local_1e0 & 0xffffffff,local_1f1,&local_1f2);
}
local_200 = (PFS_table_share *)
PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>
::allocate((PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>
*)&global_table_share_container,local_204);
if (local_200 == (PFS_table_share *)0x0) {
local_1a0 = (PFS_table_share *)0x0;
goto LAB_00143f64;
}
memcpy(local_200 + 8,local_198,0x188);
*(PFS_table_share **)(local_200 + 400) = local_200 + 9;
*(int *)(local_200 + 0x198) = (int)local_1d0;
*(PFS_table_share **)(local_200 + 0x1a0) = local_200 + local_1d0 + 10;
*(int *)(local_200 + 0x1a8) = (int)local_1e0;
local_200[4] = (PFS_table_share)(local_1f1[0] & 1);
local_200[5] = (PFS_table_share)(local_1f2 & 1);
PFS_table_share::init_refcount(local_200);
PFS_table_share::destroy_lock_stat(local_200);
PFS_table_share::destroy_index_stats(local_200);
*(int4 *)(local_200 + 0x1ac) = *(int4 *)(local_1b8 + 0x3a0);
pfs_lock::dirty_to_allocated((pfs_lock *)local_200,local_204);
iVar1 = lf_hash_insert(table_share_hash,local_1c0,&local_200);
if (iVar1 == 0) {
for (local_220 = 0; local_220 < *(uint *)(local_200 + 0x1ac); local_220 = local_220 + 1) {
PFS_table_share::find_or_create_index_stat(local_200,local_1b8,local_220);
}
local_1a0 = local_200;
goto LAB_00143f64;
}
PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>
::deallocate((PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>
*)&global_table_share_container,local_200);
if (iVar1 < 1) {
global_table_share_container = global_table_share_container + 1;
local_1a0 = (PFS_table_share *)0x0;
goto LAB_00143f64;
}
local_1ec = local_1ec + 1;
} while (local_1ec < 4);
global_table_share_container = global_table_share_container + 1;
local_1a0 = (PFS_table_share *)0x0;
}
LAB_00143f64:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_1a0;
}
|
|
64,770 |
mysql_stmt_attr_set
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
my_bool STDCALL mysql_stmt_attr_set(MYSQL_STMT *stmt, enum enum_stmt_attr_type attr_type, const void *value)
{
switch (attr_type) {
case STMT_ATTR_UPDATE_MAX_LENGTH:
stmt->update_max_length= *(my_bool *)value;
break;
case STMT_ATTR_CURSOR_TYPE:
if (*(ulong *)value > (unsigned long) CURSOR_TYPE_READ_ONLY)
{
SET_CLIENT_STMT_ERROR(stmt, CR_NOT_IMPLEMENTED, SQLSTATE_UNKNOWN, 0);
return(1);
}
stmt->flags = *(ulong *)value;
break;
case STMT_ATTR_PREFETCH_ROWS:
if (*(ulong *)value == 0)
*(long *)value= MYSQL_DEFAULT_PREFETCH_ROWS;
else
stmt->prefetch_rows= *(long *)value;
break;
case STMT_ATTR_PREBIND_PARAMS:
if (stmt->state > MYSQL_STMT_INITTED)
{
mysql_stmt_internal_reset(stmt, 1);
net_stmt_close(stmt, 0);
stmt->state= MYSQL_STMT_INITTED;
stmt->params= 0;
}
stmt->prebind_params= stmt->param_count= *(unsigned int *)value;
break;
case STMT_ATTR_ARRAY_SIZE:
stmt->array_size= *(unsigned int *)value;
break;
case STMT_ATTR_ROW_SIZE:
stmt->row_size= *(size_t *)value;
break;
case STMT_ATTR_CB_RESULT:
stmt->result_callback= (ps_result_callback)value;
break;
case STMT_ATTR_CB_PARAM:
stmt->param_callback= (ps_param_callback)value;
break;
case STMT_ATTR_CB_USER_DATA:
stmt->user_data= (void *)value;
break;
default:
SET_CLIENT_STMT_ERROR(stmt, CR_NOT_IMPLEMENTED, SQLSTATE_UNKNOWN, 0);
return(1);
}
return(0);
}
|
O0
|
c
|
mysql_stmt_attr_set:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x2ca52
jmp 0x2c9d3
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x2ca67
jmp 0x2c9e1
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x2caf6
jmp 0x2c9ef
movl -0x24(%rbp), %eax
subl $0xc8, %eax
je 0x2cb24
jmp 0x2c9ff
movl -0x24(%rbp), %eax
subl $0xc9, %eax
je 0x2cb7a
jmp 0x2ca0f
movl -0x24(%rbp), %eax
subl $0xca, %eax
je 0x2cb8f
jmp 0x2ca1f
movl -0x24(%rbp), %eax
subl $0xcc, %eax
je 0x2cbcb
jmp 0x2ca2f
movl -0x24(%rbp), %eax
subl $0xcd, %eax
je 0x2cbba
jmp 0x2ca3f
movl -0x24(%rbp), %eax
subl $0xce, %eax
je 0x2cba6
jmp 0x2cbdc
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x313(%rax)
jmp 0x2cc4a
movq -0x20(%rbp), %rax
cmpq $0x1, (%rax)
jbe 0x2cae2
jmp 0x2ca73
movq -0x10(%rbp), %rax
movl $0x806, 0x108(%rax) # imm = 0x806
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x386ed(%rip), %rax # 0x65180
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x386d3(%rip), %rax # 0x65190
movq 0x1b0(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2cc4e
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0x2cc4a
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2cb0d
movq -0x20(%rbp), %rax
movq $0x1, (%rax)
jmp 0x2cb1f
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x318(%rax)
jmp 0x2cc4a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jbe 0x2cb5e
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x2cc60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2ce70
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x378(%rax)
jmp 0x2cc4a
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x368(%rax)
jmp 0x2cc4a
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x370(%rax)
jmp 0x2cc4a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x388(%rax)
jmp 0x2cc4a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x390(%rax)
jmp 0x2cc4a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x380(%rax)
jmp 0x2cc4a
jmp 0x2cbde
movq -0x10(%rbp), %rax
movl $0x806, 0x108(%rax) # imm = 0x806
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x38582(%rip), %rax # 0x65180
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x38568(%rip), %rax # 0x65190
movq 0x1b0(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2cc4e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
mysql_stmt_attr_set:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov eax, [rbp+var_14]
mov [rbp+var_24], eax
test eax, eax
jz loc_2CA52
jmp short $+2
loc_2C9D3:
mov eax, [rbp+var_24]
sub eax, 1
jz loc_2CA67
jmp short $+2
loc_2C9E1:
mov eax, [rbp+var_24]
sub eax, 2
jz loc_2CAF6
jmp short $+2
loc_2C9EF:
mov eax, [rbp+var_24]
sub eax, 0C8h
jz loc_2CB24
jmp short $+2
loc_2C9FF:
mov eax, [rbp+var_24]
sub eax, 0C9h
jz loc_2CB7A
jmp short $+2
loc_2CA0F:
mov eax, [rbp+var_24]
sub eax, 0CAh
jz loc_2CB8F
jmp short $+2
loc_2CA1F:
mov eax, [rbp+var_24]
sub eax, 0CCh
jz loc_2CBCB
jmp short $+2
loc_2CA2F:
mov eax, [rbp+var_24]
sub eax, 0CDh
jz loc_2CBBA
jmp short $+2
loc_2CA3F:
mov eax, [rbp+var_24]
sub eax, 0CEh
jz loc_2CBA6
jmp loc_2CBDC
loc_2CA52:
mov rax, [rbp+var_20]
mov cl, [rax]
mov rax, [rbp+var_10]
mov [rax+313h], cl
jmp loc_2CC4A
loc_2CA67:
mov rax, [rbp+var_20]
cmp qword ptr [rax], 1
jbe short loc_2CAE2
jmp short $+2
loc_2CA73:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 806h
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_10]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+1B0h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_1], 1
jmp loc_2CC4E
loc_2CAE2:
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+48h], rcx
jmp loc_2CC4A
loc_2CAF6:
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jnz short loc_2CB0D
mov rax, [rbp+var_20]
mov qword ptr [rax], 1
jmp short loc_2CB1F
loc_2CB0D:
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+318h], rcx
loc_2CB1F:
jmp loc_2CC4A
loc_2CB24:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 0
jbe short loc_2CB5E
mov rdi, [rbp+var_10]
mov esi, 1
call mysql_stmt_internal_reset
mov rdi, [rbp+var_10]
xor esi, esi
call net_stmt_close
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+70h], 0
loc_2CB5E:
mov rax, [rbp+var_20]
mov ecx, [rax]
mov rax, [rbp+var_10]
mov [rax+64h], ecx
mov rax, [rbp+var_10]
mov [rax+378h], ecx
jmp loc_2CC4A
loc_2CB7A:
mov rax, [rbp+var_20]
mov ecx, [rax]
mov rax, [rbp+var_10]
mov [rax+368h], ecx
jmp loc_2CC4A
loc_2CB8F:
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+370h], rcx
jmp loc_2CC4A
loc_2CBA6:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+388h], rcx
jmp loc_2CC4A
loc_2CBBA:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+390h], rcx
jmp short loc_2CC4A
loc_2CBCB:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+380h], rcx
jmp short loc_2CC4A
loc_2CBDC:
jmp short $+2
loc_2CBDE:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 806h
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_10]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+1B0h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_1], 1
jmp short loc_2CC4E
loc_2CC4A:
mov [rbp+var_1], 0
loc_2CC4E:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char mysql_stmt_attr_set(long long a1, int a2, _BYTE *a3)
{
int v3; // ecx
if ( !a2 )
{
*(_BYTE *)(a1 + 787) = *a3;
return 0;
}
if ( a2 != 1 )
{
switch ( a2 )
{
case 2:
if ( *(_QWORD *)a3 )
*(_QWORD *)(a1 + 792) = *(_QWORD *)a3;
else
*(_QWORD *)a3 = 1LL;
break;
case 200:
if ( *(_DWORD *)(a1 + 80) )
{
mysql_stmt_internal_reset(a1, 1LL);
net_stmt_close(a1, 0LL);
*(_DWORD *)(a1 + 80) = 0;
*(_QWORD *)(a1 + 112) = 0LL;
}
v3 = *(_DWORD *)a3;
*(_DWORD *)(a1 + 100) = *(_DWORD *)a3;
*(_DWORD *)(a1 + 888) = v3;
break;
case 201:
*(_DWORD *)(a1 + 872) = *(_DWORD *)a3;
break;
case 202:
*(_QWORD *)(a1 + 880) = *(_QWORD *)a3;
break;
case 204:
*(_QWORD *)(a1 + 896) = a3;
break;
case 205:
*(_QWORD *)(a1 + 912) = a3;
break;
case 206:
*(_QWORD *)(a1 + 904) = a3;
break;
default:
goto LABEL_13;
}
return 0;
}
if ( *(_QWORD *)a3 <= 1uLL )
{
*(_QWORD *)(a1 + 72) = *(_QWORD *)a3;
return 0;
}
LABEL_13:
*(_DWORD *)(a1 + 264) = 2054;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[54], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
|
mysql_stmt_attr_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x24],EAX
TEST EAX,EAX
JZ 0x0012ca52
JMP 0x0012c9d3
LAB_0012c9d3:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x1
JZ 0x0012ca67
JMP 0x0012c9e1
LAB_0012c9e1:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x2
JZ 0x0012caf6
JMP 0x0012c9ef
LAB_0012c9ef:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc8
JZ 0x0012cb24
JMP 0x0012c9ff
LAB_0012c9ff:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc9
JZ 0x0012cb7a
JMP 0x0012ca0f
LAB_0012ca0f:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xca
JZ 0x0012cb8f
JMP 0x0012ca1f
LAB_0012ca1f:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xcc
JZ 0x0012cbcb
JMP 0x0012ca2f
LAB_0012ca2f:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xcd
JZ 0x0012cbba
JMP 0x0012ca3f
LAB_0012ca3f:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xce
JZ 0x0012cba6
JMP 0x0012cbdc
LAB_0012ca52:
MOV RAX,qword ptr [RBP + -0x20]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x313],CL
JMP 0x0012cc4a
LAB_0012ca67:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x1
JBE 0x0012cae2
JMP 0x0012ca73
LAB_0012ca73:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x806
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x165180]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x165190]
MOV RSI,qword ptr [RAX + 0x1b0]
MOV EDX,0x200
CALL 0x00113220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012cc4e
LAB_0012cae2:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],RCX
JMP 0x0012cc4a
LAB_0012caf6:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JNZ 0x0012cb0d
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x1
JMP 0x0012cb1f
LAB_0012cb0d:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x318],RCX
LAB_0012cb1f:
JMP 0x0012cc4a
LAB_0012cb24:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x0
JBE 0x0012cb5e
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x1
CALL 0x0012cc60
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x0012ce70
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x70],0x0
LAB_0012cb5e:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x64],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x378],ECX
JMP 0x0012cc4a
LAB_0012cb7a:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x368],ECX
JMP 0x0012cc4a
LAB_0012cb8f:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x370],RCX
JMP 0x0012cc4a
LAB_0012cba6:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x388],RCX
JMP 0x0012cc4a
LAB_0012cbba:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x390],RCX
JMP 0x0012cc4a
LAB_0012cbcb:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x380],RCX
JMP 0x0012cc4a
LAB_0012cbdc:
JMP 0x0012cbde
LAB_0012cbde:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x806
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x165180]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x165190]
MOV RSI,qword ptr [RAX + 0x1b0]
MOV EDX,0x200
CALL 0x00113220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012cc4e
LAB_0012cc4a:
MOV byte ptr [RBP + -0x1],0x0
LAB_0012cc4e:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 mysql_stmt_attr_set(long param_1,int param_2,ulong *param_3)
{
ulong uVar1;
if (param_2 == 0) {
*(char *)(param_1 + 0x313) = (char)*param_3;
}
else if (param_2 == 1) {
if (1 < *param_3) {
*(int4 *)(param_1 + 0x108) = 0x806;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_This_feature_is_not_implemented_o_00165340,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
*(ulong *)(param_1 + 0x48) = *param_3;
}
else if (param_2 == 2) {
if (*param_3 == 0) {
*param_3 = 1;
}
else {
*(ulong *)(param_1 + 0x318) = *param_3;
}
}
else if (param_2 == 200) {
if (*(int *)(param_1 + 0x50) != 0) {
mysql_stmt_internal_reset(param_1,1);
net_stmt_close(param_1,0);
*(int4 *)(param_1 + 0x50) = 0;
*(int8 *)(param_1 + 0x70) = 0;
}
uVar1 = *param_3;
*(int *)(param_1 + 100) = (int)uVar1;
*(int *)(param_1 + 0x378) = (int)uVar1;
}
else if (param_2 == 0xc9) {
*(int *)(param_1 + 0x368) = (int)*param_3;
}
else if (param_2 == 0xca) {
*(ulong *)(param_1 + 0x370) = *param_3;
}
else if (param_2 == 0xcc) {
*(ulong **)(param_1 + 0x380) = param_3;
}
else if (param_2 == 0xcd) {
*(ulong **)(param_1 + 0x390) = param_3;
}
else {
if (param_2 != 0xce) {
*(int4 *)(param_1 + 0x108) = 0x806;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_This_feature_is_not_implemented_o_00165340,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
*(ulong **)(param_1 + 0x388) = param_3;
}
return 0;
}
|
|
64,771 |
ggml_compute_forward_dup_same_cont(ggml_compute_params const*, ggml_tensor*)
|
ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp
|
static void ggml_compute_forward_dup_same_cont(
const ggml_compute_params * params,
ggml_tensor * dst) {
const ggml_tensor * src0 = dst->src[0];
GGML_ASSERT(ggml_nelements(dst) == ggml_nelements(src0));
GGML_ASSERT(ggml_is_contiguous(dst) && ggml_is_contiguous(src0));
GGML_ASSERT(src0->type == dst->type);
const size_t nb0 = ggml_type_size(src0->type);
const int ith = params->ith; // thread index
const int nth = params->nth; // number of threads
// parallelize by blocks
const int nk = ggml_nelements(src0)/ggml_blck_size(src0->type);
const int dr = (nk + nth - 1) / nth;
const int k0 = dr * ith;
const int k1 = MIN(k0 + dr, nk);
if (k0 < k1) {
memcpy(
((char *) dst->data + k0*nb0),
((char *) src0->data + k0*nb0),
(k1 - k0) * nb0);
}
}
|
O0
|
cpp
|
ggml_compute_forward_dup_same_cont(ggml_compute_params const*, ggml_tensor*):
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0xfd30
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0xfd30
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
je 0xa7926
leaq 0xdd8c(%rip), %rdi # 0xb5698
movl $0x20, %esi
leaq 0x4066(%rip), %rdx # 0xab97e
leaq 0xdf13(%rip), %rcx # 0xb5832
movb $0x0, %al
callq 0x10660
movq 0x48(%rsp), %rdi
callq 0xf2c0
testb $0x1, %al
jne 0xa7936
jmp 0xa7944
movq 0x40(%rsp), %rdi
callq 0xf2c0
testb $0x1, %al
jne 0xa7965
leaq 0xdd4d(%rip), %rdi # 0xb5698
movl $0x21, %esi
leaq 0x4027(%rip), %rdx # 0xab97e
leaq 0xdf18(%rip), %rcx # 0xb5876
movb $0x0, %al
callq 0x10660
movq 0x40(%rsp), %rax
movl (%rax), %eax
movq 0x48(%rsp), %rcx
cmpl (%rcx), %eax
je 0xa7996
leaq 0xdd1c(%rip), %rdi # 0xb5698
movl $0x22, %esi
leaq 0x3ff6(%rip), %rdx # 0xab97e
leaq 0xdecf(%rip), %rcx # 0xb585e
movb $0x0, %al
callq 0x10660
movq 0x40(%rsp), %rax
movl (%rax), %edi
callq 0xfcb0
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x50(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0xfd30
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movl (%rax), %edi
callq 0x104d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cqto
idivq %rcx
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
addl 0x30(%rsp), %eax
subl $0x1, %eax
cltd
idivl 0x30(%rsp)
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
imull 0x34(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0xa7a27
movl 0x24(%rsp), %eax
addl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xa7a2f
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0xa7a8b
movq 0x48(%rsp), %rax
movq 0xf8(%rax), %rdi
movslq 0x24(%rsp), %rax
imulq 0x38(%rsp), %rax
addq %rax, %rdi
movq 0x40(%rsp), %rax
movq 0xf8(%rax), %rsi
movslq 0x24(%rsp), %rax
imulq 0x38(%rsp), %rax
addq %rax, %rsi
movl 0x20(%rsp), %eax
subl 0x24(%rsp), %eax
movslq %eax, %rdx
imulq 0x38(%rsp), %rdx
callq 0xfa50
addq $0x58, %rsp
retq
|
_ZL34ggml_compute_forward_dup_same_contPK19ggml_compute_paramsP11ggml_tensor:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov rax, [rsp+58h+var_10]
mov rax, [rax+98h]
mov [rsp+58h+var_18], rax
mov rdi, [rsp+58h+var_10]
call _ggml_nelements
mov [rsp+58h+var_40], rax
mov rdi, [rsp+58h+var_18]
call _ggml_nelements
mov rcx, rax
mov rax, [rsp+58h+var_40]
cmp rax, rcx
jz short loc_A7926
lea rdi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
mov esi, 20h ; ' '
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlNelementsD; "ggml_nelements(dst) == ggml_nelements(s"...
mov al, 0
call _ggml_abort
loc_A7926:
mov rdi, [rsp+58h+var_10]
call _ggml_is_contiguous
test al, 1
jnz short loc_A7936
jmp short loc_A7944
loc_A7936:
mov rdi, [rsp+58h+var_18]
call _ggml_is_contiguous
test al, 1
jnz short loc_A7965
loc_A7944:
lea rdi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
mov esi, 21h ; '!'
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_3; "ggml_is_contiguous(dst) && ggml_is_cont"...
mov al, 0
call _ggml_abort
loc_A7965:
mov rax, [rsp+58h+var_18]
mov eax, [rax]
mov rcx, [rsp+58h+var_10]
cmp eax, [rcx]
jz short loc_A7996
lea rdi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
mov esi, 22h ; '"'
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSrc0TypeDstTyp; "src0->type == dst->type"
mov al, 0
call _ggml_abort
loc_A7996:
mov rax, [rsp+58h+var_18]
mov edi, [rax]
call _ggml_type_size
mov [rsp+58h+var_20], rax
mov rax, [rsp+58h+var_8]
mov eax, [rax]
mov [rsp+58h+var_24], eax
mov rax, [rsp+58h+var_8]
mov eax, [rax+4]
mov [rsp+58h+var_28], eax
mov rdi, [rsp+58h+var_18]
call _ggml_nelements
mov [rsp+58h+var_48], rax
mov rax, [rsp+58h+var_18]
mov edi, [rax]
call _ggml_blck_size
mov rcx, rax
mov rax, [rsp+58h+var_48]
cqo
idiv rcx
mov [rsp+58h+var_2C], eax
mov eax, [rsp+58h+var_2C]
add eax, [rsp+58h+var_28]
sub eax, 1
cdq
idiv [rsp+58h+var_28]
mov [rsp+58h+var_30], eax
mov eax, [rsp+58h+var_30]
imul eax, [rsp+58h+var_24]
mov [rsp+58h+var_34], eax
mov eax, [rsp+58h+var_34]
add eax, [rsp+58h+var_30]
cmp eax, [rsp+58h+var_2C]
jge short loc_A7A27
mov eax, [rsp+58h+var_34]
add eax, [rsp+58h+var_30]
mov [rsp+58h+var_4C], eax
jmp short loc_A7A2F
loc_A7A27:
mov eax, [rsp+58h+var_2C]
mov [rsp+58h+var_4C], eax
loc_A7A2F:
mov eax, [rsp+58h+var_4C]
mov [rsp+58h+var_38], eax
mov eax, [rsp+58h+var_34]
cmp eax, [rsp+58h+var_38]
jge short loc_A7A8B
mov rax, [rsp+58h+var_10]
mov rdi, [rax+0F8h]
movsxd rax, [rsp+58h+var_34]
imul rax, [rsp+58h+var_20]
add rdi, rax
mov rax, [rsp+58h+var_18]
mov rsi, [rax+0F8h]
movsxd rax, [rsp+58h+var_34]
imul rax, [rsp+58h+var_20]
add rsi, rax
mov eax, [rsp+58h+var_38]
sub eax, [rsp+58h+var_34]
movsxd rdx, eax
imul rdx, [rsp+58h+var_20]
call _memcpy
loc_A7A8B:
add rsp, 58h
retn
|
double ggml_compute_forward_dup_same_cont(int *a1, long long a2)
{
double result; // xmm0_8
int v3; // [rsp+Ch] [rbp-4Ch]
long long v4; // [rsp+10h] [rbp-48h]
long long v5; // [rsp+18h] [rbp-40h]
int v6; // [rsp+24h] [rbp-34h]
int v7; // [rsp+28h] [rbp-30h]
int v8; // [rsp+2Ch] [rbp-2Ch]
int v9; // [rsp+30h] [rbp-28h]
int v10; // [rsp+34h] [rbp-24h]
long long v11; // [rsp+38h] [rbp-20h]
unsigned int *v12; // [rsp+40h] [rbp-18h]
v12 = *(unsigned int **)(a2 + 152);
v5 = ggml_nelements(a2);
if ( v5 != ggml_nelements(v12) )
result = ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp",
32LL,
"GGML_ASSERT(%s) failed",
"ggml_nelements(dst) == ggml_nelements(src0)");
if ( (ggml_is_contiguous(a2) & 1) == 0 || (ggml_is_contiguous(v12) & 1) == 0 )
result = ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp",
33LL,
"GGML_ASSERT(%s) failed",
"ggml_is_contiguous(dst) && ggml_is_contiguous(src0)");
if ( *v12 != *(_DWORD *)a2 )
result = ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp",
34LL,
"GGML_ASSERT(%s) failed",
"src0->type == dst->type");
v11 = ggml_type_size(*v12);
v10 = *a1;
v9 = a1[1];
v4 = ggml_nelements(v12);
v8 = v4 / ggml_blck_size(*v12);
v7 = (v9 + v8 - 1) / v9;
v6 = v10 * v7;
if ( v7 + v10 * v7 >= v8 )
v3 = v8;
else
v3 = v7 + v6;
if ( v6 < v3 )
return memcpy(v11 * v6 + *(_QWORD *)(a2 + 248), v11 * v6 + *((_QWORD *)v12 + 31), v11 * (v3 - v6));
return result;
}
|
ggml_compute_forward_dup_same_cont:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x0010fd30
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x0010fd30
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x18]
CMP RAX,RCX
JZ 0x001a7926
LEA RDI,[0x1b5698]
MOV ESI,0x20
LEA RDX,[0x1ab97e]
LEA RCX,[0x1b5832]
MOV AL,0x0
CALL 0x00110660
LAB_001a7926:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x0010f2c0
TEST AL,0x1
JNZ 0x001a7936
JMP 0x001a7944
LAB_001a7936:
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x0010f2c0
TEST AL,0x1
JNZ 0x001a7965
LAB_001a7944:
LEA RDI,[0x1b5698]
MOV ESI,0x21
LEA RDX,[0x1ab97e]
LEA RCX,[0x1b5876]
MOV AL,0x0
CALL 0x00110660
LAB_001a7965:
MOV RAX,qword ptr [RSP + 0x40]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x48]
CMP EAX,dword ptr [RCX]
JZ 0x001a7996
LEA RDI,[0x1b5698]
MOV ESI,0x22
LEA RDX,[0x1ab97e]
LEA RCX,[0x1b585e]
MOV AL,0x0
CALL 0x00110660
LAB_001a7996:
MOV RAX,qword ptr [RSP + 0x40]
MOV EDI,dword ptr [RAX]
CALL 0x0010fcb0
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x34],EAX
MOV RAX,qword ptr [RSP + 0x50]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RSP + 0x30],EAX
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x0010fd30
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV EDI,dword ptr [RAX]
CALL 0x001104d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
CQO
IDIV RCX
MOV dword ptr [RSP + 0x2c],EAX
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,dword ptr [RSP + 0x30]
SUB EAX,0x1
CDQ
IDIV dword ptr [RSP + 0x30]
MOV dword ptr [RSP + 0x28],EAX
MOV EAX,dword ptr [RSP + 0x28]
IMUL EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x24],EAX
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,dword ptr [RSP + 0x28]
CMP EAX,dword ptr [RSP + 0x2c]
JGE 0x001a7a27
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,dword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0xc],EAX
JMP 0x001a7a2f
LAB_001a7a27:
MOV EAX,dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0xc],EAX
LAB_001a7a2f:
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x20],EAX
MOV EAX,dword ptr [RSP + 0x24]
CMP EAX,dword ptr [RSP + 0x20]
JGE 0x001a7a8b
MOV RAX,qword ptr [RSP + 0x48]
MOV RDI,qword ptr [RAX + 0xf8]
MOVSXD RAX,dword ptr [RSP + 0x24]
IMUL RAX,qword ptr [RSP + 0x38]
ADD RDI,RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RAX + 0xf8]
MOVSXD RAX,dword ptr [RSP + 0x24]
IMUL RAX,qword ptr [RSP + 0x38]
ADD RSI,RAX
MOV EAX,dword ptr [RSP + 0x20]
SUB EAX,dword ptr [RSP + 0x24]
MOVSXD RDX,EAX
IMUL RDX,qword ptr [RSP + 0x38]
CALL 0x0010fa50
LAB_001a7a8b:
ADD RSP,0x58
RET
|
/* ggml_compute_forward_dup_same_cont(ggml_compute_params const*, ggml_tensor*) */
void ggml_compute_forward_dup_same_cont(ggml_compute_params *param_1,ggml_tensor *param_2)
{
int *piVar1;
int iVar2;
int iVar3;
long lVar4;
long lVar5;
ulong uVar6;
long lVar7;
int local_4c;
piVar1 = *(int **)(param_2 + 0x98);
lVar4 = ggml_nelements(param_2);
lVar5 = ggml_nelements(piVar1);
if (lVar4 != lVar5) {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp"
,0x20,"GGML_ASSERT(%s) failed","ggml_nelements(dst) == ggml_nelements(src0)");
}
uVar6 = ggml_is_contiguous(param_2);
if (((uVar6 & 1) == 0) || (uVar6 = ggml_is_contiguous(piVar1), (uVar6 & 1) == 0)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp"
,0x21,"GGML_ASSERT(%s) failed","ggml_is_contiguous(dst) && ggml_is_contiguous(src0)")
;
}
if (*piVar1 != *(int *)param_2) {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp"
,0x22,"GGML_ASSERT(%s) failed","src0->type == dst->type");
}
lVar4 = ggml_type_size(*piVar1);
iVar3 = *(int *)param_1;
iVar2 = *(int *)(param_1 + 4);
lVar5 = ggml_nelements(piVar1);
lVar7 = ggml_blck_size(*piVar1);
local_4c = (int)(lVar5 / lVar7);
iVar2 = (local_4c + iVar2 + -1) / iVar2;
iVar3 = iVar2 * iVar3;
if (iVar3 + iVar2 < local_4c) {
local_4c = iVar3 + iVar2;
}
if (iVar3 < local_4c) {
memcpy((void *)(*(long *)(param_2 + 0xf8) + iVar3 * lVar4),
(void *)(*(long *)(piVar1 + 0x3e) + iVar3 * lVar4),(local_4c - iVar3) * lVar4);
}
return;
}
|
|
64,772 |
void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(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&, 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>::boolean_t&)
|
llama.cpp/common/json.hpp
|
inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
{
if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
{
JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
}
b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
}
|
O3
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(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&, 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>::boolean_t&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x4, (%rdi)
jne 0x76056
movb 0x8(%r14), %al
movb %al, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1c460
movq %rax, %rbx
movq %r14, %rdi
callq 0x30fda
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x55ec5(%rip), %rsi # 0xcbf3f
leaq 0x10(%rsp), %rdi
callq 0x760ec
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x72d1c
xorl %ebp, %ebp
leaq 0x87e3b(%rip), %rsi # 0xfdee0
leaq -0x488a6(%rip), %rdx # 0x2d806
movq %rbx, %rdi
callq 0x1c7b0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x760d2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1c110
testb %bpl, %bpl
jne 0x760dc
jmp 0x760e4
movq %rax, %r14
movq %rbx, %rdi
callq 0x1caa0
movq %r14, %rdi
callq 0x1c7d0
|
_ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_9boolean_tE:
push rbp; void *
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 4
jnz short loc_76056
mov al, [r14+8]
mov [rsi], al
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_76056:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeBool; "type must be boolean, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA30_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[30],char const*>(char const(&)[30],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_760D2
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_760D2:
test bpl, bpl
jnz short loc_760DC
jmp short loc_760E4
mov r14, rax
loc_760DC:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_760E4:
mov rdi, r14
call __Unwind_Resume
|
unsigned __int8 nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
unsigned __int8 *a1,
unsigned __int8 *a2)
{
unsigned __int8 result; // al
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *a1 != 4 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[30],char const*>(
v4,
"type must be boolean, but is ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
result = a1[8];
*a2 = result;
return result;
}
|
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x4
JNZ 0x00176056
MOV AL,byte ptr [R14 + 0x8]
MOV byte ptr [RSI],AL
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00176056:
MOV EDI,0x20
CALL 0x0011c460
MOV RBX,RAX
MOV RDI,R14
CALL 0x00130fda
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00176073:
LEA RSI,[0x1cbf3f]
LEA RDI,[RSP + 0x10]
CALL 0x001760ec
MOV BPL,0x1
LAB_00176087:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x00172d1c
XOR EBP,EBP
LEA RSI,[0x1fdee0]
LEA RDX,[0x12d806]
MOV RDI,RBX
CALL 0x0011c7b0
|
/* void
nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> 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>::boolean_t&) */
void nlohmann::json_abi_v3_11_3::detail::
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(basic_json *param_1,boolean_t *param_2)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*param_1 == (basic_json)0x4) {
*param_2 = param_1[8];
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
/* try { // try from 00176073 to 00176083 has its CatchHandler @ 001760d9 */
concat<std::__cxx11::string,char_const(&)[30],char_const*>
(local_38,"type must be boolean, but is ",&local_40);
/* try { // try from 00176087 to 001760b3 has its CatchHandler @ 001760b4 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&type_error::typeinfo,exception::~exception);
}
|
|
64,773 |
fts_ast_state_free(fts_ast_state_t*)
|
eloqsql/storage/innobase/fts/fts0ast.cc
|
void
fts_ast_state_free(
/*===============*/
fts_ast_state_t*state) /*!< in: ast state to free */
{
fts_ast_node_t* node = state->list.head;
/* Free the nodes that were allocated during parsing. */
while (node) {
fts_ast_node_t* next = node->next_alloc;
if (node->type == FTS_AST_TEXT && node->text.ptr) {
fts_ast_string_free(node->text.ptr);
node->text.ptr = NULL;
} else if (node->type == FTS_AST_TERM && node->term.ptr) {
fts_ast_string_free(node->term.ptr);
node->term.ptr = NULL;
}
ut_free(node);
node = next;
}
state->root = state->list.head = state->list.tail = NULL;
}
|
O0
|
cpp
|
fts_ast_state_free(fts_ast_state_t*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12397d6
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x123977e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x123977e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12394f0
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x12397ad
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x12397ab
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x12397ab
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x12394f0
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x12397ad
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
callq 0xfc4360
movq -0x10(%rbp), %rsi
leaq -0x1c(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xfc7f70
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1239738
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
|
_Z18fts_ast_state_freeP15fts_ast_state_t:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_10], rax
loc_1239738:
cmp [rbp+var_10], 0
jz loc_12397D6
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
cmp dword ptr [rax], 3
jnz short loc_123977E
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 0
jz short loc_123977E
mov rax, [rbp+var_10]
mov rdi, [rax+8]
call _Z19fts_ast_string_freeP16fts_ast_string_t; fts_ast_string_free(fts_ast_string_t *)
mov rax, [rbp+var_10]
mov qword ptr [rax+8], 0
jmp short loc_12397AD
loc_123977E:
mov rax, [rbp+var_10]
cmp dword ptr [rax], 2
jnz short loc_12397AB
mov rax, [rbp+var_10]
cmp qword ptr [rax+18h], 0
jz short loc_12397AB
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
call _Z19fts_ast_string_freeP16fts_ast_string_t; fts_ast_string_free(fts_ast_string_t *)
mov rax, [rbp+var_10]
mov qword ptr [rax+18h], 0
loc_12397AB:
jmp short $+2
loc_12397AD:
lea rdi, [rbp+var_1C]
xor esi, esi
call _ZN12ut_allocatorIhLb1EEC2Ej; ut_allocator<uchar,true>::ut_allocator(uint)
mov rsi, [rbp+var_10]
lea rdi, [rbp+var_1C]
xor eax, eax
mov edx, eax
call _ZN12ut_allocatorIhLb1EE10deallocateEPhm; ut_allocator<uchar,true>::deallocate(uchar *,ulong)
mov rax, [rbp+var_18]
mov [rbp+var_10], rax
jmp loc_1239738
loc_12397D6:
mov rax, [rbp+var_8]
mov qword ptr [rax+18h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
add rsp, 20h
pop rbp
retn
|
_QWORD * fts_ast_state_free(_QWORD *a1)
{
_QWORD *result; // rax
int v2; // [rsp+4h] [rbp-1Ch] BYREF
long long v3; // [rsp+8h] [rbp-18h]
long long i; // [rsp+10h] [rbp-10h]
_QWORD *v5; // [rsp+18h] [rbp-8h]
v5 = a1;
for ( i = a1[2]; i; i = v3 )
{
v3 = *(_QWORD *)(i + 72);
if ( *(_DWORD *)i == 3 && *(_QWORD *)(i + 8) )
{
fts_ast_string_free(*(long long **)(i + 8));
*(_QWORD *)(i + 8) = 0LL;
}
else if ( *(_DWORD *)i == 2 )
{
if ( *(_QWORD *)(i + 24) )
{
fts_ast_string_free(*(long long **)(i + 24));
*(_QWORD *)(i + 24) = 0LL;
}
}
ut_allocator<unsigned char,true>::ut_allocator(&v2, 0);
ut_allocator<unsigned char,true>::deallocate((long long)&v2, i);
}
v5[3] = 0LL;
v5[2] = 0LL;
result = v5;
v5[1] = 0LL;
return result;
}
|
deallocate_trace:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RAX,[0x1c0e4d0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x3f8]
MOV RCX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RCX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x8]
CALL RAX
ADD RSP,0x10
POP RBP
RET
|
/* ut_allocator<Pool<trx_t, TrxFactory, TrxPoolLock>, true>::deallocate_trace(ut_new_pfx_t const*)
*/
void __thiscall
ut_allocator<Pool<trx_t,TrxFactory,TrxPoolLock>,true>::deallocate_trace
(ut_allocator<Pool<trx_t,TrxFactory,TrxPoolLock>,true> *this,ut_new_pfx_t *param_1)
{
(**(code **)(PSI_server + 0x3f8))
(*(int4 *)param_1,*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 8));
return;
}
|
|
64,774 |
my_numcells_sjis
|
eloqsql/strings/ctype-sjis.c
|
static
size_t my_numcells_sjis(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *str_end)
{
size_t clen;
const uchar *b= (const uchar *) str;
const uchar *e= (const uchar *) str_end;
for (clen= 0; b < e; )
{
if (*b >= 0xA1 && *b <= 0xDF)
{
clen++;
b++;
}
else if (*b > 0x7F)
{
clen+= 2;
b+= 2;
}
else
{
clen++;
b++;
}
}
return clen;
}
|
O3
|
c
|
my_numcells_sjis:
cmpq %rdx, %rsi
jae 0x3ebfb
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x1, %ecx
movb (%rsi), %dil
leal 0x5f(%rdi), %r8d
shrb $0x7, %dil
movzbl %dil, %edi
incq %rdi
cmpb $0x3f, %r8b
cmovbq %rcx, %rdi
addq %rdi, %rax
addq %rdi, %rsi
cmpq %rdx, %rsi
jb 0x3ebd4
popq %rbp
retq
xorl %eax, %eax
retq
|
my_numcells_sjis:
cmp rsi, rdx
jnb short loc_3EBFB
push rbp
mov rbp, rsp
xor eax, eax
mov ecx, 1
loc_3EBD4:
mov dil, [rsi]
lea r8d, [rdi+5Fh]
shr dil, 7
movzx edi, dil
inc rdi
cmp r8b, 3Fh ; '?'
cmovb rdi, rcx
add rax, rdi
add rsi, rdi
cmp rsi, rdx
jb short loc_3EBD4
pop rbp
retn
loc_3EBFB:
xor eax, eax
retn
|
long long my_numcells_sjis(long long a1, _BYTE *a2, unsigned long long a3)
{
long long result; // rax
long long v4; // rdi
if ( (unsigned long long)a2 >= a3 )
return 0LL;
result = 0LL;
do
{
v4 = (*a2 >> 7) + 1LL;
if ( (unsigned __int8)(*a2 + 95) < 0x3Fu )
v4 = 1LL;
result += v4;
a2 += v4;
}
while ( (unsigned long long)a2 < a3 );
return result;
}
|
my_numcells_sjis:
CMP RSI,RDX
JNC 0x0013ebfb
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
MOV ECX,0x1
LAB_0013ebd4:
MOV DIL,byte ptr [RSI]
LEA R8D,[RDI + 0x5f]
SHR DIL,0x7
MOVZX EDI,DIL
INC RDI
CMP R8B,0x3f
CMOVC RDI,RCX
ADD RAX,RDI
ADD RSI,RDI
CMP RSI,RDX
JC 0x0013ebd4
POP RBP
RET
LAB_0013ebfb:
XOR EAX,EAX
RET
|
long my_numcells_sjis(int8 param_1,byte *param_2,byte *param_3)
{
long lVar1;
long lVar2;
if (param_2 < param_3) {
lVar1 = 0;
do {
lVar2 = (ulong)(*param_2 >> 7) + 1;
if ((byte)(*param_2 + 0x5f) < 0x3f) {
lVar2 = 1;
}
lVar1 = lVar1 + lVar2;
param_2 = param_2 + lVar2;
} while (param_2 < param_3);
return lVar1;
}
return 0;
}
|
|
64,775 |
mi_update_blob_record
|
eloqsql/storage/myisam/mi_dynrec.c
|
int _mi_update_blob_record(MI_INFO *info, my_off_t pos, const uchar *record)
{
uchar *rec_buff;
int error;
ulong reclength,extra;
extra= (ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
MI_DYN_DELETE_BLOCK_HEADER);
reclength= (info->s->base.pack_reclength+
_mi_calc_total_blob_length(info,record)+ extra);
if (!(rec_buff=(uchar*) my_alloca(reclength)))
{
my_errno= HA_ERR_OUT_OF_MEM; /* purecov: inspected */
return(-1);
}
reclength=_mi_rec_pack(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
record);
error=update_dynamic_record(info,pos,
rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
reclength);
my_afree(rec_buff);
return(error);
}
|
O0
|
c
|
mi_update_blob_record:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x5c, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x148(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa88d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
addq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0xf3860
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xa89ea
callq 0xf60c0
movl $0x80, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa8a30
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
callq 0xa7940
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x18, %rdx
movq -0x38(%rbp), %rcx
callq 0xa8070
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0xf3be0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
_mi_update_blob_record:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_40], 5Ch ; '\'
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+148h]
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call _mi_calc_total_blob_length
mov rcx, rax
mov rax, [rbp+var_48]
add rax, rcx
add rax, [rbp+var_40]
mov [rbp+var_38], rax
mov rsi, [rbp+var_38]
xor edi, edi
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_A89EA
call _my_thread_var
mov dword ptr [rax], 80h
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_A8A30
loc_A89EA:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
add rsi, 18h
mov rdx, [rbp+var_20]
call _mi_rec_pack
mov eax, eax
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
add rdx, 18h
mov rcx, [rbp+var_38]
call update_dynamic_record_0
mov [rbp+var_2C], eax
mov rdi, [rbp+var_28]
call my_free
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_A8A30:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long mi_update_blob_record(_QWORD *a1, long long a2, _BYTE *a3)
{
const char *v3; // rsi
long long v5; // [rsp+8h] [rbp-48h]
unsigned long long v6; // [rsp+18h] [rbp-38h]
unsigned int updated; // [rsp+24h] [rbp-2Ch]
long long v8; // [rsp+28h] [rbp-28h]
v5 = *(_QWORD *)(*a1 + 328LL);
v3 = (const char *)(mi_calc_total_blob_length(a1, (long long)a3) + v5 + 92);
v8 = my_malloc(0LL, v3, 0LL);
if ( v8 )
{
v6 = (unsigned int)mi_rec_pack(a1, (_BYTE *)(v8 + 24), a3);
updated = update_dynamic_record_0(a1, a2, v8 + 24, v6);
my_free(v8);
return updated;
}
else
{
*(_DWORD *)my_thread_var(0LL, v3) = 128;
return (unsigned int)-1;
}
}
|
_mi_update_blob_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x40],0x5c
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001a88d0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RCX
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
MOV RSI,qword ptr [RBP + -0x38]
XOR EDI,EDI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f3860
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x001a89ea
CALL 0x001f60c0
MOV dword ptr [RAX],0x80
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001a8a30
LAB_001a89ea:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001a7940
MOV EAX,EAX
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,0x18
MOV RCX,qword ptr [RBP + -0x38]
CALL 0x001a8070
MOV dword ptr [RBP + -0x2c],EAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001f3be0
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_001a8a30:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4 _mi_update_blob_record(long *param_1,int8 param_2,int8 param_3)
{
int4 uVar1;
long lVar2;
long lVar3;
int4 *puVar4;
int4 local_c;
lVar3 = *(long *)(*param_1 + 0x148);
lVar2 = _mi_calc_total_blob_length(param_1,param_3);
lVar3 = my_malloc(0,lVar3 + lVar2 + 0x5c,0);
if (lVar3 == 0) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x80;
local_c = 0xffffffff;
}
else {
uVar1 = _mi_rec_pack(param_1,lVar3 + 0x18,param_3);
local_c = update_dynamic_record(param_1,param_2,lVar3 + 0x18,uVar1);
my_free(lVar3);
}
return local_c;
}
|
|
64,776 |
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& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [5], 0>(char const (&) [5]) const
|
monkey531[P]llama/common/json.hpp
|
const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return it->second;
}
|
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> const& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [5], 0>(char const (&) [5]) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xa4e5f
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xa4e49
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a230
testl %eax, %eax
je 0xa4e3e
addq $0x30, %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
jne 0xa4e1f
jmp 0xa4e41
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
cmpq %rbx, %rax
je 0xa4ebd
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1a460
movq %rax, %rbx
movq %r14, %rdi
callq 0x5e9cc
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x4c081(%rip), %rsi # 0xf0f02
leaq 0x20(%rsp), %rdi
callq 0xaa855
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x861ba
xorl %ebp, %ebp
leaq 0x850ac(%rip), %rsi # 0x129f58
leaq -0x4a2b1(%rip), %rdx # 0x5ac02
movq %rbx, %rdi
callq 0x1af30
jmp 0xa4f36
movl $0x20, %edi
callq 0x1a460
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x1a400
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x21af4
leaq 0x4c040(%rip), %rsi # 0xf0f32
leaq 0x4c03f(%rip), %rcx # 0xf0f38
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xaae32
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0xab1aa
xorl %ebp, %ebp
leaq 0x84fb1(%rip), %rsi # 0x129ed8
leaq -0x4a32c(%rip), %rdx # 0x5ac02
movq %rbx, %rdi
callq 0x1af30
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4f54
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a8f0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa4f9f
movq 0x10(%rsp), %rsi
jmp 0xa4f97
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa4fa9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8f0
jmp 0xa4fa9
jmp 0xa4fa6
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4f9f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a8f0
testb %bpl, %bpl
jne 0xa4fa9
jmp 0xa4fb1
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a690
movq %r14, %rdi
callq 0x1afd0
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push r12; int
push rbx; char
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_A4E5F
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
mov rax, [r12+8]
cmp rbx, rax
jz short loc_A4E49
loc_A4E1F:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_A4E3E
add rbx, 30h ; '0'
mov rax, [r12+8]
cmp rbx, rax
jnz short loc_A4E1F
jmp short loc_A4E41
loc_A4E3E:
mov rax, rbx
loc_A4E41:
mov rcx, [r14+8]
mov rbx, [rcx+8]
loc_A4E49:
cmp rax, rbx
jz short loc_A4EBD
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A4E5F:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov rdx, rsp
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_A4F36
loc_A4EBD:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_58]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
mov rdi, rsp
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_A4F36:
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A4F54
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A4F54:
mov rdi, [rsp+68h+var_68]
cmp rdi, r12
jz short loc_A4F9F
mov rsi, [rsp+68h+var_58]
jmp short loc_A4F97
mov r14, rax
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r12
jz short loc_A4FA9
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A4FA9
jmp short loc_A4FA6
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A4F9F
mov rsi, [rsp+68h+var_38]
loc_A4F97:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A4F9F:
test bpl, bpl
jnz short loc_A4FA9
jmp short loc_A4FB1
loc_A4FA6:
mov r14, rax
loc_A4FA9:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A4FB1:
mov rdi, r14
call __Unwind_Resume
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x001a4e5f
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x001a4e49
LAB_001a4e1f:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a230
TEST EAX,EAX
JZ 0x001a4e3e
ADD RBX,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JNZ 0x001a4e1f
JMP 0x001a4e41
LAB_001a4e3e:
MOV RAX,RBX
LAB_001a4e41:
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
LAB_001a4e49:
CMP RAX,RBX
JZ 0x001a4ebd
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001a4e5f:
MOV EDI,0x20
CALL 0x0011a460
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015e9cc
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LAB_001a4e7a:
LEA RSI,[0x1f0f02]
LEA RDI,[RSP + 0x20]
CALL 0x001aa855
MOV BPL,0x1
LAB_001a4e8e:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x001861ba
XOR EBP,EBP
LEA RSI,[0x229f58]
LEA RDX,[0x15ac02]
MOV RDI,RBX
CALL 0x0011af30
LAB_001a4ebd:
MOV EDI,0x20
CALL 0x0011a460
MOV RBX,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x0011a400
LEA RDX,[RAX + R15*0x1]
LAB_001a4ee0:
MOV RDI,RSP
MOV RSI,R15
CALL 0x00121af4
LAB_001a4eeb:
LEA RSI,[0x1f0f32]
LEA RCX,[0x1f0f38]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001aae32
MOV BPL,0x1
LAB_001a4f09:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x001ab1aa
XOR EBP,EBP
LEA RSI,[0x229ed8]
LEA RDX,[0x15ac02]
MOV RDI,RBX
CALL 0x0011af30
|
char * _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2)
{
long *plVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
char *local_68 [2];
char local_58 [16];
detail local_48 [32];
if (*param_1 !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_1);
/* try { // try from 001a4e7a to 001a4e8a has its CatchHandler @ 001a4fa6 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_48,"cannot use at() with ",local_68);
/* try { // try from 001a4e8e to 001a4eba has its CatchHandler @ 001a4f81 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x130,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
plVar1 = *(long **)(param_1 + 8);
pcVar6 = (char *)*plVar1;
pcVar3 = (char *)plVar1[1];
if (pcVar6 != pcVar3) {
do {
pcVar3 = pcVar6;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar6 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar6 != pcVar3);
pcVar6 = *(char **)(*(long *)(param_1 + 8) + 8);
}
if (pcVar3 == pcVar6) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
sVar5 = strlen(param_2);
/* try { // try from 001a4ee0 to 001a4eea has its CatchHandler @ 001a4f7f */
std::__cxx11::string::_M_construct<char_const*>(local_68,param_2,param_2 + sVar5);
/* try { // try from 001a4eeb to 001a4f05 has its CatchHandler @ 001a4f64 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_48,"key \'",(string *)local_68,"\' not found");
/* try { // try from 001a4f09 to 001a4f35 has its CatchHandler @ 001a4f36 */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x193,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return pcVar3 + 0x20;
}
|
||
64,777 |
reset_connection
|
eloqsql/libmariadb/unittest/libmariadb/my_test.h
|
static int reset_connection(MYSQL *mysql) {
int rc;
if (is_mariadb && !IS_MAXSCALE())
rc= mysql_change_user(mysql, username, password, schema);
else
rc= mysql_reset_connection(mysql);
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "SET sql_mode=''");
check_mysql_rc(rc, mysql);
return OK;
}
|
O0
|
c
|
reset_connection:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movzbl 0x4f81e(%rip), %eax # 0x645e1
cmpl $0x0, %eax
je 0x14e6f
cmpq $0x0, 0x4f68c(%rip) # 0x64460
je 0x14df7
movq 0x4f683(%rip), %rdi # 0x64460
callq 0x25440
movq %rax, %rdi
leaq 0x39b89(%rip), %rsi # 0x4e975
callq 0x13100
cmpq $0x0, %rax
jne 0x14e6f
leaq 0x39722(%rip), %rdi # 0x4e520
callq 0x13540
cmpq $0x0, %rax
je 0x14e49
leaq 0x39710(%rip), %rdi # 0x4e520
callq 0x13540
movq %rax, %rdi
leaq 0x39fbd(%rip), %rsi # 0x4eddc
callq 0x135f0
cmpl $0x0, %eax
je 0x14e6f
leaq 0x396f0(%rip), %rdi # 0x4e520
callq 0x13540
movq %rax, %rdi
leaq 0x39b3f(%rip), %rsi # 0x4e97e
callq 0x135f0
cmpl $0x0, %eax
je 0x14e6f
movq -0x10(%rbp), %rdi
movq 0x4f754(%rip), %rsi # 0x645a8
movq 0x4f755(%rip), %rdx # 0x645b0
movq 0x4f756(%rip), %rcx # 0x645b8
callq 0x22a60
movsbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0x14e7b
movq -0x10(%rbp), %rdi
callq 0x27700
movl %eax, -0x14(%rbp)
jmp 0x14e7d
cmpl $0x0, -0x14(%rbp)
je 0x14ecc
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x268a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26870
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
movl %eax, %ecx
leaq 0x3937c(%rip), %rdi # 0x4e22b
leaq 0x39258(%rip), %r8 # 0x4e10e
movl $0x238, %r9d # imm = 0x238
movb $0x0, %al
callq 0x187a0
movl $0x1, -0x4(%rbp)
jmp 0x14f39
jmp 0x14ece
movq -0x10(%rbp), %rdi
leaq 0x394a6(%rip), %rsi # 0x4e37f
callq 0x22f20
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x14f30
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x268a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26870
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rdx
movl %eax, %ecx
leaq 0x39318(%rip), %rdi # 0x4e22b
leaq 0x391f4(%rip), %r8 # 0x4e10e
movl $0x23a, %r9d # imm = 0x23A
movb $0x0, %al
callq 0x187a0
movl $0x1, -0x4(%rbp)
jmp 0x14f39
jmp 0x14f32
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
reset_connection:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
movzx eax, cs:is_mariadb
cmp eax, 0
jz loc_14E6F
cmp cs:mysql_default, 0
jz short loc_14DF7
mov rdi, cs:mysql_default
call mysql_get_server_info
mov rdi, rax
lea rsi, aMaxscale; "maxScale"
call _strstr
cmp rax, 0
jnz short loc_14E6F
loc_14DF7:
lea rdi, aSrv; "srv"
call _getenv
cmp rax, 0
jz short loc_14E49
lea rdi, aSrv; "srv"
call _getenv
mov rdi, rax
lea rsi, aTestDisabledWi+13h; "maxscale"
call _strcmp
cmp eax, 0
jz short loc_14E6F
lea rdi, aSrv; "srv"
call _getenv
mov rdi, rax
lea rsi, aSkysqlHa; "skysql-ha"
call _strcmp
cmp eax, 0
jz short loc_14E6F
loc_14E49:
mov rdi, [rbp+var_10]
mov rsi, cs:username
mov rdx, cs:password
mov rcx, cs:schema
call mysql_change_user
movsx eax, al
mov [rbp+var_14], eax
jmp short loc_14E7B
loc_14E6F:
mov rdi, [rbp+var_10]
call mysql_reset_connection
mov [rbp+var_14], eax
loc_14E7B:
jmp short $+2
loc_14E7D:
cmp [rbp+var_14], 0
jz short loc_14ECC
mov eax, [rbp+var_14]
mov [rbp+var_24], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_24]
mov rdx, [rbp+var_20]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 238h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_14F39
loc_14ECC:
jmp short $+2
loc_14ECE:
mov rdi, [rbp+var_10]
lea rsi, aSetSqlMode; "SET sql_mode=''"
call mysql_query
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jz short loc_14F30
mov eax, [rbp+var_14]
mov [rbp+var_34], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_34]
mov rdx, [rbp+var_30]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 23Ah
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_14F39
loc_14F30:
jmp short $+2
loc_14F32:
mov [rbp+var_4], 0
loc_14F39:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long reset_connection(long long a1)
{
long long server_info; // rax
long long v2; // rax
long long v3; // rax
int v4; // eax
int v5; // eax
int v7; // [rsp+10h] [rbp-30h]
int v8; // [rsp+20h] [rbp-20h]
int v9; // [rsp+2Ch] [rbp-14h]
int v10; // [rsp+2Ch] [rbp-14h]
if ( !is_mariadb
|| mysql_default && (server_info = mysql_get_server_info(mysql_default), strstr(server_info, "maxScale"))
|| getenv("srv")
&& ((v2 = getenv("srv"), !(unsigned int)strcmp(v2, "maxscale"))
|| (v3 = getenv("srv"), !(unsigned int)strcmp(v3, "skysql-ha"))) )
{
v9 = mysql_reset_connection(a1);
}
else
{
v9 = (char)mysql_change_user(a1, username, password, schema);
}
if ( v9 )
{
v8 = mysql_error(a1);
v4 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v9,
v8,
v4,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",
568);
return 1;
}
else
{
v10 = mysql_query(a1, "SET sql_mode=''");
if ( v10 )
{
v7 = mysql_error(a1);
v5 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v10,
v7,
v5,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",
570);
return 1;
}
else
{
return 0;
}
}
}
|
reset_connection:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOVZX EAX,byte ptr [0x001645e1]
CMP EAX,0x0
JZ 0x00114e6f
CMP qword ptr [0x00164460],0x0
JZ 0x00114df7
MOV RDI,qword ptr [0x00164460]
CALL 0x00125440
MOV RDI,RAX
LEA RSI,[0x14e975]
CALL 0x00113100
CMP RAX,0x0
JNZ 0x00114e6f
LAB_00114df7:
LEA RDI,[0x14e520]
CALL 0x00113540
CMP RAX,0x0
JZ 0x00114e49
LEA RDI,[0x14e520]
CALL 0x00113540
MOV RDI,RAX
LEA RSI,[0x14eddc]
CALL 0x001135f0
CMP EAX,0x0
JZ 0x00114e6f
LEA RDI,[0x14e520]
CALL 0x00113540
MOV RDI,RAX
LEA RSI,[0x14e97e]
CALL 0x001135f0
CMP EAX,0x0
JZ 0x00114e6f
LAB_00114e49:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [0x001645a8]
MOV RDX,qword ptr [0x001645b0]
MOV RCX,qword ptr [0x001645b8]
CALL 0x00122a60
MOVSX EAX,AL
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00114e7b
LAB_00114e6f:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00127700
MOV dword ptr [RBP + -0x14],EAX
LAB_00114e7b:
JMP 0x00114e7d
LAB_00114e7d:
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00114ecc
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001268a0
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00126870
MOV ESI,dword ptr [RBP + -0x24]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,EAX
LEA RDI,[0x14e22b]
LEA R8,[0x14e10e]
MOV R9D,0x238
MOV AL,0x0
CALL 0x001187a0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00114f39
LAB_00114ecc:
JMP 0x00114ece
LAB_00114ece:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x14e37f]
CALL 0x00122f20
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00114f30
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x34],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001268a0
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00126870
MOV ESI,dword ptr [RBP + -0x34]
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,EAX
LEA RDI,[0x14e22b]
LEA R8,[0x14e10e]
MOV R9D,0x23a
MOV AL,0x0
CALL 0x001187a0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00114f39
LAB_00114f30:
JMP 0x00114f32
LAB_00114f32:
MOV dword ptr [RBP + -0x4],0x0
LAB_00114f39:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 reset_connection(int8 param_1)
{
char cVar1;
int iVar2;
int4 uVar3;
char *pcVar4;
int8 uVar5;
int local_1c;
int4 local_c;
if (is_mariadb != '\0') {
if (mysql_default != 0) {
pcVar4 = (char *)mysql_get_server_info(mysql_default);
pcVar4 = strstr(pcVar4,"maxScale");
if (pcVar4 != (char *)0x0) goto LAB_00114e6f;
}
pcVar4 = getenv("srv");
if (pcVar4 == (char *)0x0) {
LAB_00114e49:
cVar1 = mysql_change_user(param_1,username,password,schema);
local_1c = (int)cVar1;
goto LAB_00114e7b;
}
pcVar4 = getenv("srv");
iVar2 = strcmp(pcVar4,"maxscale");
if (iVar2 != 0) {
pcVar4 = getenv("srv");
iVar2 = strcmp(pcVar4,"skysql-ha");
if (iVar2 != 0) goto LAB_00114e49;
}
}
LAB_00114e6f:
local_1c = mysql_reset_connection(param_1);
LAB_00114e7b:
if (local_1c == 0) {
iVar2 = mysql_query(param_1,"SET sql_mode=\'\'");
if (iVar2 == 0) {
local_c = 0;
}
else {
uVar5 = mysql_error(param_1);
uVar3 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar5,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",0x23a
);
local_c = 1;
}
}
else {
uVar5 = mysql_error(param_1);
uVar3 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",local_1c,uVar5,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",0x238);
local_c = 1;
}
return local_c;
}
|
|
64,778 |
get_internal_charset
|
eloqsql/mysys/charset.c
|
static CHARSET_INFO *
get_internal_charset(MY_CHARSET_LOADER *loader, uint cs_number, myf flags)
{
char buf[FN_REFLEN];
struct charset_info_st *cs;
DBUG_ASSERT(cs_number < array_elements(all_charsets));
if ((cs= (struct charset_info_st*) all_charsets[cs_number]))
{
if (cs->state & MY_CS_READY) /* if CS is already initialized */
{
my_collation_statistics_inc_use_count(cs_number);
return cs;
}
/*
To make things thread safe we are not allowing other threads to interfere
while we may changing the cs_info_table
*/
mysql_mutex_lock(&THR_LOCK_charset);
if (!(cs->state & (MY_CS_COMPILED|MY_CS_LOADED))) /* if CS is not in memory */
{
MY_CHARSET_LOADER loader;
strxmov(get_charsets_dir(buf), cs->cs_name.str, ".xml", NullS);
my_charset_loader_init_mysys(&loader);
my_read_charset_file(&loader, buf, flags);
}
if (cs->state & MY_CS_AVAILABLE)
{
if (!(cs->state & MY_CS_READY))
{
if (!simple_8bit_charset_data_is_full(cs))
{
CHARSET_INFO *refcs= find_charset_data_inheritance_source(cs);
if (refcs)
inherit_charset_data(cs, refcs);
}
if (!simple_8bit_collation_data_is_full(cs))
{
CHARSET_INFO *refcl= find_collation_data_inheritance_source(cs, flags);
if (refcl)
inherit_collation_data(cs, refcl);
}
if (my_ci_init_charset(cs, loader) ||
my_ci_init_collation(cs, loader))
{
cs= NULL;
}
else
cs->state|= MY_CS_READY;
}
my_collation_statistics_inc_use_count(cs_number);
}
else
cs= NULL;
mysql_mutex_unlock(&THR_LOCK_charset);
}
return cs;
}
|
O0
|
c
|
get_internal_charset:
pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x2d0(%rbp)
movl %esi, -0x2d4(%rbp)
movq %rdx, -0x2e0(%rbp)
jmp 0xa8c6e
movl -0x2d4(%rbp), %eax
movl %eax, %ecx
leaq 0xb9a4c3(%rip), %rax # 0xc43140
movq (%rax,%rcx,8), %rax
movq %rax, -0x2e8(%rbp)
cmpq $0x0, %rax
je 0xa8e77
movq -0x2e8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x100, %eax # imm = 0x100
cmpl $0x0, %eax
je 0xa8cc4
movl -0x2d4(%rbp), %edi
callq 0xaa5d0
movq -0x2e8(%rbp), %rax
movq %rax, -0x2c8(%rbp)
jmp 0xa8e85
leaq 0xba3535(%rip), %rdi # 0xc4c200
leaq 0x7748f(%rip), %rsi # 0x120161
movl $0x36b, %edx # imm = 0x36B
callq 0xaa600
movq -0x2e8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x9, %eax
cmpl $0x0, %eax
jne 0xa8d40
leaq -0x210(%rbp), %rdi
callq 0xa82b0
movq %rax, %rdi
movq -0x2e8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x77435(%rip), %rdx # 0x120144
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x11b450
leaq -0x2c0(%rbp), %rdi
callq 0xa7c10
leaq -0x210(%rbp), %rsi
movq -0x2e0(%rbp), %rdx
leaq -0x2c0(%rbp), %rdi
callq 0xaa150
movq -0x2e8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x200, %eax # imm = 0x200
cmpl $0x0, %eax
je 0xa8e60
movq -0x2e8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x100, %eax # imm = 0x100
cmpl $0x0, %eax
jne 0xa8e53
movq -0x2e8(%rbp), %rdi
callq 0xaa070
cmpb $0x0, %al
jne 0xa8db2
movq -0x2e8(%rbp), %rdi
callq 0xaa670
movq %rax, -0x2f0(%rbp)
cmpq $0x0, -0x2f0(%rbp)
je 0xa8db0
movq -0x2e8(%rbp), %rdi
movq -0x2f0(%rbp), %rsi
callq 0xaa6b0
jmp 0xa8db2
movq -0x2e8(%rbp), %rdi
callq 0xaa0d0
cmpb $0x0, %al
jne 0xa8dfb
movq -0x2e8(%rbp), %rdi
movq -0x2e0(%rbp), %rsi
callq 0xaa730
movq %rax, -0x2f8(%rbp)
cmpq $0x0, -0x2f8(%rbp)
je 0xa8df9
movq -0x2e8(%rbp), %rdi
movq -0x2f8(%rbp), %rsi
callq 0xaa840
jmp 0xa8dfb
movq -0x2e8(%rbp), %rdi
movq -0x2d0(%rbp), %rsi
callq 0xaa880
movsbl %al, %eax
cmpl $0x0, %eax
jne 0xa8e31
movq -0x2e8(%rbp), %rdi
movq -0x2d0(%rbp), %rsi
callq 0xaa8d0
movsbl %al, %eax
cmpl $0x0, %eax
je 0xa8e3e
movq $0x0, -0x2e8(%rbp)
jmp 0xa8e51
movq -0x2e8(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x100, %ecx # imm = 0x100
movl %ecx, 0xc(%rax)
jmp 0xa8e53
movl -0x2d4(%rbp), %edi
callq 0xaa5d0
jmp 0xa8e6b
movq $0x0, -0x2e8(%rbp)
leaq 0xba338e(%rip), %rdi # 0xc4c200
callq 0xaa920
movq -0x2e8(%rbp), %rax
movq %rax, -0x2c8(%rbp)
movq -0x2c8(%rbp), %rax
movq %rax, -0x300(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xa8eb5
movq -0x300(%rbp), %rax
addq $0x300, %rsp # imm = 0x300
popq %rbp
retq
callq 0x272b0
nopw (%rax,%rax)
|
get_internal_charset:
push rbp
mov rbp, rsp
sub rsp, 300h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_2D0], rdi
mov [rbp+var_2D4], esi
mov [rbp+var_2E0], rdx
jmp short $+2
loc_A8C6E:
mov eax, [rbp+var_2D4]
mov ecx, eax
lea rax, all_charsets
mov rax, [rax+rcx*8]
mov [rbp+var_2E8], rax
cmp rax, 0
jz loc_A8E77
mov rax, [rbp+var_2E8]
mov eax, [rax+0Ch]
and eax, 100h
cmp eax, 0
jz short loc_A8CC4
mov edi, [rbp+var_2D4]
call my_collation_statistics_inc_use_count
mov rax, [rbp+var_2E8]
mov [rbp+var_2C8], rax
jmp loc_A8E85
loc_A8CC4:
lea rdi, THR_LOCK_charset
lea rsi, aWorkspaceLlm4b_25; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 36Bh
call inline_mysql_mutex_lock_15
mov rax, [rbp+var_2E8]
mov eax, [rax+0Ch]
and eax, 9
cmp eax, 0
jnz short loc_A8D40
lea rdi, [rbp+var_210]
call get_charsets_dir
mov rdi, rax
mov rax, [rbp+var_2E8]
mov rsi, [rax+10h]
lea rdx, aIndexXml+5; ".xml"
xor eax, eax
mov ecx, eax
mov al, 0
call strxmov
lea rdi, [rbp+var_2C0]
call my_charset_loader_init_mysys
lea rsi, [rbp+var_210]
mov rdx, [rbp+var_2E0]
lea rdi, [rbp+var_2C0]
call my_read_charset_file
loc_A8D40:
mov rax, [rbp+var_2E8]
mov eax, [rax+0Ch]
and eax, 200h
cmp eax, 0
jz loc_A8E60
mov rax, [rbp+var_2E8]
mov eax, [rax+0Ch]
and eax, 100h
cmp eax, 0
jnz loc_A8E53
mov rdi, [rbp+var_2E8]
call simple_8bit_charset_data_is_full
cmp al, 0
jnz short loc_A8DB2
mov rdi, [rbp+var_2E8]
call find_charset_data_inheritance_source
mov [rbp+var_2F0], rax
cmp [rbp+var_2F0], 0
jz short loc_A8DB0
mov rdi, [rbp+var_2E8]
mov rsi, [rbp+var_2F0]
call inherit_charset_data
loc_A8DB0:
jmp short $+2
loc_A8DB2:
mov rdi, [rbp+var_2E8]
call simple_8bit_collation_data_is_full
cmp al, 0
jnz short loc_A8DFB
mov rdi, [rbp+var_2E8]
mov rsi, [rbp+var_2E0]
call find_collation_data_inheritance_source
mov [rbp+var_2F8], rax
cmp [rbp+var_2F8], 0
jz short loc_A8DF9
mov rdi, [rbp+var_2E8]
mov rsi, [rbp+var_2F8]
call inherit_collation_data
loc_A8DF9:
jmp short $+2
loc_A8DFB:
mov rdi, [rbp+var_2E8]
mov rsi, [rbp+var_2D0]
call my_ci_init_charset
movsx eax, al
cmp eax, 0
jnz short loc_A8E31
mov rdi, [rbp+var_2E8]
mov rsi, [rbp+var_2D0]
call my_ci_init_collation
movsx eax, al
cmp eax, 0
jz short loc_A8E3E
loc_A8E31:
mov [rbp+var_2E8], 0
jmp short loc_A8E51
loc_A8E3E:
mov rax, [rbp+var_2E8]
mov ecx, [rax+0Ch]
or ecx, 100h
mov [rax+0Ch], ecx
loc_A8E51:
jmp short $+2
loc_A8E53:
mov edi, [rbp+var_2D4]
call my_collation_statistics_inc_use_count
jmp short loc_A8E6B
loc_A8E60:
mov [rbp+var_2E8], 0
loc_A8E6B:
lea rdi, THR_LOCK_charset
call inline_mysql_mutex_unlock_16
loc_A8E77:
mov rax, [rbp+var_2E8]
mov [rbp+var_2C8], rax
loc_A8E85:
mov rax, [rbp+var_2C8]
mov [rbp+var_300], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_A8EB5
mov rax, [rbp+var_300]
add rsp, 300h
pop rbp
retn
loc_A8EB5:
call ___stack_chk_fail
|
long long get_internal_charset(long long a1, unsigned int a2, long long a3)
{
int charsets_dir; // eax
int v4; // r8d
int v5; // r9d
long long collation_data_inheritance_source; // [rsp+8h] [rbp-2F8h]
long long charset_data_inheritance_source; // [rsp+10h] [rbp-2F0h]
long long v9; // [rsp+18h] [rbp-2E8h]
_BYTE v12[176]; // [rsp+40h] [rbp-2C0h] BYREF
_BYTE v13[520]; // [rsp+F0h] [rbp-210h] BYREF
unsigned long long v14; // [rsp+2F8h] [rbp-8h]
v14 = __readfsqword(0x28u);
v9 = all_charsets[a2];
if ( !v9 )
return v9;
if ( (*(_DWORD *)(v9 + 12) & 0x100) == 0 )
{
inline_mysql_mutex_lock_15(&THR_LOCK_charset, "/workspace/llm4binary/github2025/eloqsql/mysys/charset.c", 875LL);
if ( (*(_DWORD *)(v9 + 12) & 9) == 0 )
{
charsets_dir = get_charsets_dir((long long)v13);
strxmov(charsets_dir, *(_QWORD *)(v9 + 16), (unsigned int)".xml", 0, v4, v5);
my_charset_loader_init_mysys((long long)v12);
my_read_charset_file(v12, v13, a3);
}
if ( (*(_DWORD *)(v9 + 12) & 0x200) != 0 )
{
if ( (*(_DWORD *)(v9 + 12) & 0x100) == 0 )
{
if ( !(unsigned __int8)simple_8bit_charset_data_is_full(v9) )
{
charset_data_inheritance_source = find_charset_data_inheritance_source(v9);
if ( charset_data_inheritance_source )
inherit_charset_data(v9, charset_data_inheritance_source);
}
if ( !(unsigned __int8)simple_8bit_collation_data_is_full(v9) )
{
collation_data_inheritance_source = find_collation_data_inheritance_source(v9, a3);
if ( collation_data_inheritance_source )
inherit_collation_data(v9, collation_data_inheritance_source);
}
if ( (unsigned __int8)my_ci_init_charset(v9, a1) || (unsigned __int8)my_ci_init_collation(v9, a1) )
v9 = 0LL;
else
*(_DWORD *)(v9 + 12) |= 0x100u;
}
my_collation_statistics_inc_use_count(a2);
}
else
{
v9 = 0LL;
}
inline_mysql_mutex_unlock_16(&THR_LOCK_charset);
return v9;
}
my_collation_statistics_inc_use_count(a2);
return v9;
}
|
get_internal_charset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x300
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x2d0],RDI
MOV dword ptr [RBP + -0x2d4],ESI
MOV qword ptr [RBP + -0x2e0],RDX
JMP 0x001a8c6e
LAB_001a8c6e:
MOV EAX,dword ptr [RBP + -0x2d4]
MOV ECX,EAX
LEA RAX,[0xd43140]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x2e8],RAX
CMP RAX,0x0
JZ 0x001a8e77
MOV RAX,qword ptr [RBP + -0x2e8]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x100
CMP EAX,0x0
JZ 0x001a8cc4
MOV EDI,dword ptr [RBP + -0x2d4]
CALL 0x001aa5d0
MOV RAX,qword ptr [RBP + -0x2e8]
MOV qword ptr [RBP + -0x2c8],RAX
JMP 0x001a8e85
LAB_001a8cc4:
LEA RDI,[0xd4c200]
LEA RSI,[0x220161]
MOV EDX,0x36b
CALL 0x001aa600
MOV RAX,qword ptr [RBP + -0x2e8]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x9
CMP EAX,0x0
JNZ 0x001a8d40
LEA RDI,[RBP + -0x210]
CALL 0x001a82b0
MOV RDI,RAX
MOV RAX,qword ptr [RBP + -0x2e8]
MOV RSI,qword ptr [RAX + 0x10]
LEA RDX,[0x220144]
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x0021b450
LEA RDI,[RBP + -0x2c0]
CALL 0x001a7c10
LEA RSI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x2e0]
LEA RDI,[RBP + -0x2c0]
CALL 0x001aa150
LAB_001a8d40:
MOV RAX,qword ptr [RBP + -0x2e8]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x200
CMP EAX,0x0
JZ 0x001a8e60
MOV RAX,qword ptr [RBP + -0x2e8]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x100
CMP EAX,0x0
JNZ 0x001a8e53
MOV RDI,qword ptr [RBP + -0x2e8]
CALL 0x001aa070
CMP AL,0x0
JNZ 0x001a8db2
MOV RDI,qword ptr [RBP + -0x2e8]
CALL 0x001aa670
MOV qword ptr [RBP + -0x2f0],RAX
CMP qword ptr [RBP + -0x2f0],0x0
JZ 0x001a8db0
MOV RDI,qword ptr [RBP + -0x2e8]
MOV RSI,qword ptr [RBP + -0x2f0]
CALL 0x001aa6b0
LAB_001a8db0:
JMP 0x001a8db2
LAB_001a8db2:
MOV RDI,qword ptr [RBP + -0x2e8]
CALL 0x001aa0d0
CMP AL,0x0
JNZ 0x001a8dfb
MOV RDI,qword ptr [RBP + -0x2e8]
MOV RSI,qword ptr [RBP + -0x2e0]
CALL 0x001aa730
MOV qword ptr [RBP + -0x2f8],RAX
CMP qword ptr [RBP + -0x2f8],0x0
JZ 0x001a8df9
MOV RDI,qword ptr [RBP + -0x2e8]
MOV RSI,qword ptr [RBP + -0x2f8]
CALL 0x001aa840
LAB_001a8df9:
JMP 0x001a8dfb
LAB_001a8dfb:
MOV RDI,qword ptr [RBP + -0x2e8]
MOV RSI,qword ptr [RBP + -0x2d0]
CALL 0x001aa880
MOVSX EAX,AL
CMP EAX,0x0
JNZ 0x001a8e31
MOV RDI,qword ptr [RBP + -0x2e8]
MOV RSI,qword ptr [RBP + -0x2d0]
CALL 0x001aa8d0
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001a8e3e
LAB_001a8e31:
MOV qword ptr [RBP + -0x2e8],0x0
JMP 0x001a8e51
LAB_001a8e3e:
MOV RAX,qword ptr [RBP + -0x2e8]
MOV ECX,dword ptr [RAX + 0xc]
OR ECX,0x100
MOV dword ptr [RAX + 0xc],ECX
LAB_001a8e51:
JMP 0x001a8e53
LAB_001a8e53:
MOV EDI,dword ptr [RBP + -0x2d4]
CALL 0x001aa5d0
JMP 0x001a8e6b
LAB_001a8e60:
MOV qword ptr [RBP + -0x2e8],0x0
LAB_001a8e6b:
LEA RDI,[0xd4c200]
CALL 0x001aa920
LAB_001a8e77:
MOV RAX,qword ptr [RBP + -0x2e8]
MOV qword ptr [RBP + -0x2c8],RAX
LAB_001a8e85:
MOV RAX,qword ptr [RBP + -0x2c8]
MOV qword ptr [RBP + -0x300],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001a8eb5
MOV RAX,qword ptr [RBP + -0x300]
ADD RSP,0x300
POP RBP
RET
LAB_001a8eb5:
CALL 0x001272b0
|
long get_internal_charset(int8 param_1,uint param_2,int8 param_3)
{
char cVar1;
int8 uVar2;
long lVar3;
long in_FS_OFFSET;
long local_2f0;
int1 local_2c8 [176];
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2f0 = (&all_charsets)[param_2];
if (local_2f0 != 0) {
if ((*(uint *)(local_2f0 + 0xc) & 0x100) == 0) {
inline_mysql_mutex_lock
(THR_LOCK_charset,"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",0x36b);
if ((*(uint *)(local_2f0 + 0xc) & 9) == 0) {
uVar2 = get_charsets_dir(local_218);
strxmov(uVar2,*(int8 *)(local_2f0 + 0x10),".xml",0);
my_charset_loader_init_mysys(local_2c8);
my_read_charset_file(local_2c8,local_218,param_3);
}
if ((*(uint *)(local_2f0 + 0xc) & 0x200) == 0) {
local_2f0 = 0;
}
else {
if ((*(uint *)(local_2f0 + 0xc) & 0x100) == 0) {
cVar1 = simple_8bit_charset_data_is_full(local_2f0);
if ((cVar1 == '\0') &&
(lVar3 = find_charset_data_inheritance_source(local_2f0), lVar3 != 0)) {
inherit_charset_data(local_2f0,lVar3);
}
cVar1 = simple_8bit_collation_data_is_full(local_2f0);
if ((cVar1 == '\0') &&
(lVar3 = find_collation_data_inheritance_source(local_2f0,param_3), lVar3 != 0)) {
inherit_collation_data(local_2f0,lVar3);
}
cVar1 = my_ci_init_charset(local_2f0,param_1);
if ((cVar1 == '\0') && (cVar1 = my_ci_init_collation(local_2f0,param_1), cVar1 == '\0')) {
*(uint *)(local_2f0 + 0xc) = *(uint *)(local_2f0 + 0xc) | 0x100;
}
else {
local_2f0 = 0;
}
}
my_collation_statistics_inc_use_count(param_2);
}
inline_mysql_mutex_unlock(THR_LOCK_charset);
}
else {
my_collation_statistics_inc_use_count(param_2);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_2f0;
}
|
|
64,779 |
js_agent_broadcast
|
bluesky950520[P]quickjs/run-test262.c
|
static JSValue js_agent_broadcast(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
ThreadLocalStorage *tls = JS_GetRuntimeOpaque(JS_GetRuntime(ctx));
JSValue sab = argv[0];
struct list_head *el;
Test262Agent *agent;
uint8_t *buf;
size_t buf_size;
int32_t val;
if (JS_GetContextOpaque(ctx) != NULL)
return JS_ThrowTypeError(ctx, "cannot be called inside an agent");
buf = JS_GetArrayBuffer(ctx, &buf_size, sab);
if (!buf)
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &val, argv[1]))
return JS_EXCEPTION;
/* broadcast the values and wait until all agents have started
calling their callbacks */
js_mutex_lock(&tls->agent_mutex);
list_for_each(el, &tls->agent_list) {
agent = list_entry(el, Test262Agent, link);
agent->broadcast_pending = TRUE;
/* the shared array buffer is used by the thread, so increment
its refcount */
agent->broadcast_sab = JS_DupValue(ctx, sab);
agent->broadcast_sab_buf = buf;
agent->broadcast_sab_size = buf_size;
agent->broadcast_val = val;
}
js_cond_broadcast(&tls->agent_cond);
while (is_broadcast_pending(tls)) {
js_cond_wait(&tls->agent_cond, &tls->agent_mutex);
}
js_mutex_unlock(&tls->agent_mutex);
return JS_UNDEFINED;
}
|
O0
|
c
|
js_agent_broadcast:
subq $0x98, %rsp
movq %rsi, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
movq %rdi, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq %r8, 0x60(%rsp)
movq 0x70(%rsp), %rdi
callq 0x2e1f0
movq %rax, %rdi
callq 0x299e0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0x2dca0
cmpq $0x0, %rax
je 0x153e7
movq 0x70(%rsp), %rdi
leaq 0xfa586(%rip), %rsi # 0x10f951
movb $0x0, %al
callq 0x335f0
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
jmp 0x1557b
movq 0x70(%rsp), %rdi
movq 0x48(%rsp), %rdx
movq 0x50(%rsp), %rcx
leaq 0x28(%rsp), %rsi
callq 0x5e300
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x15429
movl $0x0, 0x88(%rsp)
movq $0x6, 0x90(%rsp)
jmp 0x1557b
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
leaq 0x24(%rsp), %rsi
callq 0x3f210
cmpl $0x0, %eax
je 0x15466
movl $0x0, 0x88(%rsp)
movq $0x6, 0x90(%rsp)
jmp 0x1557b
movq 0x58(%rsp), %rdi
callq 0x27220
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x58(%rsp), %rcx
addq $0x58, %rcx
cmpq %rcx, %rax
je 0x15528
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl $0x1, 0x30(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x27980
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x50(%rax)
movl 0x24(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x58(%rax)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x1547e
movq 0x58(%rsp), %rdi
addq $0x28, %rdi
callq 0x27310
movq 0x58(%rsp), %rdi
callq 0x16050
cmpl $0x0, %eax
je 0x1555a
movq 0x58(%rsp), %rdi
addq $0x28, %rdi
movq 0x58(%rsp), %rsi
callq 0x27330
jmp 0x15536
movq 0x58(%rsp), %rdi
callq 0x27240
movl $0x0, 0x88(%rsp)
movq $0x3, 0x90(%rsp)
movq 0x88(%rsp), %rax
movq 0x90(%rsp), %rdx
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_agent_broadcast:
sub rsp, 98h
mov [rsp+98h+var_20], rsi
mov [rsp+98h+var_18], rdx
mov [rsp+98h+var_28], rdi
mov [rsp+98h+var_2C], ecx
mov [rsp+98h+var_38], r8
mov rdi, [rsp+98h+var_28]
call JS_GetRuntime
mov rdi, rax
call JS_GetRuntimeOpaque
mov [rsp+98h+var_40], rax
mov rax, [rsp+98h+var_38]
mov rcx, [rax]
mov [rsp+98h+var_50], rcx
mov rax, [rax+8]
mov [rsp+98h+var_48], rax
mov rdi, [rsp+98h+var_28]
call JS_GetContextOpaque
cmp rax, 0
jz short loc_153E7
mov rdi, [rsp+98h+var_28]
lea rsi, aCannotBeCalled; "cannot be called inside an agent"
mov al, 0
call JS_ThrowTypeError
mov [rsp+98h+var_10], rax
mov [rsp+98h+var_8], rdx
jmp loc_1557B
loc_153E7:
mov rdi, [rsp+98h+var_28]
mov rdx, [rsp+98h+var_50]
mov rcx, [rsp+98h+var_48]
lea rsi, [rsp+98h+var_70]
call JS_GetArrayBuffer
mov [rsp+98h+var_68], rax
cmp [rsp+98h+var_68], 0
jnz short loc_15429
mov dword ptr [rsp+98h+var_10], 0
mov [rsp+98h+var_8], 6
jmp loc_1557B
loc_15429:
mov rdi, [rsp+98h+var_28]
mov rax, [rsp+98h+var_38]
mov rdx, [rax+10h]
mov rcx, [rax+18h]
lea rsi, [rsp+98h+var_74]
call JS_ToInt32
cmp eax, 0
jz short loc_15466
mov dword ptr [rsp+98h+var_10], 0
mov [rsp+98h+var_8], 6
jmp loc_1557B
loc_15466:
mov rdi, [rsp+98h+var_40]
call js_mutex_lock
mov rax, [rsp+98h+var_40]
mov rax, [rax+60h]
mov [rsp+98h+var_58], rax
loc_1547E:
mov rax, [rsp+98h+var_58]
mov rcx, [rsp+98h+var_40]
add rcx, 58h ; 'X'
cmp rax, rcx
jz loc_15528
mov rax, [rsp+98h+var_58]
mov [rsp+98h+var_60], rax
mov rax, [rsp+98h+var_60]
mov dword ptr [rax+30h], 1
mov rax, [rsp+98h+var_60]
mov [rsp+98h+var_90], rax
mov rdi, [rsp+98h+var_28]
mov rsi, [rsp+98h+var_50]
mov rdx, [rsp+98h+var_48]
call JS_DupValue
mov rcx, rax
mov rax, [rsp+98h+var_90]
mov [rsp+98h+var_88], rcx
mov [rsp+98h+var_80], rdx
mov rcx, [rsp+98h+var_88]
mov [rax+38h], rcx
mov rcx, [rsp+98h+var_80]
mov [rax+40h], rcx
mov rcx, [rsp+98h+var_68]
mov rax, [rsp+98h+var_60]
mov [rax+48h], rcx
mov rcx, [rsp+98h+var_70]
mov rax, [rsp+98h+var_60]
mov [rax+50h], rcx
mov ecx, [rsp+98h+var_74]
mov rax, [rsp+98h+var_60]
mov [rax+58h], ecx
mov rax, [rsp+98h+var_58]
mov rax, [rax+8]
mov [rsp+98h+var_58], rax
jmp loc_1547E
loc_15528:
mov rdi, [rsp+98h+var_40]
add rdi, 28h ; '('
call js_cond_broadcast
loc_15536:
mov rdi, [rsp+98h+var_40]
call is_broadcast_pending
cmp eax, 0
jz short loc_1555A
mov rdi, [rsp+98h+var_40]
add rdi, 28h ; '('
mov rsi, [rsp+98h+var_40]
call js_cond_wait
jmp short loc_15536
loc_1555A:
mov rdi, [rsp+98h+var_40]
call js_mutex_unlock
mov dword ptr [rsp+98h+var_10], 0
mov [rsp+98h+var_8], 3
loc_1557B:
mov rax, [rsp+98h+var_10]
mov rdx, [rsp+98h+var_8]
add rsp, 98h
retn
|
long long js_agent_broadcast(long long a1, long long a2, long long a3, int a4, int **a5)
{
long long Runtime; // rax
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // rdx
int *v11; // rsi
long long v12; // rdx
long long v13; // rdx
long long v15; // [rsp+8h] [rbp-90h]
int v16; // [rsp+24h] [rbp-74h] BYREF
long long v17; // [rsp+28h] [rbp-70h] BYREF
long long ArrayBuffer; // [rsp+30h] [rbp-68h]
long long v19; // [rsp+38h] [rbp-60h]
long long i; // [rsp+40h] [rbp-58h]
int *v21; // [rsp+48h] [rbp-50h]
int *v22; // [rsp+50h] [rbp-48h]
long long RuntimeOpaque; // [rsp+58h] [rbp-40h]
int **v24; // [rsp+60h] [rbp-38h]
int v25; // [rsp+6Ch] [rbp-2Ch]
long long v26; // [rsp+70h] [rbp-28h]
long long v27; // [rsp+78h] [rbp-20h]
long long v28; // [rsp+80h] [rbp-18h]
long long v29; // [rsp+88h] [rbp-10h]
long long v30; // [rsp+90h] [rbp-8h]
v27 = a2;
v28 = a3;
v26 = a1;
v25 = a4;
v24 = a5;
Runtime = JS_GetRuntime(a1);
RuntimeOpaque = JS_GetRuntimeOpaque(Runtime);
v21 = *v24;
v22 = v24[1];
if ( JS_GetContextOpaque(a1) )
{
v29 = JS_ThrowTypeError(v26, (unsigned int)"cannot be called inside an agent", v6, v7, v8, v9);
v30 = v10;
}
else
{
ArrayBuffer = JS_GetArrayBuffer(v26, &v17, v21, v22);
if ( ArrayBuffer )
{
v11 = &v16;
if ( (unsigned int)JS_ToInt32(v26, &v16, v24[2], v24[3]) )
{
LODWORD(v29) = 0;
v30 = 6LL;
}
else
{
js_mutex_lock(RuntimeOpaque);
for ( i = *(_QWORD *)(RuntimeOpaque + 96); i != RuntimeOpaque + 88; i = *(_QWORD *)(i + 8) )
{
v19 = i;
*(_DWORD *)(i + 48) = 1;
v15 = v19;
v11 = v21;
*(_QWORD *)(v15 + 56) = JS_DupValue(v26, v21, v22);
*(_QWORD *)(v15 + 64) = v12;
*(_QWORD *)(v19 + 72) = ArrayBuffer;
*(_QWORD *)(v19 + 80) = v17;
*(_DWORD *)(v19 + 88) = v16;
}
js_cond_broadcast(RuntimeOpaque + 40);
while ( (unsigned int)is_broadcast_pending(RuntimeOpaque) )
{
v11 = (int *)RuntimeOpaque;
js_cond_wait(RuntimeOpaque + 40, RuntimeOpaque);
}
js_mutex_unlock(RuntimeOpaque, v11, v13);
LODWORD(v29) = 0;
v30 = 3LL;
}
}
else
{
LODWORD(v29) = 0;
v30 = 6LL;
}
}
return v29;
}
|
js_agent_broadcast:
SUB RSP,0x98
MOV qword ptr [RSP + 0x78],RSI
MOV qword ptr [RSP + 0x80],RDX
MOV qword ptr [RSP + 0x70],RDI
MOV dword ptr [RSP + 0x6c],ECX
MOV qword ptr [RSP + 0x60],R8
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x0012e1f0
MOV RDI,RAX
CALL 0x001299e0
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0x48],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x50],RAX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x0012dca0
CMP RAX,0x0
JZ 0x001153e7
MOV RDI,qword ptr [RSP + 0x70]
LEA RSI,[0x20f951]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],RDX
JMP 0x0011557b
LAB_001153e7:
MOV RDI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x48]
MOV RCX,qword ptr [RSP + 0x50]
LEA RSI,[RSP + 0x28]
CALL 0x0015e300
MOV qword ptr [RSP + 0x30],RAX
CMP qword ptr [RSP + 0x30],0x0
JNZ 0x00115429
MOV dword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],0x6
JMP 0x0011557b
LAB_00115429:
MOV RDI,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RAX + 0x18]
LEA RSI,[RSP + 0x24]
CALL 0x0013f210
CMP EAX,0x0
JZ 0x00115466
MOV dword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],0x6
JMP 0x0011557b
LAB_00115466:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00127220
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RSP + 0x40],RAX
LAB_0011547e:
MOV RAX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x58]
ADD RCX,0x58
CMP RAX,RCX
JZ 0x00115528
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV dword ptr [RAX + 0x30],0x1
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x00127980
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x18],RDX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x40],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + 0x48],RCX
MOV RCX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + 0x50],RCX
MOV ECX,dword ptr [RSP + 0x24]
MOV RAX,qword ptr [RSP + 0x38]
MOV dword ptr [RAX + 0x58],ECX
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x40],RAX
JMP 0x0011547e
LAB_00115528:
MOV RDI,qword ptr [RSP + 0x58]
ADD RDI,0x28
CALL 0x00127310
LAB_00115536:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00116050
CMP EAX,0x0
JZ 0x0011555a
MOV RDI,qword ptr [RSP + 0x58]
ADD RDI,0x28
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00127330
JMP 0x00115536
LAB_0011555a:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00127240
MOV dword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],0x3
LAB_0011557b:
MOV RAX,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
ADD RSP,0x98
RET
|
int1 [16]
js_agent_broadcast(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int iVar1;
int8 uVar2;
long lVar3;
int1 auVar4 [16];
int4 local_74;
int8 local_70;
long local_68;
long local_60;
long local_58;
int8 local_50;
int8 local_48;
long local_40;
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
uVar2 = JS_GetRuntime(param_1);
local_40 = JS_GetRuntimeOpaque(uVar2);
local_50 = *local_38;
local_48 = local_38[1];
lVar3 = JS_GetContextOpaque(local_28);
if (lVar3 == 0) {
local_68 = JS_GetArrayBuffer(local_28,&local_70,local_50,local_48);
if (local_68 == 0) {
local_10 = 0;
local_8 = 6;
}
else {
iVar1 = JS_ToInt32(local_28,&local_74,local_38[2],local_38[3]);
if (iVar1 == 0) {
js_mutex_lock(local_40);
for (local_58 = *(long *)(local_40 + 0x60); lVar3 = local_58, local_58 != local_40 + 0x58;
local_58 = *(long *)(local_58 + 8)) {
local_60 = local_58;
*(int4 *)(local_58 + 0x30) = 1;
auVar4 = JS_DupValue(local_28,local_50,local_48);
*(int1 (*) [16])(lVar3 + 0x38) = auVar4;
*(long *)(local_60 + 0x48) = local_68;
*(int8 *)(local_60 + 0x50) = local_70;
*(int4 *)(local_60 + 0x58) = local_74;
}
js_cond_broadcast(local_40 + 0x28);
while( true ) {
iVar1 = is_broadcast_pending(local_40);
if (iVar1 == 0) break;
js_cond_wait(local_40 + 0x28,local_40);
}
js_mutex_unlock(local_40);
local_10 = 0;
local_8 = 3;
}
else {
local_10 = 0;
local_8 = 6;
}
}
}
else {
auVar4 = JS_ThrowTypeError(local_28,"cannot be called inside an agent");
local_8 = auVar4._8_8_;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
}
auVar4._4_4_ = uStack_c;
auVar4._0_4_ = local_10;
auVar4._8_8_ = local_8;
return auVar4;
}
|
|
64,780 |
js_agent_broadcast
|
bluesky950520[P]quickjs/run-test262.c
|
static JSValue js_agent_broadcast(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
ThreadLocalStorage *tls = JS_GetRuntimeOpaque(JS_GetRuntime(ctx));
JSValue sab = argv[0];
struct list_head *el;
Test262Agent *agent;
uint8_t *buf;
size_t buf_size;
int32_t val;
if (JS_GetContextOpaque(ctx) != NULL)
return JS_ThrowTypeError(ctx, "cannot be called inside an agent");
buf = JS_GetArrayBuffer(ctx, &buf_size, sab);
if (!buf)
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &val, argv[1]))
return JS_EXCEPTION;
/* broadcast the values and wait until all agents have started
calling their callbacks */
js_mutex_lock(&tls->agent_mutex);
list_for_each(el, &tls->agent_list) {
agent = list_entry(el, Test262Agent, link);
agent->broadcast_pending = TRUE;
/* the shared array buffer is used by the thread, so increment
its refcount */
agent->broadcast_sab = JS_DupValue(ctx, sab);
agent->broadcast_sab_buf = buf;
agent->broadcast_sab_size = buf_size;
agent->broadcast_val = val;
}
js_cond_broadcast(&tls->agent_cond);
while (is_broadcast_pending(tls)) {
js_cond_wait(&tls->agent_cond, &tls->agent_mutex);
}
js_mutex_unlock(&tls->agent_mutex);
return JS_UNDEFINED;
}
|
O2
|
c
|
js_agent_broadcast:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rdi, %r14
callq 0x1dd35
movq %rax, %rdi
callq 0x1b9a5
movq %rax, %r13
movq (%rbx), %r15
movq 0x8(%rbx), %r12
movq %r14, %rdi
callq 0x1da80
testq %rax, %rax
je 0x12d96
leaq 0x72bd2(%rip), %rsi # 0x85947
movq %r14, %rdi
xorl %eax, %eax
callq 0x201fd
movq %rdx, %r13
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %eax
jmp 0x12e7f
movq %r13, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
callq 0x35c68
pushq $0x6
popq %r13
testq %rax, %rax
je 0x12e7b
movq %rax, %rbp
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x25187
testl %eax, %eax
jne 0x12e7b
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a949
leaq 0x58(%rbx), %r13
addq $0x60, %rbx
movq %rbx, 0x18(%rsp)
movq (%rbx), %rbx
cmpq %r13, %rbx
je 0x12e34
movl $0x1, 0x30(%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1abab
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
movq %rbp, 0x48(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x58(%rbx)
addq $0x8, %rbx
jmp 0x12df5
movq 0x10(%rsp), %r14
movq %r14, %rbx
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x1a9de
movq 0x18(%rsp), %r15
movq %r15, %rax
movq (%rax), %rcx
cmpq %r13, %rcx
je 0x12e6f
leaq 0x8(%rcx), %rax
cmpl $0x0, 0x30(%rcx)
je 0x12e50
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a9ef
jmp 0x12e4d
movq %r14, %rdi
callq 0x1a95a
pushq $0x3
popq %r13
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
movq %r13, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_agent_broadcast:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, r8
mov r14, rdi
call JS_GetRuntime
mov rdi, rax
call JS_GetRuntimeOpaque
mov r13, rax
mov r15, [rbx]
mov r12, [rbx+8]
mov rdi, r14
call JS_GetContextOpaque
test rax, rax
jz short loc_12D96
lea rsi, aCannotBeCalled; "cannot be called inside an agent"
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
mov r13, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov eax, eax
jmp loc_12E7F
loc_12D96:
mov [rsp+58h+var_48], r13
lea rsi, [rsp+58h+var_38]
mov rdi, r14
mov rdx, r15
mov rcx, r12
call JS_GetArrayBuffer
push 6
pop r13
test rax, rax
jz loc_12E7B
mov rbp, rax
mov rdx, [rbx+10h]
mov rcx, [rbx+18h]
lea rsi, [rsp+58h+var_4C]
mov rdi, r14
call JS_ToInt32
test eax, eax
jnz loc_12E7B
mov rbx, [rsp+58h+var_48]
mov rdi, rbx
call js_mutex_lock
lea r13, [rbx+58h]
add rbx, 60h ; '`'
mov [rsp+58h+var_40], rbx
loc_12DF5:
mov rbx, [rbx]
cmp rbx, r13
jz short loc_12E34
mov dword ptr [rbx+30h], 1
mov rdi, r14
mov rsi, r15
mov rdx, r12
call JS_DupValue
mov [rbx+38h], rax
mov [rbx+40h], rdx
mov [rbx+48h], rbp
mov rax, [rsp+58h+var_38]
mov [rbx+50h], rax
mov eax, [rsp+58h+var_4C]
mov [rbx+58h], eax
add rbx, 8
jmp short loc_12DF5
loc_12E34:
mov r14, [rsp+58h+var_48]
mov rbx, r14
add rbx, 28h ; '('
mov rdi, rbx
call js_cond_broadcast
mov r15, [rsp+58h+var_40]
loc_12E4D:
mov rax, r15
loc_12E50:
mov rcx, [rax]
cmp rcx, r13
jz short loc_12E6F
lea rax, [rcx+8]
cmp dword ptr [rcx+30h], 0
jz short loc_12E50
mov rdi, rbx
mov rsi, r14
call js_cond_wait
jmp short loc_12E4D
loc_12E6F:
mov rdi, r14
call js_mutex_unlock
push 3
pop r13
loc_12E7B:
xor eax, eax
xor ecx, ecx
loc_12E7F:
or rax, rcx
mov rdx, r13
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long js_agent_broadcast(long long a1, long long a2, long long a3, long long a4, int **a5)
{
long long Runtime; // rax
long long RuntimeOpaque; // r13
int *v8; // r15
int *v9; // r12
int v10; // edx
int v11; // ecx
int v12; // r8d
int v13; // r9d
unsigned long long v14; // rcx
long long v15; // rax
long long ArrayBuffer; // rax
long long v17; // rbp
int *v18; // rsi
long long v19; // rbx
long long v20; // r13
long long *v21; // rbx
long long v22; // rbx
long long v23; // rdx
int *v24; // r14
long long v25; // rbx
long long v26; // rdx
long long *v27; // r15
long long *v28; // rax
long long v29; // rcx
int v31; // [rsp+Ch] [rbp-4Ch] BYREF
long long v32; // [rsp+10h] [rbp-48h]
long long *v33; // [rsp+18h] [rbp-40h]
long long v34[7]; // [rsp+20h] [rbp-38h] BYREF
Runtime = JS_GetRuntime(a1);
RuntimeOpaque = JS_GetRuntimeOpaque(Runtime);
v8 = *a5;
v9 = a5[1];
if ( JS_GetContextOpaque(a1) )
{
v15 = JS_ThrowTypeError(a1, (unsigned int)"cannot be called inside an agent", v10, v11, v12, v13);
v14 = v15 & 0xFFFFFFFF00000000LL;
v15 = (unsigned int)v15;
}
else
{
v32 = RuntimeOpaque;
ArrayBuffer = JS_GetArrayBuffer(a1, v34, v8, v9);
if ( ArrayBuffer )
{
v17 = ArrayBuffer;
v18 = &v31;
if ( !(unsigned int)JS_ToInt32(a1, &v31, a5[2], a5[3]) )
{
v19 = v32;
js_mutex_lock(v32);
v20 = v19 + 88;
v21 = (long long *)(v19 + 96);
v33 = v21;
while ( 1 )
{
v22 = *v21;
if ( v22 == v20 )
break;
*(_DWORD *)(v22 + 48) = 1;
v18 = v8;
*(_QWORD *)(v22 + 56) = JS_DupValue(a1, v8, v9);
*(_QWORD *)(v22 + 64) = v23;
*(_QWORD *)(v22 + 72) = v17;
*(_QWORD *)(v22 + 80) = v34[0];
*(_DWORD *)(v22 + 88) = v31;
v21 = (long long *)(v22 + 8);
}
v24 = (int *)v32;
v25 = v32 + 40;
js_cond_broadcast(v32 + 40);
v27 = v33;
LABEL_9:
v28 = v27;
while ( 1 )
{
v29 = *v28;
if ( *v28 == v20 )
break;
v28 = (long long *)(v29 + 8);
if ( *(_DWORD *)(v29 + 48) )
{
v18 = v24;
js_cond_wait(v25, v24);
goto LABEL_9;
}
}
js_mutex_unlock(v24, v18, v26);
}
}
v15 = 0LL;
v14 = 0LL;
}
return v14 | v15;
}
|
js_agent_broadcast:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,R8
MOV R14,RDI
CALL 0x0011dd35
MOV RDI,RAX
CALL 0x0011b9a5
MOV R13,RAX
MOV R15,qword ptr [RBX]
MOV R12,qword ptr [RBX + 0x8]
MOV RDI,R14
CALL 0x0011da80
TEST RAX,RAX
JZ 0x00112d96
LEA RSI,[0x185947]
MOV RDI,R14
XOR EAX,EAX
CALL 0x001201fd
MOV R13,RDX
MOV RCX,-0x100000000
AND RCX,RAX
MOV EAX,EAX
JMP 0x00112e7f
LAB_00112d96:
MOV qword ptr [RSP + 0x10],R13
LEA RSI,[RSP + 0x20]
MOV RDI,R14
MOV RDX,R15
MOV RCX,R12
CALL 0x00135c68
PUSH 0x6
POP R13
TEST RAX,RAX
JZ 0x00112e7b
MOV RBP,RAX
MOV RDX,qword ptr [RBX + 0x10]
MOV RCX,qword ptr [RBX + 0x18]
LEA RSI,[RSP + 0xc]
MOV RDI,R14
CALL 0x00125187
TEST EAX,EAX
JNZ 0x00112e7b
MOV RBX,qword ptr [RSP + 0x10]
MOV RDI,RBX
CALL 0x0011a949
LEA R13,[RBX + 0x58]
ADD RBX,0x60
MOV qword ptr [RSP + 0x18],RBX
LAB_00112df5:
MOV RBX,qword ptr [RBX]
CMP RBX,R13
JZ 0x00112e34
MOV dword ptr [RBX + 0x30],0x1
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x0011abab
MOV qword ptr [RBX + 0x38],RAX
MOV qword ptr [RBX + 0x40],RDX
MOV qword ptr [RBX + 0x48],RBP
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RBX + 0x50],RAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RBX + 0x58],EAX
ADD RBX,0x8
JMP 0x00112df5
LAB_00112e34:
MOV R14,qword ptr [RSP + 0x10]
MOV RBX,R14
ADD RBX,0x28
MOV RDI,RBX
CALL 0x0011a9de
MOV R15,qword ptr [RSP + 0x18]
LAB_00112e4d:
MOV RAX,R15
LAB_00112e50:
MOV RCX,qword ptr [RAX]
CMP RCX,R13
JZ 0x00112e6f
LEA RAX,[RCX + 0x8]
CMP dword ptr [RCX + 0x30],0x0
JZ 0x00112e50
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011a9ef
JMP 0x00112e4d
LAB_00112e6f:
MOV RDI,R14
CALL 0x0011a95a
PUSH 0x3
POP R13
LAB_00112e7b:
XOR EAX,EAX
XOR ECX,ECX
LAB_00112e7f:
OR RAX,RCX
MOV RDX,R13
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_agent_broadcast(int8 param_1)
{
long lVar1;
int8 uVar2;
long lVar3;
int iVar4;
int8 uVar5;
long lVar6;
long lVar7;
ulong uVar8;
long *plVar9;
ulong uVar10;
long *plVar11;
int8 *in_R8;
int8 uVar12;
int1 auVar13 [16];
int4 local_4c;
long local_48;
long *local_40;
int8 local_38;
uVar5 = JS_GetRuntime();
lVar6 = JS_GetRuntimeOpaque(uVar5);
uVar5 = *in_R8;
uVar2 = in_R8[1];
lVar7 = JS_GetContextOpaque(param_1);
if (lVar7 == 0) {
local_48 = lVar6;
lVar6 = JS_GetArrayBuffer(param_1,&local_38,uVar5,uVar2);
uVar12 = 6;
if ((lVar6 != 0) &&
(iVar4 = JS_ToInt32(param_1,&local_4c,in_R8[2],in_R8[3]), lVar7 = local_48, iVar4 == 0)) {
js_mutex_lock(local_48);
lVar1 = lVar7 + 0x58;
plVar11 = (long *)(lVar7 + 0x60);
local_40 = plVar11;
while (lVar3 = local_48, lVar7 = *plVar11, lVar7 != lVar1) {
*(int4 *)(lVar7 + 0x30) = 1;
auVar13 = JS_DupValue(param_1,uVar5,uVar2);
*(int1 (*) [16])(lVar7 + 0x38) = auVar13;
*(long *)(lVar7 + 0x48) = lVar6;
*(int8 *)(lVar7 + 0x50) = local_38;
*(int4 *)(lVar7 + 0x58) = local_4c;
plVar11 = (long *)(lVar7 + 8);
}
lVar6 = local_48 + 0x28;
js_cond_broadcast(lVar6);
plVar11 = local_40;
plVar9 = plVar11;
while (lVar7 = *plVar9, lVar7 != lVar1) {
plVar9 = (long *)(lVar7 + 8);
if (*(int *)(lVar7 + 0x30) != 0) {
js_cond_wait(lVar6,lVar3);
plVar9 = plVar11;
}
}
js_mutex_unlock(lVar3);
uVar12 = 3;
}
uVar8 = 0;
uVar10 = 0;
}
else {
auVar13 = JS_ThrowTypeError(param_1,"cannot be called inside an agent");
uVar12 = auVar13._8_8_;
uVar10 = auVar13._0_8_ & 0xffffffff00000000;
uVar8 = auVar13._0_8_ & 0xffffffff;
}
auVar13._0_8_ = uVar8 | uVar10;
auVar13._8_8_ = uVar12;
return auVar13;
}
|
|
64,781 |
mariadb_reconnect
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
my_bool STDCALL mariadb_reconnect(MYSQL *mysql)
{
MYSQL tmp_mysql;
struct my_hook_data hook_data;
struct mysql_async_context *ctxt= NULL;
LIST *li_stmt= mysql->stmts;
/* check if connection handler is active */
if (IS_CONNHDLR_ACTIVE(mysql))
{
if (mysql->extension->conn_hdlr->plugin && mysql->extension->conn_hdlr->plugin->reconnect)
return(mysql->extension->conn_hdlr->plugin->reconnect(mysql));
}
if (!mysql->options.reconnect ||
(mysql->server_status & SERVER_STATUS_IN_TRANS) || !mysql->host_info)
{
/* Allow reconnect next time */
mysql->server_status&= ~SERVER_STATUS_IN_TRANS;
my_set_error(mysql, CR_SERVER_GONE_ERROR, SQLSTATE_UNKNOWN, 0);
return(1);
}
mysql_init(&tmp_mysql);
tmp_mysql.free_me= 0;
tmp_mysql.options=mysql->options;
if (mysql->extension->conn_hdlr)
{
tmp_mysql.extension->conn_hdlr= mysql->extension->conn_hdlr;
mysql->extension->conn_hdlr= 0;
}
/* don't reread options from configuration files */
tmp_mysql.options.my_cnf_group= tmp_mysql.options.my_cnf_file= NULL;
if (IS_MYSQL_ASYNC_ACTIVE(mysql))
{
ctxt= mysql->options.extension->async_context;
hook_data.orig_mysql= mysql;
hook_data.new_mysql= &tmp_mysql;
hook_data.orig_pvio= mysql->net.pvio;
my_context_install_suspend_resume_hook(ctxt, my_suspend_hook, &hook_data);
}
if (!mysql_real_connect(&tmp_mysql,mysql->host,mysql->user,mysql->passwd,
mysql->db, mysql->port, mysql->unix_socket,
mysql->client_flag | CLIENT_REMEMBER_OPTIONS) ||
mysql_set_character_set(&tmp_mysql, mysql->charset->csname))
{
if (ctxt)
my_context_install_suspend_resume_hook(ctxt, NULL, NULL);
/* don't free options (CONC-118) */
memset(&tmp_mysql.options, 0, sizeof(struct st_mysql_options));
my_set_error(mysql, tmp_mysql.net.last_errno,
tmp_mysql.net.sqlstate,
tmp_mysql.net.last_error);
mysql_close(&tmp_mysql);
return(1);
}
for (;li_stmt;li_stmt= li_stmt->next)
{
MYSQL_STMT *stmt= (MYSQL_STMT *)li_stmt->data;
if (stmt->state != MYSQL_STMT_INITTED)
{
stmt->state= MYSQL_STMT_INITTED;
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
}
}
tmp_mysql.free_me= mysql->free_me;
tmp_mysql.stmts= mysql->stmts;
mysql->stmts= NULL;
if (ctxt)
my_context_install_suspend_resume_hook(ctxt, NULL, NULL);
/* Don't free options, we moved them to tmp_mysql */
memset(&mysql->options, 0, sizeof(mysql->options));
mysql->free_me=0;
mysql_close(mysql);
*mysql=tmp_mysql;
mysql->net.pvio->mysql= mysql;
#ifdef HAVE_TLS
/* CONC-604: Set new connection handle */
if (mysql_get_ssl_cipher(mysql))
ma_pvio_tls_set_connection(mysql);
#endif
ma_net_clear(&mysql->net);
mysql->affected_rows= ~(unsigned long long) 0;
mysql->info= 0;
return(0);
}
|
O3
|
c
|
mariadb_reconnect:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x528, %rsp # imm = 0x528
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x4c8(%rdi), %r14
movq 0x4f0(%rdi), %rax
testq %rax, %rax
je 0x16655
movq (%rax), %rax
testq %rax, %rax
je 0x16655
movq (%rax), %rax
testq %rax, %rax
je 0x16655
movq 0x78(%rax), %rax
testq %rax, %rax
je 0x16655
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x1696e
movq %rbx, %rdi
addq $0x528, %rsp # imm = 0x528
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
cmpb $0x0, 0x43b(%rbx)
setne %cl
movl 0x380(%rbx), %eax
testb $0x1, %al
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x16726
cmpq $0x0, 0x2d8(%rbx)
je 0x16726
leaq 0x390(%rbx), %r15
leaq -0x528(%rbp), %r12
movq %r12, %rdi
callq 0x18b71
movb $0x0, 0x48c(%r12)
leaq -0x198(%rbp), %rdi
movl $0xf8, %edx
movq %r15, %rsi
callq 0x13390
movq 0x4f0(%rbx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x166da
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq 0x4f0(%rbx), %rax
movq $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x148(%rbp)
movq 0x480(%rbx), %rax
testq %rax, %rax
je 0x1674f
movq 0x28(%rax), %r13
testq %r13, %r13
je 0x1674f
cmpb $0x0, 0x14(%r13)
je 0x1674f
leaq -0x550(%rbp), %rdx
movq %rbx, (%rdx)
movq %r12, 0x8(%rdx)
movq (%rbx), %rax
movq %rax, 0x10(%rdx)
leaq 0x408f(%rip), %rsi # 0x1a7ab
movq %r13, %rdi
callq 0x2a448
jmp 0x16752
andl $-0x2, %eax
movl %eax, 0x380(%rbx)
leaq 0x3538a(%rip), %rax # 0x4bac0
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x7d6, %esi # imm = 0x7D6
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x160e1
jmp 0x16806
xorl %r13d, %r13d
movq 0x2b0(%rbx), %rsi
movq 0x2b8(%rbx), %rdx
movq 0x2c0(%rbx), %rcx
movq 0x2e8(%rbx), %r8
movl 0x360(%rbx), %r9d
movl $0x80000000, %eax # imm = 0x80000000
orq 0x368(%rbx), %rax
leaq -0x528(%rbp), %rdi
pushq %rax
pushq 0x2c8(%rbx)
callq 0x18eaa
addq $0x10, %rsp
testq %rax, %rax
je 0x167b8
movq 0x2f0(%rbx), %rax
movq 0x8(%rax), %rsi
leaq -0x528(%rbp), %rdi
callq 0x1a7d3
testl %eax, %eax
je 0x1682d
testq %r13, %r13
je 0x167c9
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a448
movl $0xf8, %edx
leaq -0x198(%rbp), %rdi
xorl %esi, %esi
callq 0x13260
leaq -0x291(%rbp), %rdx
movl -0x207(%rdx), %esi
leaq -0x491(%rbp), %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x160e1
leaq -0x528(%rbp), %rdi
callq 0x1a8c8
movb $0x1, %al
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x1696e
addq $0x528, %rsp # imm = 0x528
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, -0x530(%rbp)
movq %r15, -0x538(%rbp)
testq %r14, %r14
je 0x168b2
leaq 0x35279(%rip), %rax # 0x4bac0
movq (%rax), %r12
xorl %r13d, %r13d
movq 0x10(%r14), %r15
cmpl $0x0, 0x50(%r15)
je 0x168a9
movl $0x0, 0x50(%r15)
movl $0x7dd, 0x108(%r15) # imm = 0x7DD
leaq 0x30d(%r15), %rdi
movl $0x5, %edx
movq %r12, %rsi
callq 0x13220
movb %r13b, 0x312(%r15)
leaq 0x10c(%r15), %rdi
leaq 0x3523c(%rip), %rax # 0x4bad0
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r13b, 0x30b(%r15)
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x1684d
movb 0x48c(%rbx), %al
movb %al, -0x9c(%rbp)
movq 0x4c8(%rbx), %rax
movq %rax, -0x60(%rbp)
movq $0x0, 0x4c8(%rbx)
movq -0x530(%rbp), %rdi
testq %rdi, %rdi
je 0x168e9
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a448
movl $0xf8, %edx
movq -0x538(%rbp), %rdi
xorl %esi, %esi
callq 0x13260
movb $0x0, 0x48c(%rbx)
movq %rbx, %rdi
callq 0x1a8c8
leaq -0x528(%rbp), %rsi
movl $0x4f8, %edx # imm = 0x4F8
movq %rbx, %rdi
callq 0x13390
movq (%rbx), %rax
movq %rbx, 0x40(%rax)
movq (%rbx), %rax
testq %rax, %rax
je 0x16949
movq 0x38(%rax), %rdi
testq %rdi, %rdi
je 0x16949
callq 0x1e34a
testq %rax, %rax
je 0x16949
movq %rbx, %rdi
callq 0x1e606
movq %rbx, %rdi
callq 0x32c04
movq $-0x1, 0x338(%rbx)
movq $0x0, 0x2e0(%rbx)
xorl %eax, %eax
jmp 0x16808
callq 0x13500
|
mariadb_reconnect:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 528h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14, [rdi+4C8h]
mov rax, [rdi+4F0h]
test rax, rax
jz short loc_16655
mov rax, [rax]
test rax, rax
jz short loc_16655
mov rax, [rax]
test rax, rax
jz short loc_16655
mov rax, [rax+78h]
test rax, rax
jz short loc_16655
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz loc_1696E
mov rdi, rbx
add rsp, 528h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
loc_16655:
cmp byte ptr [rbx+43Bh], 0
setnz cl
mov eax, [rbx+380h]
test al, 1
setz dl
and dl, cl
cmp dl, 1
jnz loc_16726
cmp qword ptr [rbx+2D8h], 0
jz loc_16726
lea r15, [rbx+390h]
lea r12, [rbp+var_528]
mov rdi, r12
call mysql_init
mov byte ptr [r12+48Ch], 0
lea rdi, [rbp+var_198]
mov edx, 0F8h
mov rsi, r15
call _memcpy
mov rax, [rbx+4F0h]
mov rax, [rax]
test rax, rax
jz short loc_166DA
mov rcx, [rbp+var_38]
mov [rcx], rax
mov rax, [rbx+4F0h]
mov qword ptr [rax], 0
loc_166DA:
xorps xmm0, xmm0
movups [rbp+var_148], xmm0
mov rax, [rbx+480h]
test rax, rax
jz short loc_1674F
mov r13, [rax+28h]
test r13, r13
jz short loc_1674F
cmp byte ptr [r13+14h], 0
jz short loc_1674F
lea rdx, [rbp+var_550]
mov [rdx], rbx
mov [rdx+8], r12
mov rax, [rbx]
mov [rdx+10h], rax
lea rsi, my_suspend_hook
mov rdi, r13
call my_context_install_suspend_resume_hook
jmp short loc_16752
loc_16726:
and eax, 0FFFFFFFEh
mov [rbx+380h], eax
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov rdi, rbx
mov esi, 7D6h
xor ecx, ecx
xor eax, eax
call my_set_error
jmp loc_16806
loc_1674F:
xor r13d, r13d
loc_16752:
mov rsi, [rbx+2B0h]
mov rdx, [rbx+2B8h]
mov rcx, [rbx+2C0h]
mov r8, [rbx+2E8h]
mov r9d, [rbx+360h]
mov eax, 80000000h
or rax, [rbx+368h]
lea rdi, [rbp+var_528]
push rax
push qword ptr [rbx+2C8h]
call mysql_real_connect
add rsp, 10h
test rax, rax
jz short loc_167B8
mov rax, [rbx+2F0h]
mov rsi, [rax+8]
lea rdi, [rbp+var_528]
call mysql_set_character_set
test eax, eax
jz short loc_1682D
loc_167B8:
test r13, r13
jz short loc_167C9
mov rdi, r13
xor esi, esi
xor edx, edx
call my_context_install_suspend_resume_hook
loc_167C9:
mov edx, 0F8h
lea rdi, [rbp+var_198]
xor esi, esi
call _memset
lea rdx, [rbp+var_291]
mov esi, [rdx-207h]
lea rcx, [rbp+var_491]
mov rdi, rbx
xor eax, eax
call my_set_error
lea rdi, [rbp+var_528]
call mysql_close
loc_16806:
mov al, 1
loc_16808:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz loc_1696E
add rsp, 528h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1682D:
mov [rbp+var_530], r13
mov [rbp+var_538], r15
test r14, r14
jz short loc_168B2
lea rax, SQLSTATE_UNKNOWN
mov r12, [rax]
xor r13d, r13d
loc_1684D:
mov r15, [r14+10h]
cmp dword ptr [r15+50h], 0
jz short loc_168A9
mov dword ptr [r15+50h], 0
mov dword ptr [r15+108h], 7DDh
lea rdi, [r15+30Dh]
mov edx, 5
mov rsi, r12
call _strncpy
mov [r15+312h], r13b
lea rdi, [r15+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
mov edx, 200h
call _strncpy
mov [r15+30Bh], r13b
loc_168A9:
mov r14, [r14+8]
test r14, r14
jnz short loc_1684D
loc_168B2:
mov al, [rbx+48Ch]
mov [rbp+var_9C], al
mov rax, [rbx+4C8h]
mov [rbp+var_60], rax
mov qword ptr [rbx+4C8h], 0
mov rdi, [rbp+var_530]
test rdi, rdi
jz short loc_168E9
xor esi, esi
xor edx, edx
call my_context_install_suspend_resume_hook
loc_168E9:
mov edx, 0F8h
mov rdi, [rbp+var_538]
xor esi, esi
call _memset
mov byte ptr [rbx+48Ch], 0
mov rdi, rbx
call mysql_close
lea rsi, [rbp+var_528]
mov edx, 4F8h
mov rdi, rbx
call _memcpy
mov rax, [rbx]
mov [rax+40h], rbx
mov rax, [rbx]
test rax, rax
jz short loc_16949
mov rdi, [rax+38h]
test rdi, rdi
jz short loc_16949
call ma_pvio_tls_cipher
test rax, rax
jz short loc_16949
mov rdi, rbx
call ma_pvio_tls_set_connection
loc_16949:
mov rdi, rbx
call ma_net_clear
mov qword ptr [rbx+338h], 0FFFFFFFFFFFFFFFFh
mov qword ptr [rbx+2E0h], 0
xor eax, eax
jmp loc_16808
loc_1696E:
call ___stack_chk_fail
|
char mariadb_reconnect(_QWORD *a1, long long a2, long long a3)
{
long long v3; // r14
long long **v4; // rax
long long *v5; // rax
long long v6; // rax
long long ( *v7)(_QWORD *, long long, long long, unsigned long long); // rax
int v9; // eax
long long v10; // rax
long long v11; // rax
long long v12; // r13
long long v13; // rcx
long long v14; // r8
long long v15; // r9
char *v16; // r12
long long v17; // r15
_QWORD *v18; // [rsp+0h] [rbp-550h]
_BYTE *v19; // [rsp+8h] [rbp-548h]
long long v20; // [rsp+10h] [rbp-540h]
_BYTE v21[144]; // [rsp+28h] [rbp-528h] BYREF
int v22; // [rsp+B8h] [rbp-498h]
char v23[512]; // [rsp+BFh] [rbp-491h] BYREF
_BYTE v24[249]; // [rsp+2BFh] [rbp-291h] BYREF
_BYTE v25[80]; // [rsp+3B8h] [rbp-198h] BYREF
__int128 v26; // [rsp+408h] [rbp-148h]
char v27; // [rsp+4B4h] [rbp-9Ch]
long long v28; // [rsp+4F0h] [rbp-60h]
_QWORD *v29; // [rsp+518h] [rbp-38h]
unsigned long long v30; // [rsp+520h] [rbp-30h]
v30 = __readfsqword(0x28u);
v3 = a1[153];
v4 = (long long **)a1[158];
if ( v4 )
{
v5 = *v4;
if ( v5 )
{
v6 = *v5;
if ( v6 )
{
v7 = *(long long ( **)(_QWORD *, long long, long long, unsigned long long))(v6 + 120);
if ( v7 )
return v7(a1, a2, a3, __readfsqword(0x28u));
}
}
}
v9 = *((_DWORD *)a1 + 224);
if ( *((_BYTE *)a1 + 1083) == 0 || (v9 & 1) != 0 || !a1[91] )
{
*((_DWORD *)a1 + 224) = v9 & 0xFFFFFFFE;
my_set_error((long long)a1, 2006, (long long)SQLSTATE_UNKNOWN, 0LL);
return 1;
}
mysql_init(v21);
v27 = 0;
memcpy(v25, a1 + 114, 248LL);
v10 = *(_QWORD *)a1[158];
if ( v10 )
{
*v29 = v10;
*(_QWORD *)a1[158] = 0LL;
}
v26 = 0LL;
v11 = a1[144];
if ( v11 && (v12 = *(_QWORD *)(v11 + 40)) != 0 && *(_BYTE *)(v12 + 20) )
{
v18 = a1;
v19 = v21;
v20 = *a1;
((void ( *)(long long, long long ( *)()))my_context_install_suspend_resume_hook)(
v12,
my_suspend_hook);
}
else
{
v12 = 0LL;
}
if ( !mysql_real_connect(
(unsigned int)v21,
a1[86],
a1[87],
a1[88],
a1[93],
*((_DWORD *)a1 + 216),
a1[89],
a1[109] | 0x80000000LL)
|| (unsigned int)mysql_set_character_set(v21, *(_QWORD *)(a1[94] + 8LL)) )
{
if ( v12 )
my_context_install_suspend_resume_hook(v12, 0LL, 0LL, v13, v14, v15, v18, v19, v20);
memset(v25, 0LL, 248LL);
my_set_error((long long)a1, v22, (long long)v24, v23);
mysql_close(v21);
return 1;
}
if ( v3 )
{
v16 = SQLSTATE_UNKNOWN;
do
{
v17 = *(_QWORD *)(v3 + 16);
if ( *(_DWORD *)(v17 + 80) )
{
*(_DWORD *)(v17 + 80) = 0;
*(_DWORD *)(v17 + 264) = 2013;
strncpy(v17 + 781, v16, 5LL);
*(_BYTE *)(v17 + 786) = 0;
strncpy(v17 + 268, client_errors[13], 512LL);
*(_BYTE *)(v17 + 779) = 0;
}
v3 = *(_QWORD *)(v3 + 8);
}
while ( v3 );
}
v27 = *((_BYTE *)a1 + 1164);
v28 = a1[153];
a1[153] = 0LL;
if ( v12 )
my_context_install_suspend_resume_hook(v12, 0LL, 0LL, v13, v14, v15, v18, v19, v20);
memset(a1 + 114, 0LL, 248LL);
*((_BYTE *)a1 + 1164) = 0;
mysql_close(a1);
memcpy(a1, v21, 1272LL);
*(_QWORD *)(*a1 + 64LL) = a1;
if ( *a1 && *(_QWORD *)(*a1 + 56LL) && ma_pvio_tls_cipher() )
ma_pvio_tls_set_connection(a1);
ma_net_clear(a1);
a1[103] = -1LL;
a1[92] = 0LL;
return 0;
}
|
mariadb_reconnect:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x528
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14,qword ptr [RDI + 0x4c8]
MOV RAX,qword ptr [RDI + 0x4f0]
TEST RAX,RAX
JZ 0x00116655
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00116655
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00116655
MOV RAX,qword ptr [RAX + 0x78]
TEST RAX,RAX
JZ 0x00116655
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0011696e
MOV RDI,RBX
ADD RSP,0x528
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
LAB_00116655:
CMP byte ptr [RBX + 0x43b],0x0
SETNZ CL
MOV EAX,dword ptr [RBX + 0x380]
TEST AL,0x1
SETZ DL
AND DL,CL
CMP DL,0x1
JNZ 0x00116726
CMP qword ptr [RBX + 0x2d8],0x0
JZ 0x00116726
LEA R15,[RBX + 0x390]
LEA R12,[RBP + -0x528]
MOV RDI,R12
CALL 0x00118b71
MOV byte ptr [R12 + 0x48c],0x0
LEA RDI,[RBP + -0x198]
MOV EDX,0xf8
MOV RSI,R15
CALL 0x00113390
MOV RAX,qword ptr [RBX + 0x4f0]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x001166da
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RCX],RAX
MOV RAX,qword ptr [RBX + 0x4f0]
MOV qword ptr [RAX],0x0
LAB_001166da:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBP + -0x148],XMM0
MOV RAX,qword ptr [RBX + 0x480]
TEST RAX,RAX
JZ 0x0011674f
MOV R13,qword ptr [RAX + 0x28]
TEST R13,R13
JZ 0x0011674f
CMP byte ptr [R13 + 0x14],0x0
JZ 0x0011674f
LEA RDX,[RBP + -0x550]
MOV qword ptr [RDX],RBX
MOV qword ptr [RDX + 0x8],R12
MOV RAX,qword ptr [RBX]
MOV qword ptr [RDX + 0x10],RAX
LEA RSI,[0x11a7ab]
MOV RDI,R13
CALL 0x0012a448
JMP 0x00116752
LAB_00116726:
AND EAX,0xfffffffe
MOV dword ptr [RBX + 0x380],EAX
LEA RAX,[0x14bac0]
MOV RDX,qword ptr [RAX]
MOV RDI,RBX
MOV ESI,0x7d6
XOR ECX,ECX
XOR EAX,EAX
CALL 0x001160e1
JMP 0x00116806
LAB_0011674f:
XOR R13D,R13D
LAB_00116752:
MOV RSI,qword ptr [RBX + 0x2b0]
MOV RDX,qword ptr [RBX + 0x2b8]
MOV RCX,qword ptr [RBX + 0x2c0]
MOV R8,qword ptr [RBX + 0x2e8]
MOV R9D,dword ptr [RBX + 0x360]
MOV EAX,0x80000000
OR RAX,qword ptr [RBX + 0x368]
LEA RDI,[RBP + -0x528]
PUSH RAX
PUSH qword ptr [RBX + 0x2c8]
CALL 0x00118eaa
ADD RSP,0x10
TEST RAX,RAX
JZ 0x001167b8
MOV RAX,qword ptr [RBX + 0x2f0]
MOV RSI,qword ptr [RAX + 0x8]
LEA RDI,[RBP + -0x528]
CALL 0x0011a7d3
TEST EAX,EAX
JZ 0x0011682d
LAB_001167b8:
TEST R13,R13
JZ 0x001167c9
MOV RDI,R13
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0012a448
LAB_001167c9:
MOV EDX,0xf8
LEA RDI,[RBP + -0x198]
XOR ESI,ESI
CALL 0x00113260
LEA RDX,[RBP + -0x291]
MOV ESI,dword ptr [RDX + -0x207]
LEA RCX,[RBP + -0x491]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001160e1
LEA RDI,[RBP + -0x528]
CALL 0x0011a8c8
LAB_00116806:
MOV AL,0x1
LAB_00116808:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0011696e
ADD RSP,0x528
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011682d:
MOV qword ptr [RBP + -0x530],R13
MOV qword ptr [RBP + -0x538],R15
TEST R14,R14
JZ 0x001168b2
LEA RAX,[0x14bac0]
MOV R12,qword ptr [RAX]
XOR R13D,R13D
LAB_0011684d:
MOV R15,qword ptr [R14 + 0x10]
CMP dword ptr [R15 + 0x50],0x0
JZ 0x001168a9
MOV dword ptr [R15 + 0x50],0x0
MOV dword ptr [R15 + 0x108],0x7dd
LEA RDI,[R15 + 0x30d]
MOV EDX,0x5
MOV RSI,R12
CALL 0x00113220
MOV byte ptr [R15 + 0x312],R13B
LEA RDI,[R15 + 0x10c]
LEA RAX,[0x14bad0]
MOV RSI,qword ptr [RAX + 0x68]
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [R15 + 0x30b],R13B
LAB_001168a9:
MOV R14,qword ptr [R14 + 0x8]
TEST R14,R14
JNZ 0x0011684d
LAB_001168b2:
MOV AL,byte ptr [RBX + 0x48c]
MOV byte ptr [RBP + -0x9c],AL
MOV RAX,qword ptr [RBX + 0x4c8]
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBX + 0x4c8],0x0
MOV RDI,qword ptr [RBP + -0x530]
TEST RDI,RDI
JZ 0x001168e9
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0012a448
LAB_001168e9:
MOV EDX,0xf8
MOV RDI,qword ptr [RBP + -0x538]
XOR ESI,ESI
CALL 0x00113260
MOV byte ptr [RBX + 0x48c],0x0
MOV RDI,RBX
CALL 0x0011a8c8
LEA RSI,[RBP + -0x528]
MOV EDX,0x4f8
MOV RDI,RBX
CALL 0x00113390
MOV RAX,qword ptr [RBX]
MOV qword ptr [RAX + 0x40],RBX
MOV RAX,qword ptr [RBX]
TEST RAX,RAX
JZ 0x00116949
MOV RDI,qword ptr [RAX + 0x38]
TEST RDI,RDI
JZ 0x00116949
CALL 0x0011e34a
TEST RAX,RAX
JZ 0x00116949
MOV RDI,RBX
CALL 0x0011e606
LAB_00116949:
MOV RDI,RBX
CALL 0x00132c04
MOV qword ptr [RBX + 0x338],-0x1
MOV qword ptr [RBX + 0x2e0],0x0
XOR EAX,EAX
JMP 0x00116808
LAB_0011696e:
CALL 0x00113500
|
int8 mariadb_reconnect(long *param_1)
{
long *plVar1;
code *UNRECOVERED_JUMPTABLE;
int *__src;
int iVar2;
int8 uVar3;
long lVar4;
long lVar5;
long lVar6;
long in_FS_OFFSET;
int1 local_530 [144];
int4 local_4a0;
int1 local_499 [512];
int1 local_299 [249];
int1 local_1a0 [80];
int8 local_150;
int8 uStack_148;
int1 local_a4;
long local_68;
long *local_40;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar5 = param_1[0x99];
if (((((long *)param_1[0x9e] != (long *)0x0) &&
(plVar1 = *(long **)param_1[0x9e], plVar1 != (long *)0x0)) && (lVar6 = *plVar1, lVar6 != 0))
&& (UNRECOVERED_JUMPTABLE = *(code **)(lVar6 + 0x78), UNRECOVERED_JUMPTABLE != (code *)0x0)) {
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
/* WARNING: Could not recover jumptable at 0x00116653. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar3 = (*UNRECOVERED_JUMPTABLE)(param_1);
return uVar3;
}
goto LAB_0011696e;
}
if (((*(uint *)(param_1 + 0x70) & 1) == 0 && *(char *)((long)param_1 + 0x43b) != '\0') &&
(param_1[0x5b] != 0)) {
mysql_init(local_530);
local_a4 = 0;
memcpy(local_1a0,param_1 + 0x72,0xf8);
if (*(long *)param_1[0x9e] != 0) {
*local_40 = *(long *)param_1[0x9e];
*(int8 *)param_1[0x9e] = 0;
}
local_150 = 0;
uStack_148 = 0;
if (((param_1[0x90] == 0) || (lVar6 = *(long *)(param_1[0x90] + 0x28), lVar6 == 0)) ||
(*(char *)(lVar6 + 0x14) == '\0')) {
lVar6 = 0;
}
else {
my_context_install_suspend_resume_hook(lVar6,my_suspend_hook);
}
lVar4 = mysql_real_connect(local_530,param_1[0x56],param_1[0x57],param_1[0x58],param_1[0x5d],
(int)param_1[0x6c],param_1[0x59],param_1[0x6d] | 0x80000000);
if ((lVar4 == 0) ||
(iVar2 = mysql_set_character_set(local_530), __src = SQLSTATE_UNKNOWN, iVar2 != 0)) {
if (lVar6 != 0) {
my_context_install_suspend_resume_hook(lVar6,0,0);
}
memset(local_1a0,0,0xf8);
my_set_error(param_1,local_4a0,local_299,local_499);
mysql_close(local_530);
goto LAB_00116806;
}
for (; lVar5 != 0; lVar5 = *(long *)(lVar5 + 8)) {
lVar4 = *(long *)(lVar5 + 0x10);
if (*(int *)(lVar4 + 0x50) != 0) {
*(int4 *)(lVar4 + 0x50) = 0;
*(int4 *)(lVar4 + 0x108) = 0x7dd;
strncpy((char *)(lVar4 + 0x30d),__src,5);
*(int1 *)(lVar4 + 0x312) = 0;
strncpy((char *)(lVar4 + 0x10c),PTR_s_Lost_connection_to_server_during_0014bb38,0x200);
*(int1 *)(lVar4 + 0x30b) = 0;
}
}
local_a4 = *(int1 *)((long)param_1 + 0x48c);
local_68 = param_1[0x99];
param_1[0x99] = 0;
if (lVar6 != 0) {
my_context_install_suspend_resume_hook(lVar6,0,0);
}
memset(param_1 + 0x72,0,0xf8);
*(int1 *)((long)param_1 + 0x48c) = 0;
mysql_close(param_1);
memcpy(param_1,local_530,0x4f8);
*(long **)(*param_1 + 0x40) = param_1;
if (((*param_1 != 0) && (*(long *)(*param_1 + 0x38) != 0)) &&
(lVar5 = ma_pvio_tls_cipher(), lVar5 != 0)) {
ma_pvio_tls_set_connection(param_1);
}
ma_net_clear(param_1);
param_1[0x67] = -1;
param_1[0x5c] = 0;
uVar3 = 0;
}
else {
*(uint *)(param_1 + 0x70) = *(uint *)(param_1 + 0x70) & 0xfffffffe;
my_set_error(param_1,0x7d6,SQLSTATE_UNKNOWN,0);
LAB_00116806:
uVar3 = 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar3;
}
LAB_0011696e:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
64,782 |
google::protobuf::compiler::CodeGeneratorResponse::~CodeGeneratorResponse()
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/plugin.pb.cc
|
CodeGeneratorResponse::~CodeGeneratorResponse() {
// @@protoc_insertion_point(destructor:google.protobuf.compiler.CodeGeneratorResponse)
if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
(void)arena;
return;
}
SharedDtor();
}
|
O3
|
cpp
|
google::protobuf::compiler::CodeGeneratorResponse::~CodeGeneratorResponse():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %rax
testb $0x1, %al
jne 0xaede1
andq $-0x4, %rax
jmp 0xaede9
movq %rbx, %rdi
callq 0x59746
testq %rax, %rax
jne 0xaee00
leaq 0x18(%r14), %rdi
callq 0xaf5f8
leaq 0x30(%r14), %rdi
callq 0x933e4
leaq 0x52519(%rip), %rax # 0x101320
addq $0x10, %rax
movq %rax, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x59494
movq %rax, %rdi
callq 0x13387
nop
|
_ZN6google8protobuf8compiler21CodeGeneratorResponseD2Ev:
push r14
push rbx
push rax
mov r14, rdi
lea rbx, [rdi+8]
mov rax, [rdi+8]
test al, 1
jnz short loc_AEDE1
and rax, 0FFFFFFFFFFFFFFFCh
jmp short loc_AEDE9
loc_AEDE1:
mov rdi, rbx
call _ZN6google8protobuf8internal16InternalMetadata21DeleteOutOfLineHelperINS0_15UnknownFieldSetEEEPNS0_5ArenaEv; google::protobuf::internal::InternalMetadata::DeleteOutOfLineHelper<google::protobuf::UnknownFieldSet>(void)
loc_AEDE9:
test rax, rax
jnz short loc_AEE00
lea rdi, [r14+18h]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_8compiler26CodeGeneratorResponse_FileEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::compiler::CodeGeneratorResponse_File>::~RepeatedPtrField()
lea rdi, [r14+30h]; this
call _ZN6google8protobuf8internal14ArenaStringPtr7DestroyEv; google::protobuf::internal::ArenaStringPtr::Destroy(void)
loc_AEE00:
lea rax, _ZTVN6google8protobuf11MessageLiteE; `vtable for'google::protobuf::MessageLite
add rax, 10h
mov [r14], rax
mov rdi, rbx; this
add rsp, 8
pop rbx
pop r14
jmp _ZN6google8protobuf8internal16InternalMetadataD2Ev; google::protobuf::internal::InternalMetadata::~InternalMetadata()
mov rdi, rax
call __clang_call_terminate
|
void google::protobuf::compiler::CodeGeneratorResponse::~CodeGeneratorResponse(
google::protobuf::compiler::CodeGeneratorResponse *this)
{
long long v1; // rax
unsigned long long v2; // rax
v1 = *((_QWORD *)this + 1);
if ( (v1 & 1) != 0 )
v2 = google::protobuf::internal::InternalMetadata::DeleteOutOfLineHelper<google::protobuf::UnknownFieldSet>((long long *)this + 1);
else
v2 = v1 & 0xFFFFFFFFFFFFFFFCLL;
if ( !v2 )
{
google::protobuf::RepeatedPtrField<google::protobuf::compiler::CodeGeneratorResponse_File>::~RepeatedPtrField((char *)this + 24);
google::protobuf::internal::ArenaStringPtr::Destroy((google::protobuf::compiler::CodeGeneratorResponse *)((char *)this + 48));
}
*(_QWORD *)this = &`vtable for'google::protobuf::MessageLite + 2;
google::protobuf::internal::InternalMetadata::~InternalMetadata((google::protobuf::compiler::CodeGeneratorResponse *)((char *)this + 8));
}
|
~CodeGeneratorResponse:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
LEA RBX,[RDI + 0x8]
MOV RAX,qword ptr [RDI + 0x8]
TEST AL,0x1
JNZ 0x001aede1
AND RAX,-0x4
JMP 0x001aede9
LAB_001aede1:
MOV RDI,RBX
CALL 0x00159746
LAB_001aede9:
TEST RAX,RAX
JNZ 0x001aee00
LEA RDI,[R14 + 0x18]
CALL 0x001af5f8
LEA RDI,[R14 + 0x30]
CALL 0x001933e4
LAB_001aee00:
LEA RAX,[0x201320]
ADD RAX,0x10
MOV qword ptr [R14],RAX
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00159494
|
/* google::protobuf::compiler::CodeGeneratorResponse::~CodeGeneratorResponse() */
void __thiscall
google::protobuf::compiler::CodeGeneratorResponse::~CodeGeneratorResponse
(CodeGeneratorResponse *this)
{
Arena *pAVar1;
if ((*(ulong *)(this + 8) & 1) == 0) {
pAVar1 = (Arena *)(*(ulong *)(this + 8) & 0xfffffffffffffffc);
}
else {
/* try { // try from 001aede1 to 001aedff has its CatchHandler @ 001aee1d */
pAVar1 = internal::InternalMetadata::DeleteOutOfLineHelper<google::protobuf::UnknownFieldSet>
((InternalMetadata *)(this + 8));
}
if (pAVar1 == (Arena *)0x0) {
RepeatedPtrField<google::protobuf::compiler::CodeGeneratorResponse_File>::~RepeatedPtrField
((RepeatedPtrField<google::protobuf::compiler::CodeGeneratorResponse_File> *)
(this + 0x18));
internal::ArenaStringPtr::Destroy((ArenaStringPtr *)(this + 0x30));
}
*(int ***)this = &PTR__MessageLite_00201330;
internal::InternalMetadata::~InternalMetadata((InternalMetadata *)(this + 8));
return;
}
|
|
64,783 |
link_into_queue
|
eloqsql/mysys/mf_keycache.c
|
static void link_into_queue(KEYCACHE_WQUEUE *wqueue,
struct st_my_thread_var *thread)
{
struct st_my_thread_var *last;
DBUG_ASSERT(!thread->next && !thread->prev);
if (! (last= wqueue->last_thread))
{
/* Queue is empty */
thread->next= thread;
thread->prev= &thread->next;
}
else
{
DBUG_ASSERT(last->next->prev == &last->next);
/* Add backlink to previous element */
thread->prev= last->next->prev;
/* Fix first in list to point backwords to current */
last->next->prev= &thread->next;
/* Next should point to the first element in list */
thread->next= last->next;
/* Fix old element to point to new one */
last->next= thread;
}
wqueue->last_thread= thread;
}
|
O0
|
c
|
link_into_queue:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xe525e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xe5296
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rcx
addq $0x88, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
jmp 0xe52f9
jmp 0xe5298
jmp 0xe529a
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq 0x90(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rcx
addq $0x88, %rcx
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq %rcx, 0x90(%rax)
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
link_into_queue:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_E525E:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_E5296
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax+88h], rcx
mov rcx, [rbp+var_10]
add rcx, 88h
mov rax, [rbp+var_10]
mov [rax+90h], rcx
jmp short loc_E52F9
loc_E5296:
jmp short $+2
loc_E5298:
jmp short $+2
loc_E529A:
mov rax, [rbp+var_18]
mov rax, [rax+88h]
mov rcx, [rax+90h]
mov rax, [rbp+var_10]
mov [rax+90h], rcx
mov rcx, [rbp+var_10]
add rcx, 88h
mov rax, [rbp+var_18]
mov rax, [rax+88h]
mov [rax+90h], rcx
mov rax, [rbp+var_18]
mov rcx, [rax+88h]
mov rax, [rbp+var_10]
mov [rax+88h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_18]
mov [rax+88h], rcx
loc_E52F9:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
pop rbp
retn
|
_QWORD * link_into_queue(_QWORD *a1, long long a2)
{
_QWORD *result; // rax
long long v3; // [rsp+0h] [rbp-18h]
v3 = *a1;
if ( *a1 )
{
*(_QWORD *)(a2 + 144) = *(_QWORD *)(*(_QWORD *)(v3 + 136) + 144LL);
*(_QWORD *)(*(_QWORD *)(v3 + 136) + 144LL) = a2 + 136;
*(_QWORD *)(a2 + 136) = *(_QWORD *)(v3 + 136);
*(_QWORD *)(v3 + 136) = a2;
}
else
{
*(_QWORD *)(a2 + 136) = a2;
*(_QWORD *)(a2 + 144) = a2 + 136;
}
result = a1;
*a1 = a2;
return result;
}
|
link_into_queue:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001e525e
LAB_001e525e:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x001e5296
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x88],RCX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x88
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x90],RCX
JMP 0x001e52f9
LAB_001e5296:
JMP 0x001e5298
LAB_001e5298:
JMP 0x001e529a
LAB_001e529a:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x88]
MOV RCX,qword ptr [RAX + 0x90]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x90],RCX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x88
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RAX + 0x90],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x88]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x88],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x88],RCX
LAB_001e52f9:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void link_into_queue(long *param_1,long param_2)
{
long lVar1;
lVar1 = *param_1;
if (lVar1 == 0) {
*(long *)(param_2 + 0x88) = param_2;
*(long *)(param_2 + 0x90) = param_2 + 0x88;
}
else {
*(int8 *)(param_2 + 0x90) = *(int8 *)(*(long *)(lVar1 + 0x88) + 0x90);
*(long *)(*(long *)(lVar1 + 0x88) + 0x90) = param_2 + 0x88;
*(int8 *)(param_2 + 0x88) = *(int8 *)(lVar1 + 0x88);
*(long *)(lVar1 + 0x88) = param_2;
}
*param_1 = param_2;
return;
}
|
|
64,784 |
nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&)
|
monkey531[P]llama/common/json.hpp
|
constexpr value_t type() const noexcept
{
return m_data.m_type;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movzbl (%rdi), %r12d
cmpq $0x9, %r12
ja 0xb3ff2
movq %rdi, %r14
leaq 0x3dc6f(%rip), %rax # 0xf18e8
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
jmp 0xb3f2c
movq %r14, %rdi
callq 0xb411e
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x56648
jmp 0xb3eec
movl $0x9e3779b9, %r15d # imm = 0x9E3779B9
movq %r14, %rdi
callq 0xb4068
movl %r12d, %ecx
shll $0x6, %ecx
movl %r12d, %ebx
shrl $0x2, %ebx
orl %ecx, %ebx
addq 0x8(%rax), %rbx
addq %r15, %rbx
subq (%rax), %rbx
xorq %r12, %rbx
movq %r14, %rdi
callq 0xb4068
movzbl 0x20(%rax), %eax
movq %rbx, %rcx
shlq $0x6, %rcx
orq %rax, %rcx
movq %rbx, %r12
shrq $0x2, %r12
addq %r15, %r12
addq %rcx, %r12
xorq %rbx, %r12
movq %r14, %rdi
callq 0xb4068
movq 0x18(%rax), %rcx
addq %r15, %rcx
leaq -0x1(%r15), %rdx
cmpb $0x0, 0x20(%rax)
cmovneq %rcx, %rdx
movq %r12, %rax
shlq $0x6, %rax
addq %rdx, %rax
movq %r12, %rbx
shrq $0x2, %rbx
addq %rax, %rbx
xorq %r12, %rbx
movq %r14, %rdi
callq 0xb4068
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
je 0xb3f77
movzbl (%rcx), %edx
movq %rbx, %rsi
shlq $0x6, %rsi
movq %rbx, %rdi
shrq $0x2, %rdi
addq %r15, %rsi
addq %rdi, %rsi
addq %rdx, %rsi
xorq %rsi, %rbx
incq %rcx
jmp 0xb3d3f
movl $0x9e3779b9, %r15d # imm = 0x9E3779B9
movq %r14, %rdi
callq 0x5e994
movq %rax, %rbx
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
addq %r15, %rbx
addq %rcx, %rbx
xorq %r12, %rbx
leaq 0x78(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x8eb4e
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xb7958
leaq 0xe8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x8eeee
leaq 0x78(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xb7958
movq %r12, %rdi
leaq 0x78(%rsp), %rsi
callq 0x8ec12
testb %al, %al
jne 0xb3f8c
movq %r12, %rdi
callq 0xac8d0
movq %r13, %rdi
movq %rax, %rsi
callq 0x56648
movq %rax, %r14
movq %r12, %rdi
callq 0x8e852
movq %rax, %rdi
callq 0xb3c50
movq %rax, %rbp
movq %r12, %rdi
callq 0x8e804
movq %rbx, %rax
shlq $0x6, %rax
movq %rbx, %rcx
shrq $0x2, %rcx
addq %r15, %rax
addq %rcx, %rax
addq %r14, %rax
xorq %rbx, %rax
movq %rax, %rcx
shlq $0x6, %rcx
movq %rax, %rbx
shrq $0x2, %rbx
addq %r15, %rcx
addq %rbp, %rbx
addq %rcx, %rbx
xorq %rax, %rbx
incq 0x28(%rsp)
jmp 0xb3dd6
movl $0x9e3779b9, %r13d # imm = 0x9E3779B9
movq %r14, %rdi
callq 0x5e994
movq %rax, %r15
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
addq %r13, %r15
addq %rcx, %r15
xorq %r12, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8eb4e
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x8eeee
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8ec12
testb %al, %al
je 0xb3fa2
movq %r15, %rbx
jmp 0xb3f77
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb4261
jmp 0xb3f1b
leaq 0x8(%rsp), %rbx
movb $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x891e5
movzbl (%rbx), %eax
movl %r12d, %ecx
shll $0x6, %ecx
movl %r12d, %edx
shrl $0x2, %edx
orl %ecx, %edx
movl $0x9e3779b9, %ebx # imm = 0x9E3779B9
addq %rax, %rbx
jmp 0xb3f71
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x882f1
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
addq (%rbx), %rcx
movl $0x9e3779b9, %ebx # imm = 0x9E3779B9
addq %rcx, %rbx
jmp 0xb3f74
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x88e71
movsd (%rbx), %xmm0
leaq 0x8(%rsp), %rdi
callq 0xb4036
movl %r12d, %ecx
shll $0x6, %ecx
movl %r12d, %edx
shrl $0x2, %edx
orl %ecx, %edx
addq %rax, %rdx
movl $0x9e3779b9, %ebx # imm = 0x9E3779B9
addq %rdx, %rbx
xorq %r12, %rbx
movq %rbx, %rax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x78(%rsp), %rdi
callq 0xac93e
leaq 0x8(%rsp), %rdi
callq 0xac93e
jmp 0xb3f77
leaq 0x8(%rsp), %r14
leaq 0x78(%rsp), %r12
movq %r15, %rbx
movq %r14, %rdi
callq 0x8e852
movq %rax, %rdi
callq 0xb3c50
shlq $0x6, %rbx
movq %r15, %rcx
shrq $0x2, %rcx
addq %r13, %rbx
addq %rcx, %rbx
addq %rax, %rbx
xorq %r15, %rbx
movq %r14, %rdi
callq 0x8e804
movq %r14, %rdi
movq %r12, %rsi
callq 0x8ec12
movq %rbx, %r15
testb %al, %al
je 0xb3faf
jmp 0xb3f77
leaq 0x3acb0(%rip), %rdi # 0xeeca9
leaq 0x3acf3(%rip), %rdx # 0xeecf3
leaq 0x3879c(%rip), %rcx # 0xec7a3
movl $0x17d9, %esi # imm = 0x17D9
xorl %eax, %eax
callq 0x1beb0
jmp 0xb4017
jmp 0xb4017
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xac93e
leaq 0x8(%rsp), %rdi
callq 0xac93e
movq %rbx, %rdi
callq 0x1bfb0
|
_ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 108h
movzx r12d, byte ptr [rdi]
cmp r12, 9; switch 10 cases
ja def_B3C80; jumptable 00000000000B3C80 default case
mov r14, rdi
lea rax, jpt_B3C80
movsxd rcx, ds:(jpt_B3C80 - 0F18E8h)[rax+r12*4]
add rcx, rax
jmp rcx; switch jump
loc_B3C82:
mov eax, r12d; jumptable 00000000000B3C80 cases 0,9
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
jmp loc_B3F2C
loc_B3C95:
mov rdi, r14; jumptable 00000000000B3C80 case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRKS9_KSD_EET_RT0_; 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>::get_ref_impl<std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const &)
lea rdi, [rsp+138h+var_130]
mov rsi, rax
call _ZNKSt4hashINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclERKS5_; std::hash<std::string>::operator()(std::string const&)
jmp loc_B3EEC
loc_B3CAF:
mov r15d, 9E3779B9h; jumptable 00000000000B3C80 case 8
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; 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>::get_binary(void)
mov ecx, r12d
shl ecx, 6
mov ebx, r12d
shr ebx, 2
or ebx, ecx
add rbx, [rax+8]
add rbx, r15
sub rbx, [rax]
xor rbx, r12
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; 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>::get_binary(void)
movzx eax, byte ptr [rax+20h]
mov rcx, rbx
shl rcx, 6
or rcx, rax
mov r12, rbx
shr r12, 2
add r12, r15
add r12, rcx
xor r12, rbx
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; 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>::get_binary(void)
mov rcx, [rax+18h]
add rcx, r15
lea rdx, [r15-1]
cmp byte ptr [rax+20h], 0
cmovnz rdx, rcx
mov rax, r12
shl rax, 6
add rax, rdx
mov rbx, r12
shr rbx, 2
add rbx, rax
xor rbx, r12
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; 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>::get_binary(void)
mov rcx, [rax]
mov rax, [rax+8]
loc_B3D3F:
cmp rcx, rax
jz loc_B3F77
movzx edx, byte ptr [rcx]
mov rsi, rbx
shl rsi, 6
mov rdi, rbx
shr rdi, 2
add rsi, r15
add rsi, rdi
add rsi, rdx
xor rbx, rsi
inc rcx
jmp short loc_B3D3F
loc_B3D6A:
mov r15d, 9E3779B9h; jumptable 00000000000B3C80 case 1
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv; 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>::size(void)
mov rbx, rax
mov eax, r12d
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
add rbx, r15
add rbx, rcx
xor rbx, r12
lea r13, [rsp+138h+var_C0]
mov rdi, r13
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6cbeginEv; 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>::cbegin(void)
lea r12, [rsp+138h+var_130]
mov rdi, r12
mov rsi, r13
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESI_m; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,ulong)
lea r13, [rsp+138h+var_50]
mov rdi, r13
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4cendEv; 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>::cend(void)
lea rdi, [rsp+138h+var_C0]
mov rsi, r13
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESI_m; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,ulong)
loc_B3DD6:
mov rdi, r12
lea rsi, [rsp+138h+var_C0]
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jnz loc_B3F8C
mov rdi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEE3keyEv; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::key(void)
mov rdi, r13
mov rsi, rax
call _ZNKSt4hashINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclERKS5_; std::hash<std::string>::operator()(std::string const&)
mov r14, rax
mov rdi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rbp, rax
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
mov rax, rbx
shl rax, 6
mov rcx, rbx
shr rcx, 2
add rax, r15
add rax, rcx
add rax, r14
xor rax, rbx
mov rcx, rax
shl rcx, 6
mov rbx, rax
shr rbx, 2
add rcx, r15
add rbx, rbp
add rbx, rcx
xor rbx, rax
inc [rsp+138h+var_110]
jmp loc_B3DD6
loc_B3E5A:
mov r13d, 9E3779B9h; jumptable 00000000000B3C80 case 2
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv; 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>::size(void)
mov r15, rax
mov eax, r12d
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
add r15, r13
add r15, rcx
xor r15, r12
lea rbx, [rsp+138h+var_130]
mov rdi, rbx
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6cbeginEv; 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>::cbegin(void)
lea r12, [rsp+138h+var_C0]
mov rdi, r12
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4cendEv; 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>::cend(void)
mov rdi, rbx
mov rsi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jz loc_B3FA2
mov rbx, r15
jmp loc_B3F77
loc_B3EBD:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000B3C80 case 6
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
jmp short loc_B3F1B
loc_B3ED6:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000B3C80 case 4
mov byte ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,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>::boolean_t &)
movzx eax, byte ptr [rbx]
loc_B3EEC:
mov ecx, r12d
shl ecx, 6
mov edx, r12d
shr edx, 2
or edx, ecx
mov ebx, 9E3779B9h
add rbx, rax
jmp short loc_B3F71
loc_B3F04:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000B3C80 case 5
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
loc_B3F1B:
mov eax, r12d
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
add rcx, [rbx]
loc_B3F2C:
mov ebx, 9E3779B9h
add rbx, rcx
jmp short loc_B3F74
loc_B3F36:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000B3C80 case 7
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
movsd xmm0, qword ptr [rbx]
lea rdi, [rsp+138h+var_130]
call _ZNKSt4hashIdEclEd; std::hash<double>::operator()(double)
mov ecx, r12d
shl ecx, 6
mov edx, r12d
shr edx, 2
or edx, ecx
add rdx, rax
mov ebx, 9E3779B9h
loc_B3F71:
add rbx, rdx
loc_B3F74:
xor rbx, r12
loc_B3F77:
mov rax, rbx
add rsp, 108h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_B3F8C:
lea rdi, [rsp+138h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
lea rdi, [rsp+138h+var_130]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
jmp short loc_B3F77
loc_B3FA2:
lea r14, [rsp+138h+var_130]
lea r12, [rsp+138h+var_C0]
mov rbx, r15
loc_B3FAF:
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
shl rbx, 6
mov rcx, r15
shr rcx, 2
add rbx, r13
add rbx, rcx
add rbx, rax
xor rbx, r15
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
mov rdi, r14
mov rsi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
mov r15, rbx
test al, al
jz short loc_B3FAF
jmp short loc_B3F77
def_B3C80:
lea rdi, aWorkspaceLlm4b_0; jumptable 00000000000B3C80 default case
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAdvancedOption+0ABh; "false"
mov esi, 17D9h
xor eax, eax
call _ggml_abort
jmp short loc_B4017
jmp short $+2
loc_B4017:
mov rbx, rax
lea rdi, [rsp+138h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
lea rdi, [rsp+138h+var_130]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
mov rdi, rbx
call __Unwind_Resume
|
unsigned long long nlohmann::json_abi_v3_11_3::detail::hash<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>>(
unsigned __int8 *a1)
{
long long v1; // r12
unsigned __int8 *v2; // rcx
long long v3; // rax
long long v4; // rax
_QWORD *binary; // rax
unsigned long long v6; // rbx
unsigned long long v7; // r12
long long v8; // rax
long long v9; // rdx
unsigned long long v10; // rbx
unsigned __int8 **v11; // rax
unsigned __int8 *v12; // rcx
unsigned __int8 *v13; // rax
long long v14; // rax
long long v15; // r14
long long v16; // rax
long long v17; // rbp
unsigned long long v18; // r15
long long v19; // rdx
long long v20; // rbx
long long v21; // rbx
long long v23; // rax
long long v24; // rbx
unsigned __int8 *v25[4]; // [rsp+8h] [rbp-130h] BYREF
long long v26; // [rsp+28h] [rbp-110h]
_QWORD v27[14]; // [rsp+78h] [rbp-C0h] BYREF
_BYTE v28[80]; // [rsp+E8h] [rbp-50h] BYREF
v1 = *a1;
switch ( *a1 )
{
case 0u:
case 9u:
v2 = (unsigned __int8 *)(((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2));
goto LABEL_19;
case 1u:
v10 = v1 ^ ((((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2))
+ nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::size(a1)
+ 2654435769LL);
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>::cbegin(
(long long)v27,
a1);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::iteration_proxy_value(
v25,
v27,
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>::cend(
(long long)v28,
a1);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::iteration_proxy_value(
v27,
v28,
0LL);
while ( !(unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
v25,
v27) )
{
v14 = nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::key(v25);
v15 = std::hash<std::string>::operator()((long long)v28, v14);
v16 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(v25);
v17 = nlohmann::json_abi_v3_11_3::detail::hash<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>>(v16);
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(v25);
v10 ^= (v15 + (v10 >> 2) + (v10 << 6) + 2654435769u) ^ (((v10 ^ (v15 + (v10 >> 2) + (v10 << 6) + 2654435769u)) << 6)
+ 2654435769u
+ v17
+ ((v10 ^ (v15 + (v10 >> 2) + (v10 << 6) + 2654435769u)) >> 2));
++v26;
}
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(v27);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(v25);
return v10;
case 2u:
v18 = v1 ^ ((((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2))
+ nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::size(a1)
+ 2654435769LL);
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>::cbegin(
(long long)v25,
a1);
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>::cend(
(long long)v27,
a1);
if ( (unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
v25,
v27) )
return v18;
v10 = v18;
do
{
v23 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(v25);
v10 = v18 ^ (nlohmann::json_abi_v3_11_3::detail::hash<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>>(v23)
+ (v18 >> 2)
+ (v10 << 6)
+ 2654435769u);
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(v25);
v18 = v10;
}
while ( !(unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
v25,
v27) );
return v10;
case 3u:
v3 = 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>::get_ref_impl<std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>(a1);
v4 = std::hash<std::string>::operator()((long long)v25, v3);
goto LABEL_16;
case 4u:
LOBYTE(v25[0]) = 0;
nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
a1,
(unsigned __int8 *)v25);
v4 = LOBYTE(v25[0]);
LABEL_16:
v19 = ((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2);
v20 = v4 + 2654435769LL;
goto LABEL_21;
case 5u:
v25[0] = 0LL;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1,
v25);
goto LABEL_18;
case 6u:
v25[0] = 0LL;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1,
v25);
LABEL_18:
v2 = &v25[0][((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2)];
LABEL_19:
v21 = (long long)(v2 + 2654435769LL);
goto LABEL_22;
case 7u:
v25[0] = 0LL;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1,
(double *)v25);
v19 = std::hash<double>::operator()(v25, *(double *)v25) + (((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2));
v20 = 2654435769LL;
LABEL_21:
v21 = v19 + v20;
LABEL_22:
v10 = v1 ^ v21;
break;
case 8u:
binary = (_QWORD *)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>::get_binary(a1);
v6 = v1 ^ (binary[1] + (((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2)) + 2654435769LL - *binary);
v7 = v6 ^ ((*(unsigned __int8 *)(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>::get_binary(a1)
+ 32) | (v6 << 6))
+ (v6 >> 2)
+ 2654435769u);
v8 = 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>::get_binary(a1);
v9 = 2654435768LL;
if ( *(_BYTE *)(v8 + 32) )
v9 = *(_QWORD *)(v8 + 24) + 2654435769LL;
v10 = v7 ^ (v9 + (v7 << 6) + (v7 >> 2));
v11 = (unsigned __int8 **)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>::get_binary(a1);
v12 = *v11;
v13 = v11[1];
while ( v12 != v13 )
v10 ^= *v12++ + (v10 >> 2) + (v10 << 6) + 2654435769u;
break;
default:
v24 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6105LL,
"GGML_ASSERT(%s) failed",
"false");
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(v27);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(v25);
_Unwind_Resume(v24);
}
return v10;
}
|
hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x108
MOVZX R12D,byte ptr [RDI]
CMP R12,0x9
JA 0x001b3ff2
MOV R14,RDI
LEA RAX,[0x1f18e8]
MOVSXD RCX,dword ptr [RAX + R12*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_0:
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
JMP 0x001b3f2c
caseD_3:
MOV RDI,R14
CALL 0x001b411e
LEA RDI,[RSP + 0x8]
MOV RSI,RAX
CALL 0x00156648
JMP 0x001b3eec
caseD_8:
MOV R15D,0x9e3779b9
MOV RDI,R14
CALL 0x001b4068
MOV ECX,R12D
SHL ECX,0x6
MOV EBX,R12D
SHR EBX,0x2
OR EBX,ECX
ADD RBX,qword ptr [RAX + 0x8]
ADD RBX,R15
SUB RBX,qword ptr [RAX]
XOR RBX,R12
MOV RDI,R14
CALL 0x001b4068
MOVZX EAX,byte ptr [RAX + 0x20]
MOV RCX,RBX
SHL RCX,0x6
OR RCX,RAX
MOV R12,RBX
SHR R12,0x2
ADD R12,R15
ADD R12,RCX
XOR R12,RBX
MOV RDI,R14
CALL 0x001b4068
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,R15
LEA RDX,[R15 + -0x1]
CMP byte ptr [RAX + 0x20],0x0
CMOVNZ RDX,RCX
MOV RAX,R12
SHL RAX,0x6
ADD RAX,RDX
MOV RBX,R12
SHR RBX,0x2
ADD RBX,RAX
XOR RBX,R12
MOV RDI,R14
CALL 0x001b4068
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
LAB_001b3d3f:
CMP RCX,RAX
JZ 0x001b3f77
MOVZX EDX,byte ptr [RCX]
MOV RSI,RBX
SHL RSI,0x6
MOV RDI,RBX
SHR RDI,0x2
ADD RSI,R15
ADD RSI,RDI
ADD RSI,RDX
XOR RBX,RSI
INC RCX
JMP 0x001b3d3f
caseD_1:
MOV R15D,0x9e3779b9
MOV RDI,R14
CALL 0x0015e994
MOV RBX,RAX
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
ADD RBX,R15
ADD RBX,RCX
XOR RBX,R12
LEA R13,[RSP + 0x78]
MOV RDI,R13
MOV RSI,R14
CALL 0x0018eb4e
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R13
XOR EDX,EDX
CALL 0x001b7958
LEA R13,[RSP + 0xe8]
MOV RDI,R13
MOV RSI,R14
CALL 0x0018eeee
LEA RDI,[RSP + 0x78]
MOV RSI,R13
XOR EDX,EDX
CALL 0x001b7958
LAB_001b3dd6:
MOV RDI,R12
LEA RSI,[RSP + 0x78]
CALL 0x0018ec12
TEST AL,AL
JNZ 0x001b3f8c
LAB_001b3deb:
MOV RDI,R12
CALL 0x001ac8d0
MOV RDI,R13
MOV RSI,RAX
CALL 0x00156648
MOV R14,RAX
LAB_001b3e01:
MOV RDI,R12
CALL 0x0018e852
MOV RDI,RAX
CALL 0x001b3c50
LAB_001b3e11:
MOV RBP,RAX
MOV RDI,R12
CALL 0x0018e804
LAB_001b3e1c:
MOV RAX,RBX
SHL RAX,0x6
MOV RCX,RBX
SHR RCX,0x2
ADD RAX,R15
ADD RAX,RCX
ADD RAX,R14
XOR RAX,RBX
MOV RCX,RAX
SHL RCX,0x6
MOV RBX,RAX
SHR RBX,0x2
ADD RCX,R15
ADD RBX,RBP
ADD RBX,RCX
XOR RBX,RAX
INC qword ptr [RSP + 0x28]
JMP 0x001b3dd6
caseD_2:
MOV R13D,0x9e3779b9
MOV RDI,R14
CALL 0x0015e994
MOV R15,RAX
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
ADD R15,R13
ADD R15,RCX
XOR R15,R12
LEA RBX,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0018eb4e
LEA R12,[RSP + 0x78]
MOV RDI,R12
MOV RSI,R14
CALL 0x0018eeee
MOV RDI,RBX
MOV RSI,R12
CALL 0x0018ec12
TEST AL,AL
JZ 0x001b3fa2
MOV RBX,R15
JMP 0x001b3f77
caseD_6:
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x001b4261
JMP 0x001b3f1b
caseD_4:
LEA RBX,[RSP + 0x8]
MOV byte ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x001891e5
MOVZX EAX,byte ptr [RBX]
LAB_001b3eec:
MOV ECX,R12D
SHL ECX,0x6
MOV EDX,R12D
SHR EDX,0x2
OR EDX,ECX
MOV EBX,0x9e3779b9
ADD RBX,RAX
JMP 0x001b3f71
caseD_5:
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x001882f1
LAB_001b3f1b:
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
ADD RCX,qword ptr [RBX]
LAB_001b3f2c:
MOV EBX,0x9e3779b9
ADD RBX,RCX
JMP 0x001b3f74
caseD_7:
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00188e71
MOVSD XMM0,qword ptr [RBX]
LEA RDI,[RSP + 0x8]
CALL 0x001b4036
MOV ECX,R12D
SHL ECX,0x6
MOV EDX,R12D
SHR EDX,0x2
OR EDX,ECX
ADD RDX,RAX
MOV EBX,0x9e3779b9
LAB_001b3f71:
ADD RBX,RDX
LAB_001b3f74:
XOR RBX,R12
LAB_001b3f77:
MOV RAX,RBX
ADD RSP,0x108
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001b3f8c:
LEA RDI,[RSP + 0x78]
CALL 0x001ac93e
LEA RDI,[RSP + 0x8]
CALL 0x001ac93e
JMP 0x001b3f77
LAB_001b3fa2:
LEA R14,[RSP + 0x8]
LEA R12,[RSP + 0x78]
MOV RBX,R15
LAB_001b3faf:
MOV RDI,R14
CALL 0x0018e852
MOV RDI,RAX
CALL 0x001b3c50
SHL RBX,0x6
MOV RCX,R15
SHR RCX,0x2
ADD RBX,R13
ADD RBX,RCX
ADD RBX,RAX
XOR RBX,R15
MOV RDI,R14
CALL 0x0018e804
MOV RDI,R14
MOV RSI,R12
CALL 0x0018ec12
MOV R15,RBX
TEST AL,AL
JZ 0x001b3faf
JMP 0x001b3f77
default:
LEA RDI,[0x1eeca9]
LEA RDX,[0x1eecf3]
LEA RCX,[0x1ec7a3]
MOV ESI,0x17d9
XOR EAX,EAX
CALL 0x0011beb0
|
/* unsigned long
nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
ulong nlohmann::json_abi_v3_11_3::detail::
hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(basic_json *param_1)
{
basic_json bVar1;
char cVar2;
string *psVar3;
ulong uVar4;
long *plVar5;
long lVar6;
long lVar7;
int8 *puVar8;
basic_json *pbVar9;
byte *pbVar10;
ulong uVar11;
ulong uVar12;
double local_130 [4];
long local_110;
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
local_c0 [112];
hash<std::__cxx11::string> local_50 [32];
bVar1 = *param_1;
uVar11 = (ulong)(byte)bVar1;
switch(uVar11) {
case 0:
case 9:
uVar12 = (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6);
goto LAB_001b3f2c;
case 1:
lVar6 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::size((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar12 = lVar6 + 0x9e3779b9 + (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) ^
uVar11;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cbegin();
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::iteration_proxy_value
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)local_130,local_c0,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cend();
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::iteration_proxy_value(local_c0,local_50,0);
/* try { // try from 001b3dd6 to 001b3de2 has its CatchHandler @ 001b4017 */
while (cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)local_130,local_c0), cVar2 == '\0') {
/* try { // try from 001b3deb to 001b3df2 has its CatchHandler @ 001b4013 */
psVar3 = (string *)
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::key((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)local_130);
lVar6 = std::hash<std::__cxx11::string>::operator()(local_50,psVar3);
/* try { // try from 001b3e01 to 001b3e10 has its CatchHandler @ 001b4015 */
pbVar9 = (basic_json *)
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)local_130);
uVar11 = hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(pbVar9);
/* try { // try from 001b3e11 to 001b3e1b has its CatchHandler @ 001b4017 */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)local_130);
uVar12 = uVar12 * 0x40 + 0x9e3779b9 + (uVar12 >> 2) + lVar6 ^ uVar12;
uVar12 = (uVar12 >> 2) + uVar11 + uVar12 * 0x40 + 0x9e3779b9 ^ uVar12;
local_110 = local_110 + 1;
}
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::~iteration_proxy_value(local_c0);
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::~iteration_proxy_value
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)local_130);
break;
case 2:
lVar6 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::size((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar12 = lVar6 + 0x9e3779b9 + (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) ^
uVar11;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cbegin();
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cend();
cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
(local_130,local_c0);
if (cVar2 == '\0') {
do {
pbVar9 = (basic_json *)
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)local_130);
uVar11 = hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(pbVar9);
uVar12 = uVar12 * 0x40 + 0x9e3779b9 + (uVar12 >> 2) + uVar11 ^ uVar12;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)local_130);
cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)local_130,local_c0);
} while (cVar2 == '\0');
}
break;
case 3:
psVar3 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
get_ref_impl<std::__cxx11::string_const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
(param_1);
uVar4 = std::hash<std::__cxx11::string>::operator()
((hash<std::__cxx11::string> *)local_130,psVar3);
goto LAB_001b3eec;
case 4:
local_130[0] = (double)((ulong)local_130[0] & 0xffffffffffffff00);
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(param_1,(boolean_t *)local_130);
uVar4 = (ulong)local_130[0] & 0xff;
LAB_001b3eec:
uVar12 = (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6);
lVar6 = uVar4 + 0x9e3779b9;
LAB_001b3f71:
uVar12 = lVar6 + uVar12;
LAB_001b3f74:
uVar12 = uVar12 ^ uVar11;
break;
case 5:
local_130[0] = 0.0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(param_1,local_130);
goto LAB_001b3f1b;
case 6:
local_130[0] = 0.0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(param_1,local_130);
LAB_001b3f1b:
uVar12 = (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) + (long)local_130[0];
LAB_001b3f2c:
uVar12 = uVar12 + 0x9e3779b9;
goto LAB_001b3f74;
case 7:
local_130[0] = 0.0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(param_1,local_130);
lVar6 = std::hash<double>::operator()((hash<double> *)local_130,local_130[0]);
uVar12 = (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) + lVar6;
lVar6 = 0x9e3779b9;
goto LAB_001b3f71;
case 8:
plVar5 = (long *)basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar11 = ((ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) + plVar5[1] + 0x9e3779b9) -
*plVar5 ^ uVar11;
lVar6 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar11 = (uVar11 >> 2) + 0x9e3779b9 + (uVar11 << 6 | (ulong)*(byte *)(lVar6 + 0x20)) ^ uVar11;
lVar7 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
lVar6 = 0x9e3779b8;
if (*(char *)(lVar7 + 0x20) != '\0') {
lVar6 = *(long *)(lVar7 + 0x18) + 0x9e3779b9;
}
uVar12 = (uVar11 >> 2) + uVar11 * 0x40 + lVar6 ^ uVar11;
puVar8 = (int8 *)
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
for (pbVar10 = (byte *)*puVar8; pbVar10 != (byte *)puVar8[1]; pbVar10 = pbVar10 + 1) {
uVar12 = uVar12 ^ uVar12 * 0x40 + 0x9e3779b9 + (uVar12 >> 2) + (ulong)*pbVar10;
}
break;
default:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x17d9,
"GGML_ASSERT(%s) failed","false");
}
return uVar12;
}
|
|
64,785 |
nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&)
|
monkey531[P]llama/common/json.hpp
|
constexpr value_t type() const noexcept
{
return m_data.m_type;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movzbl (%rdi), %r12d
cmpq $0x9, %r12
ja 0xb262b
movq %rdi, %r14
leaq 0x3c66e(%rip), %rax # 0xee8d8
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
jmp 0xb2565
movq %r14, %rdi
callq 0xb2756
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x55f1a
jmp 0xb2525
movl $0x9e3779b9, %r15d # imm = 0x9E3779B9
movq %r14, %rdi
callq 0xb26a2
movl %r12d, %ecx
shll $0x6, %ecx
movl %r12d, %ebx
shrl $0x2, %ebx
orl %ecx, %ebx
addq 0x8(%rax), %rbx
addq %r15, %rbx
subq (%rax), %rbx
xorq %r12, %rbx
movq %r14, %rdi
callq 0xb26a2
movzbl 0x20(%rax), %eax
movq %rbx, %rcx
shlq $0x6, %rcx
orq %rax, %rcx
movq %rbx, %r12
shrq $0x2, %r12
addq %r15, %r12
addq %rcx, %r12
xorq %rbx, %r12
movq %r14, %rdi
callq 0xb26a2
movq 0x18(%rax), %rcx
addq %r15, %rcx
leaq -0x1(%r15), %rdx
cmpb $0x0, 0x20(%rax)
cmovneq %rcx, %rdx
movq %r12, %rax
shlq $0x6, %rax
addq %rdx, %rax
movq %r12, %rbx
shrq $0x2, %rbx
addq %rax, %rbx
xorq %r12, %rbx
movq %r14, %rdi
callq 0xb26a2
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
je 0xb25b0
movzbl (%rcx), %edx
movq %rbx, %rsi
shlq $0x6, %rsi
movq %rbx, %rdi
shrq $0x2, %rdi
addq %r15, %rsi
addq %rdi, %rsi
addq %rdx, %rsi
xorq %rsi, %rbx
incq %rcx
jmp 0xb2330
movl $0x9e3779b9, %r15d # imm = 0x9E3779B9
movq %r14, %rdi
callq 0x5e0ae
movq %rax, %rbx
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
addq %r15, %rbx
addq %rcx, %rbx
xorq %r12, %rbx
leaq 0x78(%rsp), %r13
movq %r14, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r13)
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
movq %rbp, 0x18(%r13)
movq %r13, %rdi
callq 0x8d554
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xb6068
leaq 0xe8(%rsp), %r13
movq %r14, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r13)
movq %rbp, 0x18(%r13)
movq %r13, %rdi
callq 0x8d89e
leaq 0x78(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xb6068
movq %r12, %rdi
leaq 0x78(%rsp), %rsi
callq 0x8d5c6
testb %al, %al
jne 0xb25c5
movq %r12, %rdi
callq 0xaaf56
movq %r13, %rdi
movq %rax, %rsi
callq 0x55f1a
movq %rax, %r14
movq %r12, %rdi
callq 0x8d25a
movq %rax, %rdi
callq 0xb2241
movq %rax, %rbp
movq %r12, %rdi
callq 0x8d20c
movq %rbx, %rax
shlq $0x6, %rax
movq %rbx, %rcx
shrq $0x2, %rcx
addq %r15, %rax
addq %rcx, %rax
addq %r14, %rax
xorq %rbx, %rax
movq %rax, %rcx
shlq $0x6, %rcx
movq %rax, %rbx
shrq $0x2, %rbx
addq %r15, %rcx
addq %rbp, %rbx
addq %rcx, %rbx
xorq %rax, %rbx
incq 0x28(%rsp)
jmp 0xb23eb
movl $0x9e3779b9, %r13d # imm = 0x9E3779B9
movq %r14, %rdi
callq 0x5e0ae
movq %rax, %r15
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
addq %r13, %r15
addq %rcx, %r15
xorq %r12, %r15
leaq 0x8(%rsp), %rbx
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
movq %rbp, 0x18(%rbx)
movq %rbx, %rdi
callq 0x8d554
leaq 0x78(%rsp), %r12
movq %r14, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r12)
movq %rbp, 0x18(%r12)
movq %r12, %rdi
callq 0x8d89e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8d5c6
testb %al, %al
je 0xb25db
movq %r15, %rbx
jmp 0xb25b0
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb2896
jmp 0xb2554
leaq 0x8(%rsp), %rbx
movb $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x87d15
movzbl (%rbx), %eax
movl %r12d, %ecx
shll $0x6, %ecx
movl %r12d, %edx
shrl $0x2, %edx
orl %ecx, %edx
movl $0x9e3779b9, %ebx # imm = 0x9E3779B9
addq %rax, %rbx
jmp 0xb25aa
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x86dbd
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
addq (%rbx), %rcx
movl $0x9e3779b9, %ebx # imm = 0x9E3779B9
addq %rcx, %rbx
jmp 0xb25ad
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8796f
movsd (%rbx), %xmm0
leaq 0x8(%rsp), %rdi
callq 0xb2670
movl %r12d, %ecx
shll $0x6, %ecx
movl %r12d, %edx
shrl $0x2, %edx
orl %ecx, %edx
addq %rax, %rdx
movl $0x9e3779b9, %ebx # imm = 0x9E3779B9
addq %rdx, %rbx
xorq %r12, %rbx
movq %rbx, %rax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x78(%rsp), %rdi
callq 0xaafc4
leaq 0x8(%rsp), %rdi
callq 0xaafc4
jmp 0xb25b0
leaq 0x8(%rsp), %r14
leaq 0x78(%rsp), %r12
movq %r15, %rbx
movq %r14, %rdi
callq 0x8d25a
movq %rax, %rdi
callq 0xb2241
shlq $0x6, %rbx
movq %r15, %rcx
shrq $0x2, %rcx
addq %r13, %rbx
addq %rcx, %rbx
addq %rax, %rbx
xorq %r15, %rbx
movq %r14, %rdi
callq 0x8d20c
movq %r14, %rdi
movq %r12, %rsi
callq 0x8d5c6
movq %rbx, %r15
testb %al, %al
je 0xb25e8
jmp 0xb25b0
leaq 0x39677(%rip), %rdi # 0xebca9
leaq 0x396ba(%rip), %rdx # 0xebcf3
leaq 0x37163(%rip), %rcx # 0xe97a3
movl $0x17d9, %esi # imm = 0x17D9
xorl %eax, %eax
callq 0x1aeb0
jmp 0xb2650
jmp 0xb2650
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xaafc4
leaq 0x8(%rsp), %rdi
callq 0xaafc4
movq %rbx, %rdi
callq 0x1afb0
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 108h
movzx r12d, byte ptr [rdi]
cmp r12, 9; switch 10 cases
ja def_B2271; jumptable 00000000000B2271 default case
mov r14, rdi
lea rax, jpt_B2271
movsxd rcx, ds:(jpt_B2271 - 0EE8D8h)[rax+r12*4]
add rcx, rax
jmp rcx; switch jump
loc_B2273:
mov eax, r12d; jumptable 00000000000B2271 cases 0,9
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
jmp loc_B2565
loc_B2286:
mov rdi, r14; jumptable 00000000000B2271 case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRKS9_KSD_EET_RT0_; 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>::get_ref_impl<std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const &)
lea rdi, [rsp+138h+var_130]
mov rsi, rax
call _ZNKSt4hashINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclERKS5_; std::hash<std::string>::operator()(std::string const&)
jmp loc_B2525
loc_B22A0:
mov r15d, 9E3779B9h; jumptable 00000000000B2271 case 8
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; 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>::get_binary(void)
mov ecx, r12d
shl ecx, 6
mov ebx, r12d
shr ebx, 2
or ebx, ecx
add rbx, [rax+8]
add rbx, r15
sub rbx, [rax]
xor rbx, r12
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; 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>::get_binary(void)
movzx eax, byte ptr [rax+20h]
mov rcx, rbx
shl rcx, 6
or rcx, rax
mov r12, rbx
shr r12, 2
add r12, r15
add r12, rcx
xor r12, rbx
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; 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>::get_binary(void)
mov rcx, [rax+18h]
add rcx, r15
lea rdx, [r15-1]
cmp byte ptr [rax+20h], 0
cmovnz rdx, rcx
mov rax, r12
shl rax, 6
add rax, rdx
mov rbx, r12
shr rbx, 2
add rbx, rax
xor rbx, r12
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; 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>::get_binary(void)
mov rcx, [rax]
mov rax, [rax+8]
loc_B2330:
cmp rcx, rax
jz loc_B25B0
movzx edx, byte ptr [rcx]
mov rsi, rbx
shl rsi, 6
mov rdi, rbx
shr rdi, 2
add rsi, r15
add rsi, rdi
add rsi, rdx
xor rbx, rsi
inc rcx
jmp short loc_B2330
loc_B235B:
mov r15d, 9E3779B9h; jumptable 00000000000B2271 case 1
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv; 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>::size(void)
mov rbx, rax
mov eax, r12d
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
add rbx, r15
add rbx, rcx
xor rbx, r12
lea r13, [rsp+138h+var_C0]
mov [r13+0], r14
xorps xmm0, xmm0
movups xmmword ptr [r13+8], xmm0
mov rbp, 8000000000000000h
mov [r13+18h], rbp
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9set_beginEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_begin(void)
lea r12, [rsp+138h+var_130]
mov rdi, r12
mov rsi, r13
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESI_m; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,ulong)
lea r13, [rsp+138h+var_50]
mov [r13+0], r14
xorps xmm0, xmm0
movups xmmword ptr [r13+8], xmm0
mov [r13+18h], rbp
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_end(void)
lea rdi, [rsp+138h+var_C0]
mov rsi, r13
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESI_m; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,ulong)
loc_B23EB:
mov rdi, r12
lea rsi, [rsp+138h+var_C0]
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jnz loc_B25C5
mov rdi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEE3keyEv; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::key(void)
mov rdi, r13
mov rsi, rax
call _ZNKSt4hashINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclERKS5_; std::hash<std::string>::operator()(std::string const&)
mov r14, rax
mov rdi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rbp, rax
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
mov rax, rbx
shl rax, 6
mov rcx, rbx
shr rcx, 2
add rax, r15
add rax, rcx
add rax, r14
xor rax, rbx
mov rcx, rax
shl rcx, 6
mov rbx, rax
shr rbx, 2
add rcx, r15
add rbx, rbp
add rbx, rcx
xor rbx, rax
inc [rsp+138h+var_110]
jmp loc_B23EB
loc_B246F:
mov r13d, 9E3779B9h; jumptable 00000000000B2271 case 2
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv; 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>::size(void)
mov r15, rax
mov eax, r12d
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
add r15, r13
add r15, rcx
xor r15, r12
lea rbx, [rsp+138h+var_130]
mov [rbx], r14
xorps xmm0, xmm0
movups xmmword ptr [rbx+8], xmm0
mov rbp, 8000000000000000h
mov [rbx+18h], rbp
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9set_beginEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_begin(void)
lea r12, [rsp+138h+var_C0]
mov [r12], r14
xorps xmm0, xmm0
movups xmmword ptr [r12+8], xmm0
mov [r12+18h], rbp
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_end(void)
mov rdi, rbx
mov rsi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jz loc_B25DB
mov rbx, r15
jmp loc_B25B0
loc_B24F6:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000B2271 case 6
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
jmp short loc_B2554
loc_B250F:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000B2271 case 4
mov byte ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,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>::boolean_t &)
movzx eax, byte ptr [rbx]
loc_B2525:
mov ecx, r12d
shl ecx, 6
mov edx, r12d
shr edx, 2
or edx, ecx
mov ebx, 9E3779B9h
add rbx, rax
jmp short loc_B25AA
loc_B253D:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000B2271 case 5
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
loc_B2554:
mov eax, r12d
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
add rcx, [rbx]
loc_B2565:
mov ebx, 9E3779B9h
add rbx, rcx
jmp short loc_B25AD
loc_B256F:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000B2271 case 7
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
movsd xmm0, qword ptr [rbx]
lea rdi, [rsp+138h+var_130]
call _ZNKSt4hashIdEclEd; std::hash<double>::operator()(double)
mov ecx, r12d
shl ecx, 6
mov edx, r12d
shr edx, 2
or edx, ecx
add rdx, rax
mov ebx, 9E3779B9h
loc_B25AA:
add rbx, rdx
loc_B25AD:
xor rbx, r12
loc_B25B0:
mov rax, rbx
add rsp, 108h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_B25C5:
lea rdi, [rsp+138h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
lea rdi, [rsp+138h+var_130]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
jmp short loc_B25B0
loc_B25DB:
lea r14, [rsp+138h+var_130]
lea r12, [rsp+138h+var_C0]
mov rbx, r15
loc_B25E8:
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
shl rbx, 6
mov rcx, r15
shr rcx, 2
add rbx, r13
add rbx, rcx
add rbx, rax
xor rbx, r15
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
mov rdi, r14
mov rsi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
mov r15, rbx
test al, al
jz short loc_B25E8
jmp short loc_B25B0
def_B2271:
lea rdi, aWorkspaceLlm4b_0; jumptable 00000000000B2271 default case
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAdvancedOption+0ABh; "false"
mov esi, 17D9h
xor eax, eax
call _ggml_abort
jmp short loc_B2650
jmp short $+2
loc_B2650:
mov rbx, rax
lea rdi, [rsp+138h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
lea rdi, [rsp+138h+var_130]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
mov rdi, rbx
call __Unwind_Resume
|
unsigned long long nlohmann::json_abi_v3_11_3::detail::hash<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>>(
unsigned __int8 *a1)
{
long long v1; // r12
unsigned __int8 *v2; // rcx
long long v3; // rax
long long v4; // rax
_QWORD *binary; // rax
unsigned long long v6; // rbx
unsigned long long v7; // r12
long long v8; // rax
long long v9; // rdx
unsigned long long v10; // rbx
unsigned __int8 **v11; // rax
unsigned __int8 *v12; // rcx
unsigned __int8 *v13; // rax
long long v14; // rax
long long v15; // r14
long long v16; // rax
long long v17; // rbp
unsigned long long v18; // r15
long long v19; // rdx
long long v20; // rbx
long long v21; // rbx
long long v23; // rax
long long v24; // rbx
unsigned __int8 *v25; // [rsp+8h] [rbp-130h] BYREF
__int128 v26; // [rsp+10h] [rbp-128h]
unsigned long long v27; // [rsp+20h] [rbp-118h]
long long v28; // [rsp+28h] [rbp-110h]
unsigned __int8 *v29; // [rsp+78h] [rbp-C0h] BYREF
__int128 v30; // [rsp+80h] [rbp-B8h]
unsigned long long v31; // [rsp+90h] [rbp-A8h]
unsigned __int8 *v32; // [rsp+E8h] [rbp-50h] BYREF
__int128 v33; // [rsp+F0h] [rbp-48h]
unsigned long long v34; // [rsp+100h] [rbp-38h]
v1 = *a1;
switch ( *a1 )
{
case 0u:
case 9u:
v2 = (unsigned __int8 *)(((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2));
goto LABEL_19;
case 1u:
v10 = v1 ^ ((((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2))
+ nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::size(a1)
+ 2654435769LL);
v29 = a1;
v30 = 0LL;
v31 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_begin(&v29);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::iteration_proxy_value(
&v25,
&v29,
0LL);
v32 = a1;
v33 = 0LL;
v34 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_end(&v32);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::iteration_proxy_value(
&v29,
&v32,
0LL);
while ( !(unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
&v25,
&v29) )
{
v14 = nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::key(&v25);
v15 = std::hash<std::string>::operator()((long long)&v32, v14);
v16 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v25);
v17 = nlohmann::json_abi_v3_11_3::detail::hash<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>>(v16);
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(&v25);
v10 ^= (v15 + (v10 >> 2) + (v10 << 6) + 2654435769u) ^ (((v10 ^ (v15 + (v10 >> 2) + (v10 << 6) + 2654435769u)) << 6)
+ 2654435769u
+ v17
+ ((v10 ^ (v15 + (v10 >> 2) + (v10 << 6) + 2654435769u)) >> 2));
++v28;
}
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(&v29);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(&v25);
return v10;
case 2u:
v18 = v1 ^ ((((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2))
+ nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::size(a1)
+ 2654435769LL);
v25 = a1;
v26 = 0LL;
v27 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_begin(&v25);
v29 = a1;
v30 = 0LL;
v31 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_end(&v29);
if ( (unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
&v25,
&v29) )
return v18;
v10 = v18;
do
{
v23 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v25);
v10 = v18 ^ (nlohmann::json_abi_v3_11_3::detail::hash<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>>(v23)
+ (v18 >> 2)
+ (v10 << 6)
+ 2654435769u);
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(&v25);
v18 = v10;
}
while ( !(unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
&v25,
&v29) );
return v10;
case 3u:
v3 = 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>::get_ref_impl<std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>(a1);
v4 = std::hash<std::string>::operator()((long long)&v25, v3);
goto LABEL_16;
case 4u:
LOBYTE(v25) = 0;
nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
a1,
(unsigned __int8 *)&v25);
v4 = (unsigned __int8)v25;
LABEL_16:
v19 = ((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2);
v20 = v4 + 2654435769LL;
goto LABEL_21;
case 5u:
v25 = 0LL;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1,
&v25);
goto LABEL_18;
case 6u:
v25 = 0LL;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1,
&v25);
LABEL_18:
v2 = &v25[((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2)];
LABEL_19:
v21 = (long long)(v2 + 2654435769LL);
goto LABEL_22;
case 7u:
v25 = 0LL;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1,
(double *)&v25);
v19 = std::hash<double>::operator()(&v25, *(double *)&v25) + (((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2));
v20 = 2654435769LL;
LABEL_21:
v21 = v19 + v20;
LABEL_22:
v10 = v1 ^ v21;
break;
case 8u:
binary = (_QWORD *)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>::get_binary(a1);
v6 = v1 ^ (binary[1] + (((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2)) + 2654435769LL - *binary);
v7 = v6 ^ ((*(unsigned __int8 *)(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>::get_binary(a1)
+ 32) | (v6 << 6))
+ (v6 >> 2)
+ 2654435769u);
v8 = 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>::get_binary(a1);
v9 = 2654435768LL;
if ( *(_BYTE *)(v8 + 32) )
v9 = *(_QWORD *)(v8 + 24) + 2654435769LL;
v10 = v7 ^ (v9 + (v7 << 6) + (v7 >> 2));
v11 = (unsigned __int8 **)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>::get_binary(a1);
v12 = *v11;
v13 = v11[1];
while ( v12 != v13 )
v10 ^= *v12++ + (v10 >> 2) + (v10 << 6) + 2654435769u;
break;
default:
v24 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6105LL,
"GGML_ASSERT(%s) failed",
"false");
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(&v29);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(&v25);
_Unwind_Resume(v24);
}
return v10;
}
|
hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x108
MOVZX R12D,byte ptr [RDI]
CMP R12,0x9
JA 0x001b262b
MOV R14,RDI
LEA RAX,[0x1ee8d8]
MOVSXD RCX,dword ptr [RAX + R12*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_0:
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
JMP 0x001b2565
caseD_3:
MOV RDI,R14
CALL 0x001b2756
LEA RDI,[RSP + 0x8]
MOV RSI,RAX
CALL 0x00155f1a
JMP 0x001b2525
caseD_8:
MOV R15D,0x9e3779b9
MOV RDI,R14
CALL 0x001b26a2
MOV ECX,R12D
SHL ECX,0x6
MOV EBX,R12D
SHR EBX,0x2
OR EBX,ECX
ADD RBX,qword ptr [RAX + 0x8]
ADD RBX,R15
SUB RBX,qword ptr [RAX]
XOR RBX,R12
MOV RDI,R14
CALL 0x001b26a2
MOVZX EAX,byte ptr [RAX + 0x20]
MOV RCX,RBX
SHL RCX,0x6
OR RCX,RAX
MOV R12,RBX
SHR R12,0x2
ADD R12,R15
ADD R12,RCX
XOR R12,RBX
MOV RDI,R14
CALL 0x001b26a2
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,R15
LEA RDX,[R15 + -0x1]
CMP byte ptr [RAX + 0x20],0x0
CMOVNZ RDX,RCX
MOV RAX,R12
SHL RAX,0x6
ADD RAX,RDX
MOV RBX,R12
SHR RBX,0x2
ADD RBX,RAX
XOR RBX,R12
MOV RDI,R14
CALL 0x001b26a2
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
LAB_001b2330:
CMP RCX,RAX
JZ 0x001b25b0
MOVZX EDX,byte ptr [RCX]
MOV RSI,RBX
SHL RSI,0x6
MOV RDI,RBX
SHR RDI,0x2
ADD RSI,R15
ADD RSI,RDI
ADD RSI,RDX
XOR RBX,RSI
INC RCX
JMP 0x001b2330
caseD_1:
MOV R15D,0x9e3779b9
MOV RDI,R14
CALL 0x0015e0ae
MOV RBX,RAX
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
ADD RBX,R15
ADD RBX,RCX
XOR RBX,R12
LEA R13,[RSP + 0x78]
MOV qword ptr [R13],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x8],XMM0
MOV RBP,-0x8000000000000000
MOV qword ptr [R13 + 0x18],RBP
MOV RDI,R13
CALL 0x0018d554
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R13
XOR EDX,EDX
CALL 0x001b6068
LEA R13,[RSP + 0xe8]
MOV qword ptr [R13],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x8],XMM0
MOV qword ptr [R13 + 0x18],RBP
MOV RDI,R13
CALL 0x0018d89e
LEA RDI,[RSP + 0x78]
MOV RSI,R13
XOR EDX,EDX
CALL 0x001b6068
LAB_001b23eb:
MOV RDI,R12
LEA RSI,[RSP + 0x78]
CALL 0x0018d5c6
TEST AL,AL
JNZ 0x001b25c5
LAB_001b2400:
MOV RDI,R12
CALL 0x001aaf56
MOV RDI,R13
MOV RSI,RAX
CALL 0x00155f1a
MOV R14,RAX
LAB_001b2416:
MOV RDI,R12
CALL 0x0018d25a
MOV RDI,RAX
CALL 0x001b2241
LAB_001b2426:
MOV RBP,RAX
MOV RDI,R12
CALL 0x0018d20c
LAB_001b2431:
MOV RAX,RBX
SHL RAX,0x6
MOV RCX,RBX
SHR RCX,0x2
ADD RAX,R15
ADD RAX,RCX
ADD RAX,R14
XOR RAX,RBX
MOV RCX,RAX
SHL RCX,0x6
MOV RBX,RAX
SHR RBX,0x2
ADD RCX,R15
ADD RBX,RBP
ADD RBX,RCX
XOR RBX,RAX
INC qword ptr [RSP + 0x28]
JMP 0x001b23eb
caseD_2:
MOV R13D,0x9e3779b9
MOV RDI,R14
CALL 0x0015e0ae
MOV R15,RAX
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
ADD R15,R13
ADD R15,RCX
XOR R15,R12
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x8],XMM0
MOV RBP,-0x8000000000000000
MOV qword ptr [RBX + 0x18],RBP
MOV RDI,RBX
CALL 0x0018d554
LEA R12,[RSP + 0x78]
MOV qword ptr [R12],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12 + 0x8],XMM0
MOV qword ptr [R12 + 0x18],RBP
MOV RDI,R12
CALL 0x0018d89e
MOV RDI,RBX
MOV RSI,R12
CALL 0x0018d5c6
TEST AL,AL
JZ 0x001b25db
MOV RBX,R15
JMP 0x001b25b0
caseD_6:
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x001b2896
JMP 0x001b2554
caseD_4:
LEA RBX,[RSP + 0x8]
MOV byte ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00187d15
MOVZX EAX,byte ptr [RBX]
LAB_001b2525:
MOV ECX,R12D
SHL ECX,0x6
MOV EDX,R12D
SHR EDX,0x2
OR EDX,ECX
MOV EBX,0x9e3779b9
ADD RBX,RAX
JMP 0x001b25aa
caseD_5:
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00186dbd
LAB_001b2554:
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
ADD RCX,qword ptr [RBX]
LAB_001b2565:
MOV EBX,0x9e3779b9
ADD RBX,RCX
JMP 0x001b25ad
caseD_7:
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x0018796f
MOVSD XMM0,qword ptr [RBX]
LEA RDI,[RSP + 0x8]
CALL 0x001b2670
MOV ECX,R12D
SHL ECX,0x6
MOV EDX,R12D
SHR EDX,0x2
OR EDX,ECX
ADD RDX,RAX
MOV EBX,0x9e3779b9
LAB_001b25aa:
ADD RBX,RDX
LAB_001b25ad:
XOR RBX,R12
LAB_001b25b0:
MOV RAX,RBX
ADD RSP,0x108
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001b25c5:
LEA RDI,[RSP + 0x78]
CALL 0x001aafc4
LEA RDI,[RSP + 0x8]
CALL 0x001aafc4
JMP 0x001b25b0
LAB_001b25db:
LEA R14,[RSP + 0x8]
LEA R12,[RSP + 0x78]
MOV RBX,R15
LAB_001b25e8:
MOV RDI,R14
CALL 0x0018d25a
MOV RDI,RAX
CALL 0x001b2241
SHL RBX,0x6
MOV RCX,R15
SHR RCX,0x2
ADD RBX,R13
ADD RBX,RCX
ADD RBX,RAX
XOR RBX,R15
MOV RDI,R14
CALL 0x0018d20c
MOV RDI,R14
MOV RSI,R12
CALL 0x0018d5c6
MOV R15,RBX
TEST AL,AL
JZ 0x001b25e8
JMP 0x001b25b0
default:
LEA RDI,[0x1ebca9]
LEA RDX,[0x1ebcf3]
LEA RCX,[0x1e97a3]
MOV ESI,0x17d9
XOR EAX,EAX
CALL 0x0011aeb0
|
/* unsigned long
nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
ulong nlohmann::json_abi_v3_11_3::detail::
hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(basic_json *param_1)
{
basic_json bVar1;
char cVar2;
string *psVar3;
ulong uVar4;
long *plVar5;
long lVar6;
long lVar7;
int8 *puVar8;
byte *pbVar9;
ulong uVar10;
basic_json *pbVar11;
ulong uVar12;
basic_json *local_130;
int8 local_128;
int8 uStack_120;
int8 local_118;
long local_110;
basic_json *local_c0;
int8 local_b8;
int8 uStack_b0;
int8 local_a8;
basic_json *local_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
bVar1 = *param_1;
uVar12 = (ulong)(byte)bVar1;
local_c0 = param_1;
switch(uVar12) {
case 0:
case 9:
pbVar11 = (basic_json *)(ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6);
goto LAB_001b2565;
case 1:
lVar6 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::size((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar12 = lVar6 + 0x9e3779b9 + (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) ^
uVar12;
local_b8 = 0;
uStack_b0 = 0;
local_a8 = 0x8000000000000000;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_begin((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_c0);
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::iteration_proxy_value
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_130,
(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_c0,0);
local_48 = 0;
uStack_40 = 0;
local_38 = 0x8000000000000000;
local_50 = param_1;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_end((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50);
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::iteration_proxy_value
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_c0,
(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50,0);
/* try { // try from 001b23eb to 001b23f7 has its CatchHandler @ 001b2650 */
while (cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_130,&local_c0), cVar2 == '\0') {
/* try { // try from 001b2400 to 001b2407 has its CatchHandler @ 001b264c */
psVar3 = (string *)
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::key((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_130);
lVar6 = std::hash<std::__cxx11::string>::operator()
((hash<std::__cxx11::string> *)&local_50,psVar3);
/* try { // try from 001b2416 to 001b2425 has its CatchHandler @ 001b264e */
pbVar11 = (basic_json *)
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130);
uVar10 = hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(pbVar11);
/* try { // try from 001b2426 to 001b2430 has its CatchHandler @ 001b2650 */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130);
uVar12 = uVar12 * 0x40 + 0x9e3779b9 + (uVar12 >> 2) + lVar6 ^ uVar12;
uVar12 = (uVar12 >> 2) + uVar10 + uVar12 * 0x40 + 0x9e3779b9 ^ uVar12;
local_110 = local_110 + 1;
}
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::~iteration_proxy_value
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_c0);
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::~iteration_proxy_value
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_130);
break;
case 2:
lVar6 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::size((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar12 = lVar6 + 0x9e3779b9 + (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) ^
uVar12;
local_128 = 0;
uStack_120 = 0;
local_118 = 0x8000000000000000;
local_130 = param_1;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_begin((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130);
local_b8 = 0;
uStack_b0 = 0;
local_a8 = 0x8000000000000000;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_end((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_c0);
cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130,
(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_c0);
if (cVar2 == '\0') {
do {
pbVar11 = (basic_json *)
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130);
uVar10 = hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(pbVar11);
uVar12 = uVar12 * 0x40 + 0x9e3779b9 + (uVar12 >> 2) + uVar10 ^ uVar12;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130);
cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130,&local_c0);
} while (cVar2 == '\0');
}
break;
case 3:
psVar3 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
get_ref_impl<std::__cxx11::string_const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
(param_1);
uVar4 = std::hash<std::__cxx11::string>::operator()
((hash<std::__cxx11::string> *)&local_130,psVar3);
goto LAB_001b2525;
case 4:
local_130 = (basic_json *)((ulong)local_130 & 0xffffffffffffff00);
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(param_1,(boolean_t *)&local_130);
uVar4 = (ulong)local_130 & 0xff;
LAB_001b2525:
uVar10 = (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6);
lVar6 = uVar4 + 0x9e3779b9;
LAB_001b25aa:
pbVar11 = (basic_json *)(lVar6 + uVar10);
LAB_001b25ad:
uVar12 = (ulong)pbVar11 ^ uVar12;
break;
case 5:
local_130 = (basic_json *)0x0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(param_1,&local_130);
goto LAB_001b2554;
case 6:
local_130 = (basic_json *)0x0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(param_1,&local_130);
LAB_001b2554:
pbVar11 = local_130 + ((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6);
LAB_001b2565:
pbVar11 = pbVar11 + 0x9e3779b9;
goto LAB_001b25ad;
case 7:
local_130 = (basic_json *)0x0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(param_1,&local_130);
lVar6 = std::hash<double>::operator()((hash<double> *)&local_130,(double)local_130);
uVar10 = (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) + lVar6;
lVar6 = 0x9e3779b9;
goto LAB_001b25aa;
case 8:
plVar5 = (long *)basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar12 = ((ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) + plVar5[1] + 0x9e3779b9) -
*plVar5 ^ uVar12;
lVar6 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar12 = (uVar12 >> 2) + 0x9e3779b9 + (uVar12 << 6 | (ulong)*(byte *)(lVar6 + 0x20)) ^ uVar12;
lVar7 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
lVar6 = 0x9e3779b8;
if (*(char *)(lVar7 + 0x20) != '\0') {
lVar6 = *(long *)(lVar7 + 0x18) + 0x9e3779b9;
}
uVar12 = (uVar12 >> 2) + uVar12 * 0x40 + lVar6 ^ uVar12;
puVar8 = (int8 *)
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
for (pbVar9 = (byte *)*puVar8; pbVar9 != (byte *)puVar8[1]; pbVar9 = pbVar9 + 1) {
uVar12 = uVar12 ^ uVar12 * 0x40 + 0x9e3779b9 + (uVar12 >> 2) + (ulong)*pbVar9;
}
break;
default:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x17d9,
"GGML_ASSERT(%s) failed","false");
}
return uVar12;
}
|
|
64,786 |
get_bool_argument
|
eloqsql/mysys/my_getopt.c
|
static my_bool get_bool_argument(const struct my_option *opts,
const char *argument)
{
DBUG_ENTER("get_bool_argument");
if (!my_strcasecmp(&my_charset_latin1, argument, "true") ||
!my_strcasecmp(&my_charset_latin1, argument, "on") ||
!my_strcasecmp(&my_charset_latin1, argument, "1"))
DBUG_RETURN(1);
else if (!my_strcasecmp(&my_charset_latin1, argument, "false") ||
!my_strcasecmp(&my_charset_latin1, argument, "off") ||
!my_strcasecmp(&my_charset_latin1, argument, "0"))
DBUG_RETURN(0);
my_getopt_error_reporter(WARNING_LEVEL,
"option '%s': boolean value '%s' wasn't recognized. Set to OFF.",
opts->name, argument);
DBUG_RETURN(0);
}
|
O0
|
c
|
get_bool_argument:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x25e619(%rip), %rax # 0x2da160
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rsi
leaq 0x25e603(%rip), %rdi # 0x2da160
leaq 0x52b84(%rip), %rdx # 0xce6e8
callq *%rax
cmpl $0x0, %eax
je 0x7bbc1
leaq 0x25e5ee(%rip), %rax # 0x2da160
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rsi
leaq 0x25e5d8(%rip), %rdi # 0x2da160
leaq 0x541df(%rip), %rdx # 0xcfd6e
callq *%rax
cmpl $0x0, %eax
je 0x7bbc1
leaq 0x25e5c3(%rip), %rax # 0x2da160
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rsi
leaq 0x25e5ad(%rip), %rdi # 0x2da160
leaq 0x516e0(%rip), %rdx # 0xcd29a
callq *%rax
cmpl $0x0, %eax
jne 0x7bbcc
jmp 0x7bbc3
movb $0x1, -0x1(%rbp)
jmp 0x7bc81
leaq 0x25e58d(%rip), %rax # 0x2da160
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rsi
leaq 0x25e577(%rip), %rdi # 0x2da160
leaq 0x52afd(%rip), %rdx # 0xce6ed
callq *%rax
cmpl $0x0, %eax
je 0x7bc4d
leaq 0x25e562(%rip), %rax # 0x2da160
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rsi
leaq 0x25e54c(%rip), %rdi # 0x2da160
leaq 0x52ad8(%rip), %rdx # 0xce6f3
callq *%rax
cmpl $0x0, %eax
je 0x7bc4d
leaq 0x25e537(%rip), %rax # 0x2da160
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rsi
leaq 0x25e521(%rip), %rdi # 0x2da160
leaq 0x4f48e(%rip), %rdx # 0xcb0d4
callq *%rax
cmpl $0x0, %eax
jne 0x7bc55
jmp 0x7bc4f
movb $0x0, -0x1(%rbp)
jmp 0x7bc81
jmp 0x7bc57
leaq 0x1b7d32(%rip), %rax # 0x233990
movq (%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %edi
leaq 0x52e9b(%rip), %rsi # 0xceb13
movb $0x0, %al
callq *%r8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
get_bool_argument:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rsi, [rbp+var_18]
lea rdi, my_charset_latin1
lea rdx, aTrue; "true"
call rax
cmp eax, 0
jz short loc_7BBC1
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rsi, [rbp+var_18]
lea rdi, my_charset_latin1
lea rdx, aExpansion+7; "on"
call rax
cmp eax, 0
jz short loc_7BBC1
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rsi, [rbp+var_18]
lea rdi, my_charset_latin1
lea rdx, aIso88591+9; "1"
call rax
cmp eax, 0
jnz short loc_7BBCC
loc_7BBC1:
jmp short $+2
loc_7BBC3:
mov [rbp+var_1], 1
jmp loc_7BC81
loc_7BBCC:
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rsi, [rbp+var_18]
lea rdi, my_charset_latin1
lea rdx, aFalse; "false"
call rax
cmp eax, 0
jz short loc_7BC4D
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rsi, [rbp+var_18]
lea rdi, my_charset_latin1
lea rdx, aOff; "off"
call rax
cmp eax, 0
jz short loc_7BC4D
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rsi, [rbp+var_18]
lea rdi, my_charset_latin1
lea rdx, aTlsv10+6; "0"
call rax
cmp eax, 0
jnz short loc_7BC55
loc_7BC4D:
jmp short $+2
loc_7BC4F:
mov [rbp+var_1], 0
jmp short loc_7BC81
loc_7BC55:
jmp short $+2
loc_7BC57:
lea rax, my_getopt_error_reporter
mov r8, [rax]
mov rax, [rbp+var_10]
mov rdx, [rax]
mov rcx, [rbp+var_18]
mov edi, 1
lea rsi, aOptionSBoolean; "option '%s': boolean value '%s' wasn't "...
mov al, 0
call r8
mov [rbp+var_1], 0
loc_7BC81:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char get_bool_argument(const char **a1, const char *a2)
{
if ( !(*(unsigned int ( **)(void *, const char *, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
a2,
"true")
|| !(*(unsigned int ( **)(void *, const char *, char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
a2,
"on")
|| !(*(unsigned int ( **)(void *, const char *, char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
a2,
"1") )
{
return 1;
}
if ( !(*(unsigned int ( **)(void *, const char *, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
a2,
"false")
|| !(*(unsigned int ( **)(void *, const char *, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
a2,
"off")
|| !(*(unsigned int ( **)(void *, const char *, char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
a2,
"0") )
{
return 0;
}
my_getopt_error_reporter(1, (long long)"option '%s': boolean value '%s' wasn't recognized. Set to OFF.", *a1, a2);
return 0;
}
|
get_bool_argument:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
LEA RAX,[0x3da160]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x3da160]
LEA RDX,[0x1ce6e8]
CALL RAX
CMP EAX,0x0
JZ 0x0017bbc1
LEA RAX,[0x3da160]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x3da160]
LEA RDX,[0x1cfd6e]
CALL RAX
CMP EAX,0x0
JZ 0x0017bbc1
LEA RAX,[0x3da160]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x3da160]
LEA RDX,[0x1cd29a]
CALL RAX
CMP EAX,0x0
JNZ 0x0017bbcc
LAB_0017bbc1:
JMP 0x0017bbc3
LAB_0017bbc3:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017bc81
LAB_0017bbcc:
LEA RAX,[0x3da160]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x3da160]
LEA RDX,[0x1ce6ed]
CALL RAX
CMP EAX,0x0
JZ 0x0017bc4d
LEA RAX,[0x3da160]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x3da160]
LEA RDX,[0x1ce6f3]
CALL RAX
CMP EAX,0x0
JZ 0x0017bc4d
LEA RAX,[0x3da160]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x3da160]
LEA RDX,[0x1cb0d4]
CALL RAX
CMP EAX,0x0
JNZ 0x0017bc55
LAB_0017bc4d:
JMP 0x0017bc4f
LAB_0017bc4f:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0017bc81
LAB_0017bc55:
JMP 0x0017bc57
LAB_0017bc57:
LEA RAX,[0x333990]
MOV R8,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV EDI,0x1
LEA RSI,[0x1ceb13]
MOV AL,0x0
CALL R8
MOV byte ptr [RBP + -0x1],0x0
LAB_0017bc81:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 get_bool_argument(int8 *param_1,int8 param_2)
{
int iVar1;
iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003da220 + 0x40))
(&my_charset_latin1,param_2,&DAT_001ce6e8);
if (((iVar1 == 0) ||
(iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003da220 + 0x40))
(&my_charset_latin1,param_2,"on"), iVar1 == 0)) ||
(iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003da220 + 0x40))
(&my_charset_latin1,param_2,&DAT_001cd29a), iVar1 == 0)) {
return 1;
}
iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003da220 + 0x40))
(&my_charset_latin1,param_2,"false");
if (((iVar1 != 0) &&
(iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003da220 + 0x40))
(&my_charset_latin1,param_2,&DAT_001ce6f3), iVar1 != 0)) &&
(iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003da220 + 0x40))
(&my_charset_latin1,param_2,&DAT_001cb0d4), iVar1 != 0)) {
(*(code *)my_getopt_error_reporter)
(1,"option \'%s\': boolean value \'%s\' wasn\'t recognized. Set to OFF.",*param_1,
param_2);
return 0;
}
return 0;
}
|
|
64,787 |
js_array_reverse
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_reverse(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, lval, hval;
JSValue *arrp;
int64_t len, l, h;
int l_present, h_present;
uint32_t count32;
lval = JS_UNDEFINED;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
/* Special case fast arrays */
if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
uint32_t ll, hh;
if (count32 > 1) {
for (ll = 0, hh = count32 - 1; ll < hh; ll++, hh--) {
lval = arrp[ll];
arrp[ll] = arrp[hh];
arrp[hh] = lval;
}
}
return obj;
}
for (l = 0, h = len - 1; l < h; l++, h--) {
l_present = JS_TryGetPropertyInt64(ctx, obj, l, &lval);
if (l_present < 0)
goto exception;
h_present = JS_TryGetPropertyInt64(ctx, obj, h, &hval);
if (h_present < 0)
goto exception;
if (h_present) {
if (JS_SetPropertyInt64(ctx, obj, l, hval) < 0)
goto exception;
if (l_present) {
if (JS_SetPropertyInt64(ctx, obj, h, lval) < 0) {
lval = JS_UNDEFINED;
goto exception;
}
lval = JS_UNDEFINED;
} else {
if (JS_DeletePropertyInt64(ctx, obj, h, JS_PROP_THROW) < 0)
goto exception;
}
} else {
if (l_present) {
if (JS_DeletePropertyInt64(ctx, obj, l, JS_PROP_THROW) < 0)
goto exception;
if (JS_SetPropertyInt64(ctx, obj, h, lval) < 0) {
lval = JS_UNDEFINED;
goto exception;
}
lval = JS_UNDEFINED;
}
}
}
return obj;
exception:
JS_FreeValue(ctx, lval);
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O0
|
c
|
js_array_reverse:
subq $0x108, %rsp # imm = 0x108
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xf0(%rsp)
movq %rdi, 0xe0(%rsp)
movl %ecx, 0xdc(%rsp)
movq %r8, 0xd0(%rsp)
movl $0x0, 0x60(%rsp)
movq $0x3, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xf0(%rsp), %rdx
callq 0x364b0
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xc0(%rsp), %rdx
movq 0xc8(%rsp), %rcx
leaq 0x90(%rsp), %rsi
callq 0x2cca0
cmpl $0x0, %eax
je 0xc9ba9
jmp 0xc9fe1
movq 0xe0(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
leaq 0x98(%rsp), %rcx
leaq 0x74(%rsp), %r8
callq 0x6f480
cmpl $0x0, %eax
je 0xc9ce4
movl 0x74(%rsp), %eax
cmpq 0x90(%rsp), %rax
jne 0xc9ce4
cmpl $0x1, 0x74(%rsp)
jbe 0xc9cbf
movl $0x0, 0x4c(%rsp)
movl 0x74(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x48(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x48(%rsp), %eax
jae 0xc9cbd
movq 0x98(%rsp), %rax
movl 0x4c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0xb0(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xb8(%rsp)
movq 0x98(%rsp), %rax
movl 0x4c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x98(%rsp), %rcx
movl 0x48(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x98(%rsp), %rax
movl 0x48(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0xb0(%rsp), %rcx
movq %rcx, (%rax)
movq 0xb8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
movl 0x48(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0xc9c0c
jmp 0xc9cbf
movq 0xc0(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x100(%rsp)
jmp 0xca032
movq $0x0, 0x88(%rsp)
movq 0x90(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rax
cmpq 0x80(%rsp), %rax
jge 0xc9fbf
movq 0xe0(%rsp), %rdi
movq 0x88(%rsp), %rcx
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
leaq 0xb0(%rsp), %r8
callq 0x868e0
movl %eax, 0x7c(%rsp)
cmpl $0x0, 0x7c(%rsp)
jge 0xc9d57
jmp 0xc9fe1
movq 0xe0(%rsp), %rdi
movq 0x80(%rsp), %rcx
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
leaq 0xa0(%rsp), %r8
callq 0x868e0
movl %eax, 0x78(%rsp)
cmpl $0x0, 0x78(%rsp)
jge 0xc9d94
jmp 0xc9fe1
cmpl $0x0, 0x78(%rsp)
je 0xc9ebc
movq 0xe0(%rsp), %rdi
movq 0x88(%rsp), %rcx
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0xa0(%rsp), %r8
movq 0xa8(%rsp), %r9
callq 0x328f0
cmpl $0x0, %eax
jge 0xc9dde
jmp 0xc9fe1
cmpl $0x0, 0x7c(%rsp)
je 0xc9e80
movq 0xe0(%rsp), %rdi
movq 0x80(%rsp), %rcx
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0xb0(%rsp), %r8
movq 0xb8(%rsp), %r9
callq 0x328f0
cmpl $0x0, %eax
jge 0xc9e53
movl $0x0, 0x38(%rsp)
movq $0x3, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0xb8(%rsp)
jmp 0xc9fe1
movl $0x0, 0x28(%rsp)
movq $0x3, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0xb8(%rsp)
jmp 0xc9eb7
movq 0xe0(%rsp), %rdi
movq 0x80(%rsp), %rcx
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movl $0x4000, %r8d # imm = 0x4000
callq 0x36cd0
cmpl $0x0, %eax
jge 0xc9eb5
jmp 0xc9fe1
jmp 0xc9eb7
jmp 0xc9f90
cmpl $0x0, 0x7c(%rsp)
je 0xc9f8e
movq 0xe0(%rsp), %rdi
movq 0x88(%rsp), %rcx
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movl $0x4000, %r8d # imm = 0x4000
callq 0x36cd0
cmpl $0x0, %eax
jge 0xc9efc
jmp 0xc9fe1
movq 0xe0(%rsp), %rdi
movq 0x80(%rsp), %rcx
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0xb0(%rsp), %r8
movq 0xb8(%rsp), %r9
callq 0x328f0
cmpl $0x0, %eax
jge 0xc9f63
movl $0x0, 0x18(%rsp)
movq $0x3, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0xb8(%rsp)
jmp 0xc9fe1
movl $0x0, 0x8(%rsp)
movq $0x3, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0xb8(%rsp)
jmp 0xc9f90
jmp 0xc9f92
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
movq 0x80(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0xc9d04
movq 0xc0(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x100(%rsp)
jmp 0xca032
movq 0xe0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
callq 0x229d0
movq 0xe0(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
callq 0x229d0
movl $0x0, 0xf8(%rsp)
movq $0x6, 0x100(%rsp)
movq 0xf8(%rsp), %rax
movq 0x100(%rsp), %rdx
addq $0x108, %rsp # imm = 0x108
retq
nopw (%rax,%rax)
|
js_array_reverse:
sub rsp, 108h
mov [rsp+108h+var_20], rsi
mov [rsp+108h+var_18], rdx
mov [rsp+108h+var_28], rdi
mov [rsp+108h+var_2C], ecx
mov [rsp+108h+var_38], r8
mov dword ptr [rsp+108h+var_A8], 0
mov [rsp+108h+var_A0], 3
mov rax, [rsp+108h+var_A8]
mov [rsp+108h+var_58], rax
mov rax, [rsp+108h+var_A0]
mov [rsp+108h+var_50], rax
mov rdi, [rsp+108h+var_28]
mov rsi, [rsp+108h+var_20]
mov rdx, [rsp+108h+var_18]
call JS_ToObject
mov [rsp+108h+var_B8], rax
mov [rsp+108h+var_B0], rdx
mov rax, [rsp+108h+var_B8]
mov [rsp+108h+var_48], rax
mov rax, [rsp+108h+var_B0]
mov [rsp+108h+var_40], rax
mov rdi, [rsp+108h+var_28]
mov rdx, [rsp+108h+var_48]
mov rcx, [rsp+108h+var_40]
lea rsi, [rsp+108h+var_78]
call js_get_length64
cmp eax, 0
jz short loc_C9BA9
jmp loc_C9FE1
loc_C9BA9:
mov rdi, [rsp+108h+var_28]
mov rsi, [rsp+108h+var_48]
mov rdx, [rsp+108h+var_40]
lea rcx, [rsp+108h+var_70]
lea r8, [rsp+108h+var_94]
call js_get_fast_array
cmp eax, 0
jz loc_C9CE4
mov eax, [rsp+108h+var_94]
cmp rax, [rsp+108h+var_78]
jnz loc_C9CE4
cmp [rsp+108h+var_94], 1
jbe loc_C9CBF
mov [rsp+108h+var_BC], 0
mov eax, [rsp+108h+var_94]
sub eax, 1
mov [rsp+108h+var_C0], eax
loc_C9C0C:
mov eax, [rsp+108h+var_BC]
cmp eax, [rsp+108h+var_C0]
jnb loc_C9CBD
mov rax, [rsp+108h+var_70]
mov ecx, [rsp+108h+var_BC]
shl rcx, 4
add rax, rcx
mov rcx, [rax]
mov [rsp+108h+var_58], rcx
mov rax, [rax+8]
mov [rsp+108h+var_50], rax
mov rax, [rsp+108h+var_70]
mov ecx, [rsp+108h+var_BC]
shl rcx, 4
add rax, rcx
mov rcx, [rsp+108h+var_70]
mov edx, [rsp+108h+var_C0]
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rax, [rsp+108h+var_70]
mov ecx, [rsp+108h+var_C0]
shl rcx, 4
add rax, rcx
mov rcx, [rsp+108h+var_58]
mov [rax], rcx
mov rcx, [rsp+108h+var_50]
mov [rax+8], rcx
mov eax, [rsp+108h+var_BC]
add eax, 1
mov [rsp+108h+var_BC], eax
mov eax, [rsp+108h+var_C0]
add eax, 0FFFFFFFFh
mov [rsp+108h+var_C0], eax
jmp loc_C9C0C
loc_C9CBD:
jmp short $+2
loc_C9CBF:
mov rax, [rsp+108h+var_48]
mov [rsp+108h+var_10], rax
mov rax, [rsp+108h+var_40]
mov [rsp+108h+var_8], rax
jmp loc_CA032
loc_C9CE4:
mov [rsp+108h+var_80], 0
mov rax, [rsp+108h+var_78]
sub rax, 1
mov [rsp+108h+var_88], rax
loc_C9D04:
mov rax, [rsp+108h+var_80]
cmp rax, [rsp+108h+var_88]
jge loc_C9FBF
mov rdi, [rsp+108h+var_28]
mov rcx, [rsp+108h+var_80]
mov rsi, [rsp+108h+var_48]
mov rdx, [rsp+108h+var_40]
lea r8, [rsp+108h+var_58]
call JS_TryGetPropertyInt64
mov [rsp+108h+var_8C], eax
cmp [rsp+108h+var_8C], 0
jge short loc_C9D57
jmp loc_C9FE1
loc_C9D57:
mov rdi, [rsp+108h+var_28]
mov rcx, [rsp+108h+var_88]
mov rsi, [rsp+108h+var_48]
mov rdx, [rsp+108h+var_40]
lea r8, [rsp+108h+var_68]
call JS_TryGetPropertyInt64
mov [rsp+108h+var_90], eax
cmp [rsp+108h+var_90], 0
jge short loc_C9D94
jmp loc_C9FE1
loc_C9D94:
cmp [rsp+108h+var_90], 0
jz loc_C9EBC
mov rdi, [rsp+108h+var_28]
mov rcx, [rsp+108h+var_80]
mov rsi, [rsp+108h+var_48]
mov rdx, [rsp+108h+var_40]
mov r8, [rsp+108h+var_68]
mov r9, [rsp+108h+var_60]
call JS_SetPropertyInt64
cmp eax, 0
jge short loc_C9DDE
jmp loc_C9FE1
loc_C9DDE:
cmp [rsp+108h+var_8C], 0
jz loc_C9E80
mov rdi, [rsp+108h+var_28]
mov rcx, [rsp+108h+var_88]
mov rsi, [rsp+108h+var_48]
mov rdx, [rsp+108h+var_40]
mov r8, [rsp+108h+var_58]
mov r9, [rsp+108h+var_50]
call JS_SetPropertyInt64
cmp eax, 0
jge short loc_C9E53
mov dword ptr [rsp+108h+var_D0], 0
mov [rsp+108h+var_C8], 3
mov rax, [rsp+108h+var_D0]
mov [rsp+108h+var_58], rax
mov rax, [rsp+108h+var_C8]
mov [rsp+108h+var_50], rax
jmp loc_C9FE1
loc_C9E53:
mov dword ptr [rsp+108h+var_E0], 0
mov [rsp+108h+var_D8], 3
mov rax, [rsp+108h+var_E0]
mov [rsp+108h+var_58], rax
mov rax, [rsp+108h+var_D8]
mov [rsp+108h+var_50], rax
jmp short loc_C9EB7
loc_C9E80:
mov rdi, [rsp+108h+var_28]
mov rcx, [rsp+108h+var_88]
mov rsi, [rsp+108h+var_48]
mov rdx, [rsp+108h+var_40]
mov r8d, 4000h
call JS_DeletePropertyInt64
cmp eax, 0
jge short loc_C9EB5
jmp loc_C9FE1
loc_C9EB5:
jmp short $+2
loc_C9EB7:
jmp loc_C9F90
loc_C9EBC:
cmp [rsp+108h+var_8C], 0
jz loc_C9F8E
mov rdi, [rsp+108h+var_28]
mov rcx, [rsp+108h+var_80]
mov rsi, [rsp+108h+var_48]
mov rdx, [rsp+108h+var_40]
mov r8d, 4000h
call JS_DeletePropertyInt64
cmp eax, 0
jge short loc_C9EFC
jmp loc_C9FE1
loc_C9EFC:
mov rdi, [rsp+108h+var_28]
mov rcx, [rsp+108h+var_88]
mov rsi, [rsp+108h+var_48]
mov rdx, [rsp+108h+var_40]
mov r8, [rsp+108h+var_58]
mov r9, [rsp+108h+var_50]
call JS_SetPropertyInt64
cmp eax, 0
jge short loc_C9F63
mov dword ptr [rsp+108h+var_F0], 0
mov [rsp+108h+var_E8], 3
mov rax, [rsp+108h+var_F0]
mov [rsp+108h+var_58], rax
mov rax, [rsp+108h+var_E8]
mov [rsp+108h+var_50], rax
jmp short loc_C9FE1
loc_C9F63:
mov dword ptr [rsp+108h+var_100], 0
mov [rsp+108h+var_F8], 3
mov rax, [rsp+108h+var_100]
mov [rsp+108h+var_58], rax
mov rax, [rsp+108h+var_F8]
mov [rsp+108h+var_50], rax
loc_C9F8E:
jmp short $+2
loc_C9F90:
jmp short $+2
loc_C9F92:
mov rax, [rsp+108h+var_80]
add rax, 1
mov [rsp+108h+var_80], rax
mov rax, [rsp+108h+var_88]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rsp+108h+var_88], rax
jmp loc_C9D04
loc_C9FBF:
mov rax, [rsp+108h+var_48]
mov [rsp+108h+var_10], rax
mov rax, [rsp+108h+var_40]
mov [rsp+108h+var_8], rax
jmp short loc_CA032
loc_C9FE1:
mov rdi, [rsp+108h+var_28]
mov rsi, [rsp+108h+var_58]
mov rdx, [rsp+108h+var_50]
call JS_FreeValue
mov rdi, [rsp+108h+var_28]
mov rsi, [rsp+108h+var_48]
mov rdx, [rsp+108h+var_40]
call JS_FreeValue
mov dword ptr [rsp+108h+var_10], 0
mov [rsp+108h+var_8], 6
loc_CA032:
mov rax, [rsp+108h+var_10]
mov rdx, [rsp+108h+var_8]
add rsp, 108h
retn
|
_DWORD * js_array_reverse(
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)
{
long long v14; // rdx
long long *v15; // rax
long long *v16; // rcx
_QWORD *v17; // rax
double v18; // xmm4_8
double v19; // xmm5_8
double v20; // xmm4_8
double v21; // xmm5_8
long long v23; // [rsp+8h] [rbp-100h]
long long v24; // [rsp+18h] [rbp-F0h]
long long v25; // [rsp+28h] [rbp-E0h]
long long v26; // [rsp+38h] [rbp-D0h]
unsigned int i; // [rsp+48h] [rbp-C0h]
unsigned int v28; // [rsp+4Ch] [rbp-BCh]
long long v29; // [rsp+60h] [rbp-A8h]
unsigned int v30; // [rsp+74h] [rbp-94h] BYREF
int v31; // [rsp+78h] [rbp-90h]
int PropertyInt64; // [rsp+7Ch] [rbp-8Ch]
signed long long j; // [rsp+80h] [rbp-88h]
signed long long v34; // [rsp+88h] [rbp-80h]
long long v35; // [rsp+90h] [rbp-78h] BYREF
long long v36; // [rsp+98h] [rbp-70h] BYREF
long long v37[2]; // [rsp+A0h] [rbp-68h] BYREF
long long v38; // [rsp+B0h] [rbp-58h] BYREF
long long v39; // [rsp+B8h] [rbp-50h]
_DWORD *v40; // [rsp+C0h] [rbp-48h]
long long v41; // [rsp+C8h] [rbp-40h]
long long v42; // [rsp+D0h] [rbp-38h]
int v43; // [rsp+DCh] [rbp-2Ch]
long long v44; // [rsp+E0h] [rbp-28h]
_DWORD *v45; // [rsp+E8h] [rbp-20h]
long long v46; // [rsp+F0h] [rbp-18h]
_DWORD *v47; // [rsp+F8h] [rbp-10h]
long long v48; // [rsp+100h] [rbp-8h]
v45 = a2;
v46 = a3;
v44 = a1;
v43 = a4;
v42 = a5;
LODWORD(v29) = 0;
v38 = v29;
v39 = 3LL;
v40 = JS_ToObject(a1, a2, a3, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6);
v41 = v14;
if ( (unsigned int)js_get_length64(a1, &v35, (int)v40, v14) )
{
LABEL_28:
JS_FreeValue(v44, v38, v39);
JS_FreeValue(v44, (long long)v40, v41);
LODWORD(v47) = 0;
v48 = 6LL;
}
else if ( (unsigned int)js_get_fast_array(v44, (long long)v40, v41, &v36, &v30) && v30 == v35 )
{
if ( v30 > 1 )
{
v28 = 0;
for ( i = v30 - 1; v28 < i; --i )
{
v15 = (long long *)(16LL * v28 + v36);
v38 = *v15;
v39 = v15[1];
v16 = (long long *)(16LL * i + v36);
*v15 = *v16;
v15[1] = v16[1];
v17 = (_QWORD *)(16LL * i + v36);
*v17 = v38;
v17[1] = v39;
++v28;
}
}
v47 = v40;
v48 = v41;
}
else
{
v34 = 0LL;
for ( j = v35 - 1; v34 < j; --j )
{
PropertyInt64 = JS_TryGetPropertyInt64(v44, (long long)v40, v41, v34, &v38);
if ( PropertyInt64 < 0 )
goto LABEL_28;
v31 = JS_TryGetPropertyInt64(v44, (long long)v40, v41, j, v37);
if ( v31 < 0 )
goto LABEL_28;
if ( v31 )
{
if ( (int)JS_SetPropertyInt64(v44, (long long)v40, v41, v34, v37[0], v37[1]) < 0 )
goto LABEL_28;
if ( PropertyInt64 )
{
if ( (int)JS_SetPropertyInt64(v44, (long long)v40, v41, j, v38, v39) < 0 )
{
LODWORD(v26) = 0;
v38 = v26;
v39 = 3LL;
goto LABEL_28;
}
LODWORD(v25) = 0;
v38 = v25;
v39 = 3LL;
}
else if ( (int)JS_DeletePropertyInt64(v44, (long long)v40, v41, j, 0x4000, a7, a8, a9, a10, v20, v21, a13, a14) < 0 )
{
goto LABEL_28;
}
}
else if ( PropertyInt64 )
{
if ( (int)JS_DeletePropertyInt64(v44, (long long)v40, v41, v34, 0x4000, a7, a8, a9, a10, v18, v19, a13, a14) < 0 )
goto LABEL_28;
if ( (int)JS_SetPropertyInt64(v44, (long long)v40, v41, j, v38, v39) < 0 )
{
LODWORD(v24) = 0;
v38 = v24;
v39 = 3LL;
goto LABEL_28;
}
LODWORD(v23) = 0;
v38 = v23;
v39 = 3LL;
}
++v34;
}
v47 = v40;
v48 = v41;
}
return v47;
}
|
js_array_reverse:
SUB RSP,0x108
MOV qword ptr [RSP + 0xe8],RSI
MOV qword ptr [RSP + 0xf0],RDX
MOV qword ptr [RSP + 0xe0],RDI
MOV dword ptr [RSP + 0xdc],ECX
MOV qword ptr [RSP + 0xd0],R8
MOV dword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0x3
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xb8],RAX
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xe8]
MOV RDX,qword ptr [RSP + 0xf0]
CALL 0x001364b0
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xc0],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xc8],RAX
MOV RDI,qword ptr [RSP + 0xe0]
MOV RDX,qword ptr [RSP + 0xc0]
MOV RCX,qword ptr [RSP + 0xc8]
LEA RSI,[RSP + 0x90]
CALL 0x0012cca0
CMP EAX,0x0
JZ 0x001c9ba9
JMP 0x001c9fe1
LAB_001c9ba9:
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
LEA RCX,[RSP + 0x98]
LEA R8,[RSP + 0x74]
CALL 0x0016f480
CMP EAX,0x0
JZ 0x001c9ce4
MOV EAX,dword ptr [RSP + 0x74]
CMP RAX,qword ptr [RSP + 0x90]
JNZ 0x001c9ce4
CMP dword ptr [RSP + 0x74],0x1
JBE 0x001c9cbf
MOV dword ptr [RSP + 0x4c],0x0
MOV EAX,dword ptr [RSP + 0x74]
SUB EAX,0x1
MOV dword ptr [RSP + 0x48],EAX
LAB_001c9c0c:
MOV EAX,dword ptr [RSP + 0x4c]
CMP EAX,dword ptr [RSP + 0x48]
JNC 0x001c9cbd
MOV RAX,qword ptr [RSP + 0x98]
MOV ECX,dword ptr [RSP + 0x4c]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0xb0],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV ECX,dword ptr [RSP + 0x4c]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x98]
MOV EDX,dword ptr [RSP + 0x48]
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 RAX,qword ptr [RSP + 0x98]
MOV ECX,dword ptr [RSP + 0x48]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0xb0]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0xb8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RSP + 0x4c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x4c],EAX
MOV EAX,dword ptr [RSP + 0x48]
ADD EAX,-0x1
MOV dword ptr [RSP + 0x48],EAX
JMP 0x001c9c0c
LAB_001c9cbd:
JMP 0x001c9cbf
LAB_001c9cbf:
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0xf8],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x100],RAX
JMP 0x001ca032
LAB_001c9ce4:
MOV qword ptr [RSP + 0x88],0x0
MOV RAX,qword ptr [RSP + 0x90]
SUB RAX,0x1
MOV qword ptr [RSP + 0x80],RAX
LAB_001c9d04:
MOV RAX,qword ptr [RSP + 0x88]
CMP RAX,qword ptr [RSP + 0x80]
JGE 0x001c9fbf
MOV RDI,qword ptr [RSP + 0xe0]
MOV RCX,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
LEA R8,[RSP + 0xb0]
CALL 0x001868e0
MOV dword ptr [RSP + 0x7c],EAX
CMP dword ptr [RSP + 0x7c],0x0
JGE 0x001c9d57
JMP 0x001c9fe1
LAB_001c9d57:
MOV RDI,qword ptr [RSP + 0xe0]
MOV RCX,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
LEA R8,[RSP + 0xa0]
CALL 0x001868e0
MOV dword ptr [RSP + 0x78],EAX
CMP dword ptr [RSP + 0x78],0x0
JGE 0x001c9d94
JMP 0x001c9fe1
LAB_001c9d94:
CMP dword ptr [RSP + 0x78],0x0
JZ 0x001c9ebc
MOV RDI,qword ptr [RSP + 0xe0]
MOV RCX,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
MOV R8,qword ptr [RSP + 0xa0]
MOV R9,qword ptr [RSP + 0xa8]
CALL 0x001328f0
CMP EAX,0x0
JGE 0x001c9dde
JMP 0x001c9fe1
LAB_001c9dde:
CMP dword ptr [RSP + 0x7c],0x0
JZ 0x001c9e80
MOV RDI,qword ptr [RSP + 0xe0]
MOV RCX,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
MOV R8,qword ptr [RSP + 0xb0]
MOV R9,qword ptr [RSP + 0xb8]
CALL 0x001328f0
CMP EAX,0x0
JGE 0x001c9e53
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x3
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0xb8],RAX
JMP 0x001c9fe1
LAB_001c9e53:
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x3
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xb8],RAX
JMP 0x001c9eb7
LAB_001c9e80:
MOV RDI,qword ptr [RSP + 0xe0]
MOV RCX,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
MOV R8D,0x4000
CALL 0x00136cd0
CMP EAX,0x0
JGE 0x001c9eb5
JMP 0x001c9fe1
LAB_001c9eb5:
JMP 0x001c9eb7
LAB_001c9eb7:
JMP 0x001c9f90
LAB_001c9ebc:
CMP dword ptr [RSP + 0x7c],0x0
JZ 0x001c9f8e
MOV RDI,qword ptr [RSP + 0xe0]
MOV RCX,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
MOV R8D,0x4000
CALL 0x00136cd0
CMP EAX,0x0
JGE 0x001c9efc
JMP 0x001c9fe1
LAB_001c9efc:
MOV RDI,qword ptr [RSP + 0xe0]
MOV RCX,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
MOV R8,qword ptr [RSP + 0xb0]
MOV R9,qword ptr [RSP + 0xb8]
CALL 0x001328f0
CMP EAX,0x0
JGE 0x001c9f63
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x3
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0xb8],RAX
JMP 0x001c9fe1
LAB_001c9f63:
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x3
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0xb8],RAX
LAB_001c9f8e:
JMP 0x001c9f90
LAB_001c9f90:
JMP 0x001c9f92
LAB_001c9f92:
MOV RAX,qword ptr [RSP + 0x88]
ADD RAX,0x1
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x80]
ADD RAX,-0x1
MOV qword ptr [RSP + 0x80],RAX
JMP 0x001c9d04
LAB_001c9fbf:
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0xf8],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x100],RAX
JMP 0x001ca032
LAB_001c9fe1:
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
CALL 0x001229d0
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
CALL 0x001229d0
MOV dword ptr [RSP + 0xf8],0x0
MOV qword ptr [RSP + 0x100],0x6
LAB_001ca032:
MOV RAX,qword ptr [RSP + 0xf8]
MOV RDX,qword ptr [RSP + 0x100]
ADD RSP,0x108
RET
|
int1 [16]
js_array_reverse(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 param_5)
{
int8 uVar1;
int8 uVar2;
int1 auVar3 [16];
int iVar4;
int8 *puVar5;
int8 *puVar6;
uint uStack_fc;
uint uStack_ec;
uint uStack_dc;
uint uStack_cc;
uint local_c0;
uint local_bc;
uint uStack_a4;
uint local_94;
int local_90;
int local_8c;
ulong local_88;
long local_80;
ulong local_78;
long local_70;
int8 local_68;
int8 local_60;
long local_58;
int8 local_50;
int1 local_48 [16];
int8 local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_58 = (ulong)uStack_a4 << 0x20;
local_50 = 3;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_48 = JS_ToObject(param_1,param_2,param_3);
iVar4 = js_get_length64(local_28,&local_78,local_48._0_8_,local_48._8_8_);
if (iVar4 == 0) {
iVar4 = js_get_fast_array(local_28,local_48._0_8_,local_48._8_8_,&local_70,&local_94);
if ((iVar4 == 0) || (local_94 != local_78)) {
local_80 = 0;
while( true ) {
local_88 = local_78 - 1;
if ((long)local_88 <= local_80) break;
local_8c = JS_TryGetPropertyInt64(local_28,local_48._0_8_,local_48._8_8_,local_80,&local_58)
;
if (local_8c < 0) goto LAB_001c9fe1;
local_90 = JS_TryGetPropertyInt64(local_28,local_48._0_8_,local_48._8_8_,local_88,&local_68)
;
if (local_90 < 0) goto LAB_001c9fe1;
if (local_90 == 0) {
if (local_8c != 0) {
iVar4 = JS_DeletePropertyInt64(local_28,local_48._0_8_,local_48._8_8_,local_80,0x4000);
if (iVar4 < 0) goto LAB_001c9fe1;
iVar4 = JS_SetPropertyInt64(local_28,local_48._0_8_,local_48._8_8_,local_88,local_58,
local_50);
if (iVar4 < 0) {
local_58 = (ulong)uStack_ec << 0x20;
local_50 = 3;
goto LAB_001c9fe1;
}
local_58 = (ulong)uStack_fc << 0x20;
local_50 = 3;
}
}
else {
iVar4 = JS_SetPropertyInt64(local_28,local_48._0_8_,local_48._8_8_,local_80,local_68,
local_60);
if (iVar4 < 0) goto LAB_001c9fe1;
if (local_8c == 0) {
iVar4 = JS_DeletePropertyInt64(local_28,local_48._0_8_,local_48._8_8_,local_88,0x4000);
if (iVar4 < 0) goto LAB_001c9fe1;
}
else {
iVar4 = JS_SetPropertyInt64(local_28,local_48._0_8_,local_48._8_8_,local_88,local_58,
local_50);
if (iVar4 < 0) {
local_58 = (ulong)uStack_cc << 0x20;
local_50 = 3;
goto LAB_001c9fe1;
}
local_58 = (ulong)uStack_dc << 0x20;
local_50 = 3;
}
}
local_80 = local_80 + 1;
local_78 = local_88;
}
local_10 = local_48._0_4_;
uStack_c = local_48._4_4_;
local_8 = local_48._8_8_;
}
else {
if (1 < local_94) {
for (local_bc = 0; local_c0 = local_94 - 1, local_bc < local_c0; local_bc = local_bc + 1) {
puVar5 = (int8 *)(local_70 + (ulong)local_bc * 0x10);
uVar1 = *puVar5;
uVar2 = puVar5[1];
puVar5 = (int8 *)(local_70 + (ulong)local_bc * 0x10);
puVar6 = (int8 *)(local_70 + (ulong)local_c0 * 0x10);
*puVar5 = *puVar6;
puVar5[1] = puVar6[1];
puVar5 = (int8 *)(local_70 + (ulong)local_c0 * 0x10);
*puVar5 = uVar1;
puVar5[1] = uVar2;
local_94 = local_c0;
}
}
local_10 = local_48._0_4_;
uStack_c = local_48._4_4_;
local_8 = local_48._8_8_;
}
}
else {
LAB_001c9fe1:
JS_FreeValue(local_28,local_58,local_50);
JS_FreeValue(local_28,local_48._0_8_,local_48._8_8_);
local_10 = 0;
local_8 = 6;
}
auVar3._4_4_ = uStack_c;
auVar3._0_4_ = local_10;
auVar3._8_8_ = local_8;
return auVar3;
}
|
|
64,788 |
js_array_reverse
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_reverse(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, lval, hval;
JSValue *arrp;
int64_t len, l, h;
int l_present, h_present;
uint32_t count32;
lval = JS_UNDEFINED;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
/* Special case fast arrays */
if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
uint32_t ll, hh;
if (count32 > 1) {
for (ll = 0, hh = count32 - 1; ll < hh; ll++, hh--) {
lval = arrp[ll];
arrp[ll] = arrp[hh];
arrp[hh] = lval;
}
}
return obj;
}
for (l = 0, h = len - 1; l < h; l++, h--) {
l_present = JS_TryGetPropertyInt64(ctx, obj, l, &lval);
if (l_present < 0)
goto exception;
h_present = JS_TryGetPropertyInt64(ctx, obj, h, &hval);
if (h_present < 0)
goto exception;
if (h_present) {
if (JS_SetPropertyInt64(ctx, obj, l, hval) < 0)
goto exception;
if (l_present) {
if (JS_SetPropertyInt64(ctx, obj, h, lval) < 0) {
lval = JS_UNDEFINED;
goto exception;
}
lval = JS_UNDEFINED;
} else {
if (JS_DeletePropertyInt64(ctx, obj, h, JS_PROP_THROW) < 0)
goto exception;
}
} else {
if (l_present) {
if (JS_DeletePropertyInt64(ctx, obj, l, JS_PROP_THROW) < 0)
goto exception;
if (JS_SetPropertyInt64(ctx, obj, h, lval) < 0) {
lval = JS_UNDEFINED;
goto exception;
}
lval = JS_UNDEFINED;
}
}
}
return obj;
exception:
JS_FreeValue(ctx, lval);
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_array_reverse:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movl $0x0, (%rsp)
movq $0x3, 0x8(%rsp)
callq 0x261c9
movq %rax, %r14
movq %rdx, %rbx
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x21ec8
testl %eax, %eax
je 0x75790
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%r15), %rdi
callq 0x1ccb2
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ccb2
movl $0x6, %ebx
xorl %r14d, %r14d
xorl %ecx, %ecx
jmp 0x7590e
movq %r14, 0x18(%rsp)
cmpl $-0x1, %ebx
jne 0x757b0
movq 0x18(%rsp), %rax
cmpw $0x2, 0x6(%rax)
jne 0x757b0
testb $0x8, 0x5(%rax)
jne 0x75926
xorl %edx, %edx
testb %dl, %dl
je 0x75807
movl %ecx, %edx
cmpq %rdx, 0x10(%rsp)
jne 0x75807
cmpl $0x2, %ecx
jb 0x758fe
decl %ecx
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
decq %rcx
xorl %esi, %esi
movups (%rax), %xmm0
movaps %xmm0, (%rsp)
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movaps (%rsp), %xmm0
movups %xmm0, (%rdx)
incq %rsi
movl %ecx, %edi
addq $0x10, %rax
addq $-0x10, %rdx
decq %rcx
cmpq %rdi, %rsi
jb 0x757d9
jmp 0x758fe
movq 0x10(%rsp), %r12
cmpq $0x2, %r12
jl 0x758fe
decq %r12
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
movq %rsp, %r8
callq 0x4cabd
testl %eax, %eax
js 0x75760
movl %eax, %ebp
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
leaq 0x18(%rsp), %r8
callq 0x4cabd
testl %eax, %eax
js 0x75760
je 0x7589a
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x24742
testl %eax, %eax
js 0x75760
testl %ebp, %ebp
jne 0x758bd
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movl $0x4000, %r8d # imm = 0x4000
callq 0x267dd
jmp 0x758e7
testl %ebp, %ebp
je 0x758ef
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
movl $0x4000, %r8d # imm = 0x4000
callq 0x267dd
testl %eax, %eax
js 0x75760
movq (%rsp), %r8
movq 0x8(%rsp), %r9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x24742
movl $0x0, (%rsp)
movq $0x3, 0x8(%rsp)
testl %eax, %eax
js 0x75760
incq %r13
decq %r12
cmpq %r12, %r13
jl 0x7581c
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r14, %rcx
andq %rax, %rcx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x40(%rax), %ecx
movq 0x38(%rax), %rax
movb $0x1, %dl
jmp 0x757b2
|
js_array_reverse:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdi
mov dword ptr [rsp+58h+var_58], 0
mov qword ptr [rsp+58h+var_58+8], 3
call JS_ToObject
mov r14, rax
mov rbx, rdx
lea rsi, [rsp+58h+var_48]
mov rdi, r15
mov rdx, rax
mov rcx, rbx
call js_get_length64
test eax, eax
jz short loc_75790
loc_75760:
mov rsi, qword ptr [rsp+58h+var_58]
mov rdx, qword ptr [rsp+58h+var_58+8]
mov rdi, [r15+18h]
call JS_FreeValueRT
mov rdi, [r15+18h]
mov rsi, r14
mov rdx, rbx
call JS_FreeValueRT
mov ebx, 6
xor r14d, r14d
xor ecx, ecx
jmp loc_7590E
loc_75790:
mov [rsp+58h+var_40], r14
cmp ebx, 0FFFFFFFFh
jnz short loc_757B0
mov rax, [rsp+58h+var_40]
cmp word ptr [rax+6], 2
jnz short loc_757B0
test byte ptr [rax+5], 8
jnz loc_75926
loc_757B0:
xor edx, edx
loc_757B2:
test dl, dl
jz short loc_75807
mov edx, ecx
cmp [rsp+58h+var_48], rdx
jnz short loc_75807
cmp ecx, 2
jb loc_758FE
dec ecx
mov rdx, rcx
shl rdx, 4
add rdx, rax
dec rcx
xor esi, esi
loc_757D9:
movups xmm0, xmmword ptr [rax]
movaps [rsp+58h+var_58], xmm0
movups xmm0, xmmword ptr [rdx]
movups xmmword ptr [rax], xmm0
movaps xmm0, [rsp+58h+var_58]
movups xmmword ptr [rdx], xmm0
inc rsi
mov edi, ecx
add rax, 10h
add rdx, 0FFFFFFFFFFFFFFF0h
dec rcx
cmp rsi, rdi
jb short loc_757D9
jmp loc_758FE
loc_75807:
mov r12, [rsp+58h+var_48]
cmp r12, 2
jl loc_758FE
dec r12
xor r13d, r13d
loc_7581C:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov rcx, r13
mov r8, rsp
call JS_TryGetPropertyInt64
test eax, eax
js loc_75760
mov ebp, eax
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov rcx, r12
lea r8, [rsp+58h+var_40]
call JS_TryGetPropertyInt64
test eax, eax
js loc_75760
jz short loc_7589A
mov r8, [rsp+58h+var_40]
mov r9, [rsp+58h+var_38]
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov rcx, r13
call JS_SetPropertyInt64
test eax, eax
js loc_75760
test ebp, ebp
jnz short loc_758BD
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov rcx, r12
mov r8d, 4000h
call JS_DeletePropertyInt64
jmp short loc_758E7
loc_7589A:
test ebp, ebp
jz short loc_758EF
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov rcx, r13
mov r8d, 4000h
call JS_DeletePropertyInt64
test eax, eax
js loc_75760
loc_758BD:
mov r8, qword ptr [rsp+58h+var_58]
mov r9, qword ptr [rsp+58h+var_58+8]
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov rcx, r12
call JS_SetPropertyInt64
mov dword ptr [rsp+58h+var_58], 0
mov qword ptr [rsp+58h+var_58+8], 3
loc_758E7:
test eax, eax
js loc_75760
loc_758EF:
inc r13
dec r12
cmp r13, r12
jl loc_7581C
loc_758FE:
mov rax, 0FFFFFFFF00000000h
mov rcx, r14
and rcx, rax
loc_7590E:
mov eax, r14d
or rax, rcx
mov rdx, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_75926:
mov ecx, [rax+40h]
mov rax, [rax+38h]
mov dl, 1
jmp loc_757B2
|
unsigned long long js_array_reverse(
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)
{
unsigned long long v14; // r14
unsigned long long v15; // rdx
unsigned long long v16; // rbx
__int128 *length64; // rax
unsigned int v18; // ecx
unsigned long long v19; // rcx
char v20; // dl
long long v21; // rcx
__int128 *v22; // rdx
long long v23; // rcx
unsigned long long v24; // rsi
unsigned long long v25; // rdi
_DWORD *v26; // r12
_DWORD *v27; // r13
int PropertyInt64; // eax
int v29; // ebp
int v30; // eax
double v31; // xmm4_8
double v32; // xmm5_8
double v33; // xmm4_8
double v34; // xmm5_8
int v35; // eax
__int128 v37; // [rsp+0h] [rbp-58h] BYREF
long long v38; // [rsp+10h] [rbp-48h] BYREF
_DWORD *v39[8]; // [rsp+18h] [rbp-40h] BYREF
LODWORD(v37) = 0;
*((_QWORD *)&v37 + 1) = 3LL;
v14 = (unsigned long long)JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v16 = v15;
length64 = (__int128 *)js_get_length64(a1, &v38, v14, v15);
if ( !(_DWORD)length64 )
{
v39[0] = (_DWORD *)v14;
if ( (_DWORD)v16 == -1
&& (length64 = (__int128 *)v39[0], *((_WORD *)v39[0] + 3) == 2)
&& (*((_BYTE *)v39[0] + 5) & 8) != 0 )
{
v18 = v39[0][16];
length64 = (__int128 *)*((_QWORD *)v39[0] + 7);
v20 = 1;
}
else
{
v20 = 0;
}
if ( v20 && v38 == v18 )
{
if ( v18 >= 2 )
{
v21 = v18 - 1;
v22 = &length64[v21];
v23 = v21 - 1;
v24 = 0LL;
do
{
v37 = *length64;
*length64 = *v22;
*v22 = v37;
++v24;
v25 = (unsigned int)v23;
++length64;
--v22;
--v23;
}
while ( v24 < v25 );
}
goto LABEL_26;
}
if ( v38 < 2 )
{
LABEL_26:
v19 = v14 & 0xFFFFFFFF00000000LL;
return v19 | (unsigned int)v14;
}
v26 = (_DWORD *)(v38 - 1);
v27 = 0LL;
while ( 1 )
{
PropertyInt64 = JS_TryGetPropertyInt64(a1, v14, v16, (unsigned long long)v27, (long long)&v37);
if ( PropertyInt64 < 0 )
goto LABEL_2;
v29 = PropertyInt64;
v30 = JS_TryGetPropertyInt64(a1, v14, v16, (unsigned long long)v26, (long long)v39);
if ( v30 < 0 )
goto LABEL_2;
if ( v30 )
break;
if ( v29 )
{
if ( (int)JS_DeletePropertyInt64(
a1,
v14,
v16,
(unsigned long long)v27,
0x4000,
a7,
a8,
a9,
a10,
v31,
v32,
a13,
a14) < 0 )
goto LABEL_2;
LABEL_23:
v35 = JS_SetPropertyInt64(
a1,
v14,
v16,
v26,
(_DWORD *)v37,
*((long long *)&v37 + 1),
*(double *)a7.m128_u64,
a8,
a9,
a10,
v33,
v34,
a13,
a14);
LODWORD(v37) = 0;
*((_QWORD *)&v37 + 1) = 3LL;
LABEL_24:
if ( v35 < 0 )
goto LABEL_2;
}
v27 = (_DWORD *)((char *)v27 + 1);
v26 = (_DWORD *)((char *)v26 - 1);
if ( (long long)v27 >= (long long)v26 )
goto LABEL_26;
}
if ( (int)JS_SetPropertyInt64(
a1,
v14,
v16,
v27,
v39[0],
(long long)v39[1],
*(double *)a7.m128_u64,
a8,
a9,
a10,
v31,
v32,
a13,
a14) < 0 )
goto LABEL_2;
if ( v29 )
goto LABEL_23;
v35 = JS_DeletePropertyInt64(a1, v14, v16, (unsigned long long)v26, 0x4000, a7, a8, a9, a10, v33, v34, a13, a14);
goto LABEL_24;
}
LABEL_2:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v37, *((long long *)&v37 + 1));
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v14, v16);
LODWORD(v14) = 0;
v19 = 0LL;
return v19 | (unsigned int)v14;
}
|
js_array_reverse:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDI
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x3
CALL 0x001261c9
MOV R14,RAX
MOV RBX,RDX
LEA RSI,[RSP + 0x10]
MOV RDI,R15
MOV RDX,RAX
MOV RCX,RBX
CALL 0x00121ec8
TEST EAX,EAX
JZ 0x00175790
LAB_00175760:
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [R15 + 0x18]
CALL 0x0011ccb2
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011ccb2
MOV EBX,0x6
XOR R14D,R14D
XOR ECX,ECX
JMP 0x0017590e
LAB_00175790:
MOV qword ptr [RSP + 0x18],R14
CMP EBX,-0x1
JNZ 0x001757b0
MOV RAX,qword ptr [RSP + 0x18]
CMP word ptr [RAX + 0x6],0x2
JNZ 0x001757b0
TEST byte ptr [RAX + 0x5],0x8
JNZ 0x00175926
LAB_001757b0:
XOR EDX,EDX
LAB_001757b2:
TEST DL,DL
JZ 0x00175807
MOV EDX,ECX
CMP qword ptr [RSP + 0x10],RDX
JNZ 0x00175807
CMP ECX,0x2
JC 0x001758fe
DEC ECX
MOV RDX,RCX
SHL RDX,0x4
ADD RDX,RAX
DEC RCX
XOR ESI,ESI
LAB_001757d9:
MOVUPS XMM0,xmmword ptr [RAX]
MOVAPS xmmword ptr [RSP],XMM0
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS xmmword ptr [RAX],XMM0
MOVAPS XMM0,xmmword ptr [RSP]
MOVUPS xmmword ptr [RDX],XMM0
INC RSI
MOV EDI,ECX
ADD RAX,0x10
ADD RDX,-0x10
DEC RCX
CMP RSI,RDI
JC 0x001757d9
JMP 0x001758fe
LAB_00175807:
MOV R12,qword ptr [RSP + 0x10]
CMP R12,0x2
JL 0x001758fe
DEC R12
XOR R13D,R13D
LAB_0017581c:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R13
MOV R8,RSP
CALL 0x0014cabd
TEST EAX,EAX
JS 0x00175760
MOV EBP,EAX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R12
LEA R8,[RSP + 0x18]
CALL 0x0014cabd
TEST EAX,EAX
JS 0x00175760
JZ 0x0017589a
MOV R8,qword ptr [RSP + 0x18]
MOV R9,qword ptr [RSP + 0x20]
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R13
CALL 0x00124742
TEST EAX,EAX
JS 0x00175760
TEST EBP,EBP
JNZ 0x001758bd
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R12
MOV R8D,0x4000
CALL 0x001267dd
JMP 0x001758e7
LAB_0017589a:
TEST EBP,EBP
JZ 0x001758ef
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R13
MOV R8D,0x4000
CALL 0x001267dd
TEST EAX,EAX
JS 0x00175760
LAB_001758bd:
MOV R8,qword ptr [RSP]
MOV R9,qword ptr [RSP + 0x8]
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R12
CALL 0x00124742
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x3
LAB_001758e7:
TEST EAX,EAX
JS 0x00175760
LAB_001758ef:
INC R13
DEC R12
CMP R13,R12
JL 0x0017581c
LAB_001758fe:
MOV RAX,-0x100000000
MOV RCX,R14
AND RCX,RAX
LAB_0017590e:
MOV EAX,R14D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00175926:
MOV ECX,dword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x38]
MOV DL,0x1
JMP 0x001757b2
|
int1 [16] js_array_reverse(long param_1)
{
int8 uVar1;
bool bVar2;
int iVar3;
int iVar4;
int8 *puVar5;
int8 *puVar6;
uint uVar7;
ulong uVar9;
int8 uVar10;
int8 *puVar11;
ulong uVar12;
long lVar13;
long lVar14;
int1 auVar15 [16];
int1 auVar16 [16];
ulong local_58;
int8 uStack_50;
ulong local_48;
int8 *local_40;
int8 local_38;
int8 uVar8;
local_58 = local_58 & 0xffffffff00000000;
uStack_50 = 3;
auVar15 = JS_ToObject();
uVar10 = auVar15._8_8_;
puVar5 = auVar15._0_8_;
uVar8 = uVar10;
puVar6 = (int8 *)js_get_length64(param_1,&local_48,puVar5);
uVar7 = (uint)uVar8;
if ((int)puVar6 == 0) {
if (((auVar15._8_4_ == -1) && (puVar6 = puVar5, *(short *)((long)puVar5 + 6) == 2)) &&
((*(byte *)((long)puVar5 + 5) & 8) != 0)) {
uVar7 = *(uint *)(puVar5 + 8);
puVar6 = (int8 *)puVar5[7];
bVar2 = true;
}
else {
bVar2 = false;
}
if ((bVar2) && (local_48 == uVar7)) {
if (1 < uVar7) {
uVar9 = (ulong)(uVar7 - 1);
puVar11 = puVar6 + uVar9 * 2;
uVar12 = 0;
do {
uVar9 = uVar9 - 1;
uVar8 = *puVar6;
uVar10 = puVar6[1];
uVar1 = puVar11[1];
*puVar6 = *puVar11;
puVar6[1] = uVar1;
*puVar11 = uVar8;
puVar11[1] = uVar10;
uVar12 = uVar12 + 1;
puVar6 = puVar6 + 2;
puVar11 = puVar11 + -2;
} while (uVar12 < (uVar9 & 0xffffffff));
}
}
else if (1 < (long)local_48) {
lVar13 = local_48 - 1;
lVar14 = 0;
local_40 = puVar5;
do {
iVar3 = JS_TryGetPropertyInt64(param_1,puVar5,uVar10,lVar14,&local_58);
if (iVar3 < 0) goto LAB_00175760;
iVar4 = JS_TryGetPropertyInt64(param_1,puVar5,uVar10,lVar13,&local_40);
if (iVar4 < 0) goto LAB_00175760;
if (iVar4 == 0) {
if (iVar3 != 0) {
iVar3 = JS_DeletePropertyInt64(param_1,puVar5,uVar10,lVar14,0x4000);
if (-1 < iVar3) goto LAB_001758bd;
goto LAB_00175760;
}
}
else {
iVar4 = JS_SetPropertyInt64(param_1,puVar5,uVar10,lVar14,local_40,local_38);
if (iVar4 < 0) goto LAB_00175760;
if (iVar3 == 0) {
iVar3 = JS_DeletePropertyInt64(param_1,puVar5,uVar10,lVar13,0x4000);
}
else {
LAB_001758bd:
iVar3 = JS_SetPropertyInt64(param_1,puVar5,uVar10,lVar13,local_58,uStack_50);
local_58 = local_58 & 0xffffffff00000000;
uStack_50 = 3;
}
if (iVar3 < 0) goto LAB_00175760;
}
lVar14 = lVar14 + 1;
lVar13 = lVar13 + -1;
} while (lVar14 < lVar13);
}
uVar9 = (ulong)puVar5 & 0xffffffff00000000;
}
else {
LAB_00175760:
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_58,uStack_50);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),puVar5,uVar10);
auVar15 = ZEXT816(6) << 0x40;
uVar9 = 0;
}
auVar16._0_8_ = auVar15._0_8_ & 0xffffffff | uVar9;
auVar16._8_8_ = auVar15._8_8_;
return auVar16;
}
|
|
64,789 |
js_array_reverse
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_reverse(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, lval, hval;
JSValue *arrp;
int64_t len, l, h;
int l_present, h_present;
uint32_t count32;
lval = JS_UNDEFINED;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
/* Special case fast arrays */
if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
uint32_t ll, hh;
if (count32 > 1) {
for (ll = 0, hh = count32 - 1; ll < hh; ll++, hh--) {
lval = arrp[ll];
arrp[ll] = arrp[hh];
arrp[hh] = lval;
}
}
return obj;
}
for (l = 0, h = len - 1; l < h; l++, h--) {
l_present = JS_TryGetPropertyInt64(ctx, obj, l, &lval);
if (l_present < 0)
goto exception;
h_present = JS_TryGetPropertyInt64(ctx, obj, h, &hval);
if (h_present < 0)
goto exception;
if (h_present) {
if (JS_SetPropertyInt64(ctx, obj, l, hval) < 0)
goto exception;
if (l_present) {
if (JS_SetPropertyInt64(ctx, obj, h, lval) < 0) {
lval = JS_UNDEFINED;
goto exception;
}
lval = JS_UNDEFINED;
} else {
if (JS_DeletePropertyInt64(ctx, obj, h, JS_PROP_THROW) < 0)
goto exception;
}
} else {
if (l_present) {
if (JS_DeletePropertyInt64(ctx, obj, l, JS_PROP_THROW) < 0)
goto exception;
if (JS_SetPropertyInt64(ctx, obj, h, lval) < 0) {
lval = JS_UNDEFINED;
goto exception;
}
lval = JS_UNDEFINED;
}
}
}
return obj;
exception:
JS_FreeValue(ctx, lval);
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O3
|
c
|
js_array_reverse:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movl $0x0, (%rsp)
movq $0x3, 0x8(%rsp)
callq 0x268d8
movq %rax, %rbx
movq %rdx, %r14
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x226df
testl %eax, %eax
je 0x78027
addq $0x18, %r15
movq (%r15), %rdi
cmpl $-0x9, %r14d
jb 0x78018
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %eax
jg 0x78018
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20d90
xorl %ebx, %ebx
xorl %ecx, %ecx
movl $0x6, %r14d
jmp 0x781d2
cmpl $-0x1, %r14d
jne 0x7803e
cmpw $0x2, 0x6(%rbx)
jne 0x7803e
testb $0x8, 0x5(%rbx)
jne 0x7816e
movq 0x10(%rsp), %r12
cmpq $0x2, %r12
jl 0x781c2
decq %r12
xorl %r13d, %r13d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %rsp, %r8
callq 0x4e98a
testl %eax, %eax
js 0x7813a
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
leaq 0x18(%rsp), %r8
callq 0x4e98a
testl %eax, %eax
js 0x7813a
je 0x780d5
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x24d20
testl %eax, %eax
js 0x7813a
testl %ebp, %ebp
jne 0x780f4
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
movl $0x4000, %r8d # imm = 0x4000
callq 0x26f31
testl %eax, %eax
jns 0x78126
jmp 0x7813a
testl %ebp, %ebp
je 0x78126
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
movl $0x4000, %r8d # imm = 0x4000
callq 0x26f31
testl %eax, %eax
js 0x7813a
movq (%rsp), %r8
movq 0x8(%rsp), %r9
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x24d20
testl %eax, %eax
js 0x77ff4
movl $0x0, (%rsp)
movq $0x3, 0x8(%rsp)
incq %r13
decq %r12
cmpq %r12, %r13
jl 0x78053
jmp 0x781c2
movq 0x8(%rsp), %rdx
movq 0x18(%r15), %rdi
cmpl $-0x9, %edx
jb 0x77ffb
movq (%rsp), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x77ffb
addq $0x18, %r15
callq 0x20d90
jmp 0x77ff8
movl 0x40(%rbx), %eax
movq 0x10(%rsp), %r12
cmpq %rax, %r12
jne 0x78043
cmpl $0x2, %eax
jb 0x781c2
movq 0x38(%rbx), %rcx
decl %eax
movq %rax, %rdx
shlq $0x4, %rdx
addq %rcx, %rdx
decq %rax
xorl %esi, %esi
movups (%rcx), %xmm0
movaps %xmm0, (%rsp)
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movaps (%rsp), %xmm0
movups %xmm0, (%rdx)
incq %rsi
movl %eax, %edi
addq $0x10, %rcx
addq $-0x10, %rdx
decq %rax
cmpq %rdi, %rsi
jb 0x78199
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbx, %rcx
andq %rax, %rcx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_array_reverse:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdi
mov dword ptr [rsp+58h+var_58], 0
mov qword ptr [rsp+58h+var_58+8], 3
call JS_ToObject
mov rbx, rax
mov r14, rdx
lea rsi, [rsp+58h+var_48]
mov rdi, r15
mov rdx, rax
mov rcx, r14
call js_get_length64
test eax, eax
jz short loc_78027
loc_77FF4:
add r15, 18h
loc_77FF8:
mov rdi, [r15]
loc_77FFB:
cmp r14d, 0FFFFFFF7h
jb short loc_78018
mov eax, [rbx]
lea ecx, [rax-1]
mov [rbx], ecx
cmp eax, 1
jg short loc_78018
mov rsi, rbx
mov rdx, r14
call js_free_value_rt
loc_78018:
xor ebx, ebx
xor ecx, ecx
mov r14d, 6
jmp loc_781D2
loc_78027:
cmp r14d, 0FFFFFFFFh
jnz short loc_7803E
cmp word ptr [rbx+6], 2
jnz short loc_7803E
test byte ptr [rbx+5], 8
jnz loc_7816E
loc_7803E:
mov r12, [rsp+58h+var_48]
loc_78043:
cmp r12, 2
jl loc_781C2
dec r12
xor r13d, r13d
loc_78053:
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov rcx, r13
mov r8, rsp
call JS_TryGetPropertyInt64
test eax, eax
js loc_7813A
mov ebp, eax
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov rcx, r12
lea r8, [rsp+58h+var_40]
call JS_TryGetPropertyInt64
test eax, eax
js loc_7813A
jz short loc_780D5
mov r8, [rsp+58h+var_40]
mov r9, [rsp+58h+var_38]
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov rcx, r13
call JS_SetPropertyInt64
test eax, eax
js loc_7813A
test ebp, ebp
jnz short loc_780F4
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov rcx, r12
mov r8d, 4000h
call JS_DeletePropertyInt64
test eax, eax
jns short loc_78126
jmp short loc_7813A
loc_780D5:
test ebp, ebp
jz short loc_78126
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov rcx, r13
mov r8d, 4000h
call JS_DeletePropertyInt64
test eax, eax
js short loc_7813A
loc_780F4:
mov r8, qword ptr [rsp+58h+var_58]
mov r9, qword ptr [rsp+58h+var_58+8]
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov rcx, r12
call JS_SetPropertyInt64
test eax, eax
js loc_77FF4
mov dword ptr [rsp+58h+var_58], 0
mov qword ptr [rsp+58h+var_58+8], 3
loc_78126:
inc r13
dec r12
cmp r13, r12
jl loc_78053
jmp loc_781C2
loc_7813A:
mov rdx, qword ptr [rsp+58h+var_58+8]
mov rdi, [r15+18h]
cmp edx, 0FFFFFFF7h
jb loc_77FFB
mov rsi, qword ptr [rsp+58h+var_58]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg loc_77FFB
add r15, 18h
call js_free_value_rt
jmp loc_77FF8
loc_7816E:
mov eax, [rbx+40h]
mov r12, [rsp+58h+var_48]
cmp r12, rax
jnz loc_78043
cmp eax, 2
jb short loc_781C2
mov rcx, [rbx+38h]
dec eax
mov rdx, rax
shl rdx, 4
add rdx, rcx
dec rax
xor esi, esi
loc_78199:
movups xmm0, xmmword ptr [rcx]
movaps [rsp+58h+var_58], xmm0
movups xmm0, xmmword ptr [rdx]
movups xmmword ptr [rcx], xmm0
movaps xmm0, [rsp+58h+var_58]
movups xmmword ptr [rdx], xmm0
inc rsi
mov edi, eax
add rcx, 10h
add rdx, 0FFFFFFFFFFFFFFF0h
dec rax
cmp rsi, rdi
jb short loc_78199
loc_781C2:
mov rax, 0FFFFFFFF00000000h
mov rcx, rbx
and rcx, rax
loc_781D2:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long js_array_reverse(
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)
{
long long v15; // rbx
unsigned long long v16; // rdx
unsigned long long v17; // r14
long long v18; // r8
long long v19; // r9
long long *v20; // r15
long long v21; // rdi
int v22; // eax
long long v23; // rcx
unsigned long long v24; // rcx
long long v25; // r12
int *v26; // r12
int *v27; // r13
int PropertyInt64; // eax
int v29; // ebp
int v30; // eax
double v31; // xmm4_8
double v32; // xmm5_8
double v33; // xmm4_8
double v34; // xmm5_8
long long v35; // rdx
_QWORD *v36; // rsi
int v37; // eax
long long v38; // rcx
long long v39; // rax
__int128 *v40; // rcx
long long v41; // rax
__int128 *v42; // rdx
long long v43; // rax
unsigned long long v44; // rsi
unsigned long long v45; // rdi
__int128 v47; // [rsp+0h] [rbp-58h] BYREF
long long v48; // [rsp+10h] [rbp-48h] BYREF
_QWORD *v49[8]; // [rsp+18h] [rbp-40h] BYREF
LODWORD(v47) = 0;
*((_QWORD *)&v47 + 1) = 3LL;
v15 = JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v17 = v16;
if ( (unsigned int)js_get_length64(a1, &v48, v15, v16) )
{
LABEL_2:
v20 = (long long *)(a1 + 24);
goto LABEL_3;
}
if ( (_DWORD)v17 == -1 && *(_WORD *)(v15 + 6) == 2 && (*(_BYTE *)(v15 + 5) & 8) != 0 )
{
v39 = *(unsigned int *)(v15 + 64);
v25 = v48;
if ( v48 == v39 )
{
if ( (unsigned int)v39 >= 2 )
{
v40 = *(__int128 **)(v15 + 56);
v41 = (unsigned int)(v39 - 1);
v42 = &v40[v41];
v43 = v41 - 1;
v44 = 0LL;
do
{
v47 = *v40;
*v40 = *v42;
*v42 = v47;
++v44;
v45 = (unsigned int)v43;
++v40;
--v42;
--v43;
}
while ( v44 < v45 );
}
goto LABEL_34;
}
}
else
{
v25 = v48;
}
if ( v25 < 2 )
{
LABEL_34:
v24 = v15 & 0xFFFFFFFF00000000LL;
return v24 | (unsigned int)v15;
}
v26 = (int *)(v25 - 1);
v27 = 0LL;
while ( 1 )
{
PropertyInt64 = JS_TryGetPropertyInt64(a1, v15, v17, (unsigned long long)v27, (long long)&v47);
if ( PropertyInt64 < 0 )
break;
v29 = PropertyInt64;
v30 = JS_TryGetPropertyInt64(a1, v15, v17, (unsigned long long)v26, (long long)v49);
if ( v30 < 0 )
break;
if ( v30 )
{
if ( (int)JS_SetPropertyInt64(
a1,
v15,
v17,
v27,
v49[0],
(long long)v49[1],
*(double *)a7.m128_u64,
a8,
a9,
a10,
v31,
v32,
a13,
a14) < 0 )
break;
if ( v29 )
goto LABEL_23;
if ( (int)JS_DeletePropertyInt64(a1, v15, v17, (unsigned long long)v26, 0x4000, a7, a8, a9, a10, v33, v34, a13, a14) < 0 )
break;
}
else if ( v29 )
{
if ( (int)JS_DeletePropertyInt64(a1, v15, v17, (unsigned long long)v27, 0x4000, a7, a8, a9, a10, v31, v32, a13, a14) < 0 )
break;
LABEL_23:
if ( (int)JS_SetPropertyInt64(
a1,
v15,
v17,
v26,
(_QWORD *)v47,
*((long long *)&v47 + 1),
*(double *)a7.m128_u64,
a8,
a9,
a10,
v33,
v34,
a13,
a14) < 0 )
goto LABEL_2;
LODWORD(v47) = 0;
*((_QWORD *)&v47 + 1) = 3LL;
}
v27 = (int *)((char *)v27 + 1);
v26 = (int *)((char *)v26 - 1);
if ( (long long)v27 >= (long long)v26 )
goto LABEL_34;
}
v35 = *((_QWORD *)&v47 + 1);
v21 = *(_QWORD *)(a1 + 24);
if ( DWORD2(v47) >= 0xFFFFFFF7 )
{
v36 = (_QWORD *)v47;
v37 = *(_DWORD *)v47;
v38 = (unsigned int)(*(_DWORD *)v47 - 1);
*(_DWORD *)v47 = v38;
if ( v37 <= 1 )
{
v20 = (long long *)(a1 + 24);
js_free_value_rt(v21, v36, v35, v38, v18, v19);
LABEL_3:
v21 = *v20;
}
}
if ( (unsigned int)v17 >= 0xFFFFFFF7 )
{
v22 = *(_DWORD *)v15;
v23 = (unsigned int)(*(_DWORD *)v15 - 1);
*(_DWORD *)v15 = v23;
if ( v22 <= 1 )
js_free_value_rt(v21, (_QWORD *)v15, v17, v23, v18, v19);
}
LODWORD(v15) = 0;
v24 = 0LL;
return v24 | (unsigned int)v15;
}
|
js_array_reverse:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDI
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x3
CALL 0x001268d8
MOV RBX,RAX
MOV R14,RDX
LEA RSI,[RSP + 0x10]
MOV RDI,R15
MOV RDX,RAX
MOV RCX,R14
CALL 0x001226df
TEST EAX,EAX
JZ 0x00178027
LAB_00177ff4:
ADD R15,0x18
LAB_00177ff8:
MOV RDI,qword ptr [R15]
LAB_00177ffb:
CMP R14D,-0x9
JC 0x00178018
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX],ECX
CMP EAX,0x1
JG 0x00178018
MOV RSI,RBX
MOV RDX,R14
CALL 0x00120d90
LAB_00178018:
XOR EBX,EBX
XOR ECX,ECX
MOV R14D,0x6
JMP 0x001781d2
LAB_00178027:
CMP R14D,-0x1
JNZ 0x0017803e
CMP word ptr [RBX + 0x6],0x2
JNZ 0x0017803e
TEST byte ptr [RBX + 0x5],0x8
JNZ 0x0017816e
LAB_0017803e:
MOV R12,qword ptr [RSP + 0x10]
LAB_00178043:
CMP R12,0x2
JL 0x001781c2
DEC R12
XOR R13D,R13D
LAB_00178053:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R13
MOV R8,RSP
CALL 0x0014e98a
TEST EAX,EAX
JS 0x0017813a
MOV EBP,EAX
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R12
LEA R8,[RSP + 0x18]
CALL 0x0014e98a
TEST EAX,EAX
JS 0x0017813a
JZ 0x001780d5
MOV R8,qword ptr [RSP + 0x18]
MOV R9,qword ptr [RSP + 0x20]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R13
CALL 0x00124d20
TEST EAX,EAX
JS 0x0017813a
TEST EBP,EBP
JNZ 0x001780f4
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R12
MOV R8D,0x4000
CALL 0x00126f31
TEST EAX,EAX
JNS 0x00178126
JMP 0x0017813a
LAB_001780d5:
TEST EBP,EBP
JZ 0x00178126
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R13
MOV R8D,0x4000
CALL 0x00126f31
TEST EAX,EAX
JS 0x0017813a
LAB_001780f4:
MOV R8,qword ptr [RSP]
MOV R9,qword ptr [RSP + 0x8]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R12
CALL 0x00124d20
TEST EAX,EAX
JS 0x00177ff4
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x3
LAB_00178126:
INC R13
DEC R12
CMP R13,R12
JL 0x00178053
JMP 0x001781c2
LAB_0017813a:
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [R15 + 0x18]
CMP EDX,-0x9
JC 0x00177ffb
MOV RSI,qword ptr [RSP]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x00177ffb
ADD R15,0x18
CALL 0x00120d90
JMP 0x00177ff8
LAB_0017816e:
MOV EAX,dword ptr [RBX + 0x40]
MOV R12,qword ptr [RSP + 0x10]
CMP R12,RAX
JNZ 0x00178043
CMP EAX,0x2
JC 0x001781c2
MOV RCX,qword ptr [RBX + 0x38]
DEC EAX
MOV RDX,RAX
SHL RDX,0x4
ADD RDX,RCX
DEC RAX
XOR ESI,ESI
LAB_00178199:
MOVUPS XMM0,xmmword ptr [RCX]
MOVAPS xmmword ptr [RSP],XMM0
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS xmmword ptr [RCX],XMM0
MOVAPS XMM0,xmmword ptr [RSP]
MOVUPS xmmword ptr [RDX],XMM0
INC RSI
MOV EDI,EAX
ADD RCX,0x10
ADD RDX,-0x10
DEC RAX
CMP RSI,RDI
JC 0x00178199
LAB_001781c2:
MOV RAX,-0x100000000
MOV RCX,RBX
AND RCX,RAX
LAB_001781d2:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_array_reverse(long param_1)
{
uint uVar1;
int8 uVar2;
int iVar3;
int iVar4;
int *piVar5;
int8 *puVar6;
ulong uVar7;
int8 uVar8;
int8 *puVar9;
ulong uVar10;
int8 uVar11;
long lVar12;
long lVar13;
int1 auVar14 [16];
int1 auVar15 [16];
int *local_58;
int8 uStack_50;
ulong local_48;
int8 local_40;
int8 local_38;
local_58 = (int *)((ulong)local_58 & 0xffffffff00000000);
uStack_50 = 3;
auVar14 = JS_ToObject();
uVar8 = auVar14._8_8_;
piVar5 = auVar14._0_8_;
iVar3 = js_get_length64(param_1,&local_48,piVar5,uVar8);
if (iVar3 == 0) {
if ((((auVar14._8_4_ == 0xffffffff) && (*(short *)((long)piVar5 + 6) == 2)) &&
((*(byte *)((long)piVar5 + 5) & 8) != 0)) && (uVar1 = piVar5[0x10], local_48 == uVar1)) {
if (1 < uVar1) {
puVar6 = *(int8 **)(piVar5 + 0xe);
uVar7 = (ulong)(uVar1 - 1);
puVar9 = puVar6 + uVar7 * 2;
uVar10 = 0;
do {
uVar7 = uVar7 - 1;
uVar8 = *puVar6;
uVar11 = puVar6[1];
uVar2 = puVar9[1];
*puVar6 = *puVar9;
puVar6[1] = uVar2;
*puVar9 = uVar8;
puVar9[1] = uVar11;
uVar10 = uVar10 + 1;
puVar6 = puVar6 + 2;
puVar9 = puVar9 + -2;
} while (uVar10 < (uVar7 & 0xffffffff));
}
}
else if (1 < (long)local_48) {
lVar12 = local_48 - 1;
lVar13 = 0;
LAB_00178053:
iVar3 = JS_TryGetPropertyInt64(param_1,piVar5,uVar8,lVar13,&local_58);
if (-1 < iVar3) {
iVar4 = JS_TryGetPropertyInt64(param_1,piVar5,uVar8,lVar12,&local_40);
if (iVar4 < 0) goto LAB_0017813a;
if (iVar4 == 0) {
if (iVar3 != 0) {
iVar3 = JS_DeletePropertyInt64(param_1,piVar5,uVar8,lVar13,0x4000);
if (-1 < iVar3) goto LAB_001780f4;
goto LAB_0017813a;
}
LAB_00178126:
lVar13 = lVar13 + 1;
lVar12 = lVar12 + -1;
if (lVar12 <= lVar13) goto LAB_001781c2;
goto LAB_00178053;
}
iVar4 = JS_SetPropertyInt64(param_1,piVar5,uVar8,lVar13,local_40,local_38);
if (iVar4 < 0) goto LAB_0017813a;
if (iVar3 != 0) {
LAB_001780f4:
iVar3 = JS_SetPropertyInt64(param_1,piVar5,uVar8,lVar12,local_58,uStack_50);
if (-1 < iVar3) {
local_58 = (int *)((ulong)local_58 & 0xffffffff00000000);
uStack_50 = 3;
goto LAB_00178126;
}
goto LAB_00177ff8;
}
iVar3 = JS_DeletePropertyInt64(param_1,piVar5,uVar8,lVar12,0x4000);
if (-1 < iVar3) goto LAB_00178126;
}
LAB_0017813a:
uVar11 = *(int8 *)(param_1 + 0x18);
if (((uint)uStack_50 < 0xfffffff7) || (iVar3 = *local_58, *local_58 = iVar3 + -1, 1 < iVar3))
goto LAB_00177ffb;
js_free_value_rt(uVar11);
goto LAB_00177ff8;
}
LAB_001781c2:
uVar7 = (ulong)piVar5 & 0xffffffff00000000;
}
else {
LAB_00177ff8:
uVar11 = *(int8 *)(param_1 + 0x18);
LAB_00177ffb:
if ((0xfffffff6 < auVar14._8_4_) && (iVar3 = *piVar5, *piVar5 = iVar3 + -1, iVar3 < 2)) {
js_free_value_rt(uVar11,piVar5,uVar8);
}
uVar7 = 0;
auVar14 = ZEXT816(6) << 0x40;
}
auVar15._0_8_ = auVar14._0_8_ & 0xffffffff | uVar7;
auVar15._8_8_ = auVar14._8_8_;
return auVar15;
}
|
|
64,790 |
set_process_priority(ggml_sched_priority)
|
monkey531[P]llama/common/common.cpp
|
bool set_process_priority(enum ggml_sched_priority prio) {
if (prio == GGML_SCHED_PRIO_NORMAL) {
return true;
}
int p = 0;
switch (prio) {
case GGML_SCHED_PRIO_NORMAL: p = 0; break;
case GGML_SCHED_PRIO_MEDIUM: p = -5; break;
case GGML_SCHED_PRIO_HIGH: p = -10; break;
case GGML_SCHED_PRIO_REALTIME: p = -20; break;
}
if (!setpriority(PRIO_PROCESS, 0, p)) {
LOG_WRN("failed to set process priority %d : %s (%d)\n", prio, strerror(errno), errno);
return false;
}
return true;
}
|
O2
|
cpp
|
set_process_priority(ggml_sched_priority):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpl $0x3, %edi
ja 0x52de6
movl %ebx, %eax
leaq 0x5e835(%rip), %rcx # 0xb1600
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %bpl
jmp 0x52e3a
pushq $-0xa
jmp 0x52de3
pushq $-0x14
jmp 0x52de3
pushq $-0x5
popq %rdx
jmp 0x52de8
xorl %edx, %edx
xorl %edi, %edi
xorl %esi, %esi
callq 0x23230
testl %eax, %eax
setne %bpl
jne 0x52e3a
leaq 0xaa648(%rip), %rax # 0xfd448
cmpl $0x0, (%rax)
js 0x52e3a
callq 0x95f0e
movq %rax, %r14
callq 0x23050
movq %rax, %r15
movl (%rax), %edi
callq 0x232c0
movl (%r15), %r9d
leaq 0x5ebe0(%rip), %rdx # 0xb1a06
xorl %ebp, %ebp
pushq $0x3
popq %rsi
movq %r14, %rdi
movl %ebx, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0x95fa6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
_Z20set_process_priority19ggml_sched_priority:
push rbp
push r15
push r14
push rbx
push rax
mov ebx, edi
cmp edi, 3; switch 4 cases
ja short def_52DD2; jumptable 0000000000052DD2 default case
mov eax, ebx
lea rcx, jpt_52DD2
movsxd rax, ds:(jpt_52DD2 - 0B1600h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_52DD4:
mov bpl, 1; jumptable 0000000000052DD2 case 0
jmp short loc_52E3A
loc_52DD9:
push 0FFFFFFFFFFFFFFF6h; jumptable 0000000000052DD2 case 2
jmp short loc_52DE3
loc_52DDD:
push 0FFFFFFFFFFFFFFECh; jumptable 0000000000052DD2 case 3
jmp short loc_52DE3
loc_52DE1:
push 0FFFFFFFFFFFFFFFBh; jumptable 0000000000052DD2 case 1
loc_52DE3:
pop rdx
jmp short loc_52DE8
def_52DD2:
xor edx, edx; jumptable 0000000000052DD2 default case
loc_52DE8:
xor edi, edi
xor esi, esi
call _setpriority
test eax, eax
setnz bpl
jnz short loc_52E3A
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_52E3A
call _Z15common_log_mainv; common_log_main(void)
mov r14, rax
call ___errno_location
mov r15, rax
mov edi, [rax]
call _strerror
mov r9d, [r15]
lea rdx, aFailedToSetPro; "failed to set process priority %d : %s "...
xor ebp, ebp
push 3
pop rsi
mov rdi, r14
mov ecx, ebx
mov r8, rax
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_52E3A:
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long set_process_priority(int a1)
{
unsigned int v1; // ebp
long long v2; // rdx
int v3; // eax
int v4; // r14d
unsigned int *v5; // r15
int v6; // eax
long long v8; // [rsp-10h] [rbp-30h]
switch ( a1 )
{
case 0:
LOBYTE(v1) = 1;
return v1;
case 1:
v8 = -5LL;
goto LABEL_6;
case 2:
v8 = -10LL;
goto LABEL_6;
case 3:
v8 = -20LL;
LABEL_6:
v2 = v8;
break;
default:
v2 = 0LL;
break;
}
v3 = setpriority(0LL, 0LL, v2);
LOBYTE(v1) = v3 != 0;
if ( !v3 && common_log_verbosity_thold >= 0 )
{
v4 = common_log_main();
v5 = (unsigned int *)__errno_location(0LL);
v6 = strerror(*v5);
v1 = 0;
common_log_add(v4, 3, (unsigned int)"failed to set process priority %d : %s (%d)\n", a1, v6, *v5);
}
return v1;
}
|
set_process_priority:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,EDI
CMP EDI,0x3
JA 0x00152de6
MOV EAX,EBX
LEA RCX,[0x1b1600]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV BPL,0x1
JMP 0x00152e3a
caseD_2:
PUSH -0xa
JMP 0x00152de3
caseD_3:
PUSH -0x14
JMP 0x00152de3
caseD_1:
PUSH -0x5
LAB_00152de3:
POP RDX
JMP 0x00152de8
default:
XOR EDX,EDX
LAB_00152de8:
XOR EDI,EDI
XOR ESI,ESI
CALL 0x00123230
TEST EAX,EAX
SETNZ BPL
JNZ 0x00152e3a
LEA RAX,[0x1fd448]
CMP dword ptr [RAX],0x0
JS 0x00152e3a
CALL 0x00195f0e
MOV R14,RAX
CALL 0x00123050
MOV R15,RAX
MOV EDI,dword ptr [RAX]
CALL 0x001232c0
MOV R9D,dword ptr [R15]
LEA RDX,[0x1b1a06]
XOR EBP,EBP
PUSH 0x3
POP RSI
MOV RDI,R14
MOV ECX,EBX
MOV R8,RAX
XOR EAX,EAX
CALL 0x00195fa6
LAB_00152e3a:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* set_process_priority(ggml_sched_priority) */
ulong set_process_priority(int4 param_1)
{
int iVar1;
int8 uVar2;
int *piVar3;
char *pcVar4;
int8 unaff_RBP;
int7 uVar6;
ulong uVar5;
uVar6 = (int7)((ulong)unaff_RBP >> 8);
switch(param_1) {
case 0:
uVar5 = CONCAT71(uVar6,1);
goto LAB_00152e3a;
case 1:
iVar1 = -5;
break;
case 2:
iVar1 = -10;
break;
case 3:
iVar1 = -0x14;
break;
default:
iVar1 = 0;
}
iVar1 = setpriority(PRIO_PROCESS,0,iVar1);
uVar5 = CONCAT71(uVar6,iVar1 != 0);
if ((iVar1 == 0) && (-1 < common_log_verbosity_thold)) {
uVar2 = common_log_main();
piVar3 = __errno_location();
pcVar4 = strerror(*piVar3);
uVar5 = 0;
common_log_add(uVar2,3,"failed to set process priority %d : %s (%d)\n",param_1,pcVar4,*piVar3);
}
LAB_00152e3a:
return uVar5 & 0xffffffff;
}
|
|
64,791 |
ma_init_alloc_root
|
eloqsql/libmariadb/libmariadb/ma_alloc.c
|
void ma_init_alloc_root(MA_MEM_ROOT *mem_root, size_t block_size, size_t pre_alloc_size)
{
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc=32;
mem_root->block_size= (block_size-MALLOC_OVERHEAD-sizeof(MA_USED_MEM)+8);
mem_root->error_handler=0;
mem_root->block_num= 4;
mem_root->first_block_usage= 0;
#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
if ((mem_root->free = mem_root->pre_alloc=
(MA_USED_MEM*) malloc(pre_alloc_size+ ALIGN_SIZE(sizeof(MA_USED_MEM)))))
{
mem_root->free->size=pre_alloc_size+ALIGN_SIZE(sizeof(MA_USED_MEM));
mem_root->free->left=pre_alloc_size;
mem_root->free->next=0;
}
}
#endif
}
|
O0
|
c
|
ma_init_alloc_root:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x20, 0x18(%rax)
movq -0x10(%rbp), %rcx
subq $0x8, %rcx
subq $0x18, %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x3f1b8
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x145c0
movq -0x8(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x3f1b6
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
jmp 0x3f1b8
addq $0x20, %rsp
popq %rbp
retq
nop
|
ma_init_alloc_root:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+18h], 20h ; ' '
mov rcx, [rbp+var_10]
sub rcx, 8
sub rcx, 18h
add rcx, 8
mov rax, [rbp+var_8]
mov [rax+20h], rcx
mov rax, [rbp+var_8]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+28h], 4
mov rax, [rbp+var_8]
mov dword ptr [rax+2Ch], 0
cmp [rbp+var_18], 0
jz short loc_3F1B8
mov rdi, [rbp+var_18]
add rdi, 18h
call _malloc
mov rcx, [rbp+var_8]
mov [rcx+10h], rax
mov rcx, [rbp+var_8]
mov [rcx], rax
cmp rax, 0
jz short loc_3F1B6
mov rcx, [rbp+var_18]
add rcx, 18h
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+10h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+8], rcx
mov rax, [rbp+var_8]
mov rax, [rax]
mov qword ptr [rax], 0
loc_3F1B6:
jmp short $+2
loc_3F1B8:
add rsp, 20h
pop rbp
retn
|
long long ma_init_alloc_root(long long *a1, long long a2, long long a3)
{
long long result; // rax
a1[2] = 0LL;
a1[1] = 0LL;
*a1 = 0LL;
a1[3] = 32LL;
a1[4] = a2 - 32 + 8;
a1[6] = 0LL;
*((_DWORD *)a1 + 10) = 4;
result = (long long)a1;
*((_DWORD *)a1 + 11) = 0;
if ( a3 )
{
result = malloc(a3 + 24);
a1[2] = result;
*a1 = result;
if ( result )
{
*(_QWORD *)(*a1 + 16) = a3 + 24;
*(_QWORD *)(*a1 + 8) = a3;
result = *a1;
*(_QWORD *)*a1 = 0LL;
}
}
return result;
}
|
ma_init_alloc_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],0x20
MOV RCX,qword ptr [RBP + -0x10]
SUB RCX,0x8
SUB RCX,0x18
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],0x4
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c],0x0
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0013f1b8
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x18
CALL 0x001145c0
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RCX + 0x10],RAX
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x0013f1b6
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],0x0
LAB_0013f1b6:
JMP 0x0013f1b8
LAB_0013f1b8:
ADD RSP,0x20
POP RBP
RET
|
void ma_init_alloc_root(long *param_1,long param_2,long param_3)
{
void *pvVar1;
param_1[2] = 0;
param_1[1] = 0;
*param_1 = 0;
param_1[3] = 0x20;
param_1[4] = param_2 + -0x18;
param_1[6] = 0;
*(int4 *)(param_1 + 5) = 4;
*(int4 *)((long)param_1 + 0x2c) = 0;
if (param_3 != 0) {
pvVar1 = malloc(param_3 + 0x18);
param_1[2] = (long)pvVar1;
*param_1 = (long)pvVar1;
if (pvVar1 != (void *)0x0) {
*(long *)(*param_1 + 0x10) = param_3 + 0x18;
*(long *)(*param_1 + 8) = param_3;
*(int8 *)*param_1 = 0;
}
}
return;
}
|
|
64,792 |
ma_init_alloc_root
|
eloqsql/libmariadb/libmariadb/ma_alloc.c
|
void ma_init_alloc_root(MA_MEM_ROOT *mem_root, size_t block_size, size_t pre_alloc_size)
{
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc=32;
mem_root->block_size= (block_size-MALLOC_OVERHEAD-sizeof(MA_USED_MEM)+8);
mem_root->error_handler=0;
mem_root->block_num= 4;
mem_root->first_block_usage= 0;
#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
if ((mem_root->free = mem_root->pre_alloc=
(MA_USED_MEM*) malloc(pre_alloc_size+ ALIGN_SIZE(sizeof(MA_USED_MEM)))))
{
mem_root->free->size=pre_alloc_size+ALIGN_SIZE(sizeof(MA_USED_MEM));
mem_root->free->left=pre_alloc_size;
mem_root->free->next=0;
}
}
#endif
}
|
O3
|
c
|
ma_init_alloc_root:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq $0x20, 0x18(%rdi)
addq $-0x18, %rsi
movq %rsi, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movq $0x4, 0x28(%rdi)
testq %rdx, %rdx
je 0x2f422
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x18(%rdx), %r15
movq %r15, %rdi
callq 0x14620
movq %rax, 0x10(%r14)
movq %rax, (%r14)
testq %rax, %rax
je 0x2f418
movq %r15, 0x10(%rax)
movq %rbx, 0x8(%rax)
movq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
ma_init_alloc_root:
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
xor eax, eax
mov [rdi+10h], rax
mov qword ptr [rdi+18h], 20h ; ' '
add rsi, 0FFFFFFFFFFFFFFE8h
mov [rdi+20h], rsi
mov [rdi+30h], rax
mov qword ptr [rdi+28h], 4
test rdx, rdx
jz short locret_2F422
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
lea r15, [rdx+18h]
mov rdi, r15
call _malloc
mov [r14+10h], rax
mov [r14], rax
test rax, rax
jz short loc_2F418
mov [rax+10h], r15
mov [rax+8], rbx
mov qword ptr [rax], 0
loc_2F418:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_2F422:
retn
|
_QWORD * ma_init_alloc_root(long long a1, long long a2, long long a3)
{
_QWORD *result; // rax
long long v5; // r15
*(_OWORD *)a1 = 0LL;
result = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = 32LL;
*(_QWORD *)(a1 + 32) = a2 - 24;
*(_QWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 40) = 4LL;
if ( a3 )
{
v5 = a3 + 24;
result = (_QWORD *)malloc(a3 + 24);
*(_QWORD *)(a1 + 16) = result;
*(_QWORD *)a1 = result;
if ( result )
{
result[2] = v5;
result[1] = a3;
*result = 0LL;
}
}
return result;
}
|
ma_init_alloc_root:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],0x20
ADD RSI,-0x18
MOV qword ptr [RDI + 0x20],RSI
MOV qword ptr [RDI + 0x30],RAX
MOV qword ptr [RDI + 0x28],0x4
TEST RDX,RDX
JZ 0x0012f422
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
LEA R15,[RDX + 0x18]
MOV RDI,R15
CALL 0x00114620
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RAX
TEST RAX,RAX
JZ 0x0012f418
MOV qword ptr [RAX + 0x10],R15
MOV qword ptr [RAX + 0x8],RBX
MOV qword ptr [RAX],0x0
LAB_0012f418:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_0012f422:
RET
|
void ma_init_alloc_root(int8 *param_1,long param_2,long param_3)
{
int8 *puVar1;
*param_1 = 0;
param_1[1] = 0;
param_1[2] = 0;
param_1[3] = 0x20;
param_1[4] = param_2 + -0x18;
param_1[6] = 0;
param_1[5] = 4;
if (param_3 != 0) {
puVar1 = (int8 *)malloc(param_3 + 0x18U);
param_1[2] = puVar1;
*param_1 = puVar1;
if (puVar1 != (int8 *)0x0) {
puVar1[2] = param_3 + 0x18U;
puVar1[1] = param_3;
*puVar1 = 0;
}
}
return;
}
|
|
64,793 |
convert_dirname
|
eloqsql/mysys/mf_dirname.c
|
char *convert_dirname(char *to, const char *from, const char *from_end)
{
char *to_org=to;
#ifdef BACKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
DBUG_ENTER("convert_dirname");
/* We use -2 here, becasue we need place for the last FN_LIBCHAR */
if (!from_end || (from_end - from) > FN_REFLEN-2)
from_end=from+FN_REFLEN -2;
#if FN_LIBCHAR != '/'
{
for (; from != from_end && *from ; from++)
{
if (*from == '/')
*to++= FN_LIBCHAR;
else
{
#ifdef BACKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, from, from + 3)))
{
memmove(to, from, l);
to+= l;
from+= l - 1;
to_org= to; /* Don't look inside mbchar */
}
else
#endif
{
*to++= *from;
}
}
}
*to=0;
}
#else
/* This is ok even if to == from, becasue we need to cut the string */
to= strmake(to, from, (size_t) (from_end-from));
#endif
/* Add FN_LIBCHAR to the end of directory path */
if (to != to_org && (to[-1] != FN_LIBCHAR && to[-1] != FN_DEVCHAR))
{
*to++=FN_LIBCHAR;
*to=0;
}
DBUG_RETURN(to); /* Pointer to end of dir */
}
|
O0
|
c
|
convert_dirname:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe4746
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1fe, %rax # imm = 0x1FE
jle 0xe4758
movq -0x10(%rbp), %rax
addq $0x200, %rax # imm = 0x200
addq $-0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
callq 0x159ee0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xe47b1
movq -0x8(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0xe47b1
movq -0x8(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x0, %eax
je 0xe47b1
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x2f, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0xe47b3
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
|
convert_dirname:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
cmp [rbp+var_18], 0
jz short loc_E4746
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 1FEh
jle short loc_E4758
loc_E4746:
mov rax, [rbp+var_10]
add rax, 200h
add rax, 0FFFFFFFFFFFFFFFEh
mov [rbp+var_18], rax
loc_E4758:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rax, [rbp+var_10]
sub rdx, rax
call strmake
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
cmp rax, [rbp+var_20]
jz short loc_E47B1
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_E47B1
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax-1]
cmp eax, 0
jz short loc_E47B1
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
loc_E47B1:
jmp short $+2
loc_E47B3:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
|
_BYTE * convert_dirname(_BYTE *a1, long long a2, long long a3)
{
_BYTE *v3; // rax
long long v5; // [rsp+18h] [rbp-18h]
_BYTE *v6; // [rsp+28h] [rbp-8h]
v5 = a3;
if ( !a3 || a3 - a2 > 510 )
v5 = a2 + 510;
v6 = (_BYTE *)strmake(a1, a2, v5 - a2);
if ( v6 != a1 && *(v6 - 1) != 47 && *(v6 - 1) )
{
v3 = v6++;
*v3 = 47;
*v6 = 0;
}
return v6;
}
|
convert_dirname:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001e4746
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x1fe
JLE 0x001e4758
LAB_001e4746:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x200
ADD RAX,-0x2
MOV qword ptr [RBP + -0x18],RAX
LAB_001e4758:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
SUB RDX,RAX
CALL 0x00259ee0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001e47b1
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x001e47b1
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x0
JZ 0x001e47b1
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
LAB_001e47b1:
JMP 0x001e47b3
LAB_001e47b3:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
int1 * convert_dirname(int1 *param_1,long param_2,long param_3)
{
int1 *puVar1;
long local_20;
int1 *local_10;
if ((param_3 == 0) || (local_20 = param_3, 0x1fe < param_3 - param_2)) {
local_20 = param_2 + 0x1fe;
}
puVar1 = (int1 *)strmake(param_1,param_2,local_20 - param_2);
local_10 = puVar1;
if (((puVar1 != param_1) && (puVar1[-1] != '/')) && (puVar1[-1] != '\0')) {
local_10 = puVar1 + 1;
*puVar1 = 0x2f;
*local_10 = 0;
}
return local_10;
}
|
|
64,794 |
find_rh
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSOSRWHandler *find_rh(JSThreadState *ts, int fd)
{
JSOSRWHandler *rh;
struct list_head *el;
list_for_each(el, &ts->os_rw_handlers) {
rh = list_entry(el, JSOSRWHandler, link);
if (rh->fd == fd)
return rh;
}
return NULL;
}
|
O2
|
c
|
find_rh:
movq %rdi, %rax
movq 0x8(%rax), %rax
cmpq %rdi, %rax
je 0x15776
cmpl %esi, 0x10(%rax)
jne 0x15767
retq
xorl %eax, %eax
retq
|
find_rh:
mov rax, rdi
loc_15767:
mov rax, [rax+8]
cmp rax, rdi
jz short loc_15776
cmp [rax+10h], esi
jnz short loc_15767
retn
loc_15776:
xor eax, eax
retn
|
long long find_rh(long long a1, int a2)
{
long long result; // rax
result = a1;
while ( 1 )
{
result = *(_QWORD *)(result + 8);
if ( result == a1 )
break;
if ( *(_DWORD *)(result + 16) == a2 )
return result;
}
return 0LL;
}
|
find_rh:
MOV RAX,RDI
LAB_00115767:
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,RDI
JZ 0x00115776
CMP dword ptr [RAX + 0x10],ESI
JNZ 0x00115767
RET
LAB_00115776:
XOR EAX,EAX
RET
|
long find_rh(long param_1,int param_2)
{
long lVar1;
lVar1 = param_1;
do {
lVar1 = *(long *)(lVar1 + 8);
if (lVar1 == param_1) {
return 0;
}
} while (*(int *)(lVar1 + 0x10) != param_2);
return lVar1;
}
|
|
64,795 |
argh::parser::operator()(std::initializer_list<char const* const>) const
|
Andrewchistyakov[P]flashcards_lyc/src/argh.h
|
inline string_stream parser::operator()(std::initializer_list<char const* const> init_list) const
{
for (auto& name : init_list)
{
auto optIt = params_.find(trim_leading_dashes(name));
if (params_.end() != optIt)
return string_stream(optIt->second);
}
return bad_stream();
}
|
O0
|
c
|
argh::parser::operator()(std::initializer_list<char const* const>) const:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x163e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x16400
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x15c8a
movq -0xb0(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x40(%rbp)
addq $0x18, %rax
movq %rax, -0xd8(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xdaa0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x16510
jmp 0x15b6e
movq -0xb0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x16490
jmp 0x15b87
movq -0xd8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1a440
movq %rax, -0xe0(%rbp)
jmp 0x15ba0
movq -0xe0(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xdbc8
leaq -0x88(%rbp), %rdi
callq 0xdbc8
leaq -0x89(%rbp), %rdi
callq 0xd620
movq -0xb0(%rbp), %rdi
addq $0x18, %rdi
callq 0x1a4a0
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1a470
testb $0x1, %al
jne 0x15bf9
jmp 0x15c77
leaq -0x48(%rbp), %rdi
callq 0x1a4d0
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x1a4f0
jmp 0x15c9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x15c69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x15c5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xdbc8
leaq -0x88(%rbp), %rdi
callq 0xdbc8
leaq -0x89(%rbp), %rdi
callq 0xd620
jmp 0x15cad
jmp 0x15c79
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x15b09
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x1a520
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0xda90
nopl (%rax)
|
_ZNK4argh6parserclESt16initializer_listIKPKcE:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov [rbp+var_C0], rdi
mov rax, rdi
mov [rbp+var_B8], rax
mov [rbp+var_8], rdi
mov [rbp+var_18], rdx
mov [rbp+var_10], rcx
mov [rbp+var_20], rsi
mov rax, [rbp+var_20]
mov [rbp+var_B0], rax
lea rax, [rbp+var_18]
mov [rbp+var_28], rax
mov rdi, [rbp+var_28]
call _ZNKSt16initializer_listIKPKcE5beginEv; std::initializer_list<char const* const>::begin(void)
mov [rbp+var_30], rax
mov rdi, [rbp+var_28]
call _ZNKSt16initializer_listIKPKcE3endEv; std::initializer_list<char const* const>::end(void)
mov [rbp+var_38], rax
loc_15B09:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz loc_15C8A
mov rax, [rbp+var_B0]
mov rcx, [rbp+var_30]
mov [rbp+var_40], rcx
add rax, 18h
mov [rbp+var_D8], rax
mov rax, [rbp+var_40]
mov rax, [rax]
mov [rbp+var_D0], rax
lea rdi, [rbp+var_89]
mov [rbp+var_C8], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rbp+var_D0]
mov rdx, [rbp+var_C8]
lea rdi, [rbp+var_88]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_15B6E:
mov rsi, [rbp+var_B0]
lea rdi, [rbp+var_68]
lea rdx, [rbp+var_88]
call _ZNK4argh6parser19trim_leading_dashesERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; argh::parser::trim_leading_dashes(std::string const&)
jmp short $+2
loc_15B87:
mov rdi, [rbp+var_D8]
lea rsi, [rbp+var_68]
call _ZNKSt8multimapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE4findERS9_; std::multimap<std::string,std::string>::find(std::string const&)
mov [rbp+var_E0], rax
jmp short $+2
loc_15BA0:
mov rax, [rbp+var_E0]
mov [rbp+var_48], rax
lea rdi, [rbp+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_89]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rdi, [rbp+var_B0]
add rdi, 18h
call _ZNKSt8multimapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE3endEv; std::multimap<std::string,std::string>::end(void)
mov [rbp+var_A8], rax
lea rdi, [rbp+var_A8]
lea rsi, [rbp+var_48]
call _ZStneRKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_EESB_; std::operator!=(std::_Rb_tree_const_iterator<std::pair<std::string const,std::string>> const&,std::_Rb_tree_const_iterator<std::pair<std::string const,std::string>> const&)
test al, 1
jnz short loc_15BF9
jmp short loc_15C77
loc_15BF9:
lea rdi, [rbp+var_48]
call _ZNKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_EEptEv; std::_Rb_tree_const_iterator<std::pair<std::string const,std::string>>::operator->(void)
mov rdi, [rbp+var_C0]
mov rsi, rax
add rsi, 20h ; ' '
call _ZN4argh18stringstream_proxyC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; argh::stringstream_proxy::stringstream_proxy(std::string const&)
jmp loc_15C9D
mov rcx, rax
mov eax, edx
mov [rbp+var_98], rcx
mov [rbp+var_9C], eax
jmp short loc_15C69
mov rcx, rax
mov eax, edx
mov [rbp+var_98], rcx
mov [rbp+var_9C], eax
jmp short loc_15C5D
mov rcx, rax
mov eax, edx
mov [rbp+var_98], rcx
mov [rbp+var_9C], eax
lea rdi, [rbp+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_15C5D:
lea rdi, [rbp+var_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_15C69:
lea rdi, [rbp+var_89]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_15CAD
loc_15C77:
jmp short $+2
loc_15C79:
mov rax, [rbp+var_30]
add rax, 8
mov [rbp+var_30], rax
jmp loc_15B09
loc_15C8A:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZNK4argh6parser10bad_streamEv; argh::parser::bad_stream(void)
loc_15C9D:
mov rax, [rbp+var_B8]
add rsp, 0E0h
pop rbp
retn
loc_15CAD:
mov rdi, [rbp+var_98]
call __Unwind_Resume
|
argh::parser * argh::parser::operator()(argh::parser *a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v6; // [rsp+10h] [rbp-D0h]
long long v7; // [rsp+38h] [rbp-A8h] BYREF
char v8; // [rsp+57h] [rbp-89h] BYREF
_BYTE v9[32]; // [rsp+58h] [rbp-88h] BYREF
_BYTE v10[32]; // [rsp+78h] [rbp-68h] BYREF
_QWORD v11[2]; // [rsp+98h] [rbp-48h] BYREF
long long v12; // [rsp+A8h] [rbp-38h]
long long *v13; // [rsp+B0h] [rbp-30h]
_QWORD *v14; // [rsp+B8h] [rbp-28h]
long long v15; // [rsp+C0h] [rbp-20h]
_QWORD v16[3]; // [rsp+C8h] [rbp-18h] BYREF
v16[2] = a1;
v16[0] = a3;
v16[1] = a4;
v15 = a2;
v14 = v16;
v13 = (long long *)std::initializer_list<char const* const>::begin(v16);
v12 = std::initializer_list<char const* const>::end(v16);
while ( v13 != (long long *)v12 )
{
v11[1] = v13;
v6 = *v13;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(v9, v6, &v8);
argh::parser::trim_leading_dashes(v10, a2, v9);
v11[0] = std::multimap<std::string,std::string>::find(a2 + 24, v10);
std::string::~string(v10);
std::string::~string(v9);
std::allocator<char>::~allocator(&v8);
v7 = std::multimap<std::string,std::string>::end(a2 + 24);
if ( (std::operator!=(&v7, v11) & 1) != 0 )
{
v4 = std::_Rb_tree_const_iterator<std::pair<std::string const,std::string>>::operator->(v11);
argh::stringstream_proxy::stringstream_proxy(a1, v4 + 32);
return a1;
}
++v13;
}
argh::parser::bad_stream(a1);
return a1;
}
|
operator():
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV qword ptr [RBP + -0xc0],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0xb8],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x10],RCX
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0xb0],RAX
LEA RAX,[RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001163e0
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00116400
MOV qword ptr [RBP + -0x38],RAX
LAB_00115b09:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x00115c8a
MOV RAX,qword ptr [RBP + -0xb0]
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RCX
ADD RAX,0x18
MOV qword ptr [RBP + -0xd8],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xd0],RAX
LEA RDI,[RBP + -0x89]
MOV qword ptr [RBP + -0xc8],RDI
CALL 0x0010daa0
MOV RSI,qword ptr [RBP + -0xd0]
MOV RDX,qword ptr [RBP + -0xc8]
LAB_00115b60:
LEA RDI,[RBP + -0x88]
CALL 0x00116510
JMP 0x00115b6e
LAB_00115b6e:
MOV RSI,qword ptr [RBP + -0xb0]
LEA RDI,[RBP + -0x68]
LEA RDX,[RBP + -0x88]
CALL 0x00116490
JMP 0x00115b87
LAB_00115b87:
MOV RDI,qword ptr [RBP + -0xd8]
LEA RSI,[RBP + -0x68]
CALL 0x0011a440
LAB_00115b97:
MOV qword ptr [RBP + -0xe0],RAX
JMP 0x00115ba0
LAB_00115ba0:
MOV RAX,qword ptr [RBP + -0xe0]
MOV qword ptr [RBP + -0x48],RAX
LEA RDI,[RBP + -0x68]
CALL 0x0010dbc8
LEA RDI,[RBP + -0x88]
CALL 0x0010dbc8
LEA RDI,[RBP + -0x89]
CALL 0x0010d620
MOV RDI,qword ptr [RBP + -0xb0]
ADD RDI,0x18
CALL 0x0011a4a0
MOV qword ptr [RBP + -0xa8],RAX
LEA RDI,[RBP + -0xa8]
LEA RSI,[RBP + -0x48]
CALL 0x0011a470
TEST AL,0x1
JNZ 0x00115bf9
JMP 0x00115c77
LAB_00115bf9:
LEA RDI,[RBP + -0x48]
CALL 0x0011a4d0
MOV RDI,qword ptr [RBP + -0xc0]
MOV RSI,RAX
ADD RSI,0x20
CALL 0x0011a4f0
JMP 0x00115c9d
LAB_00115c77:
JMP 0x00115c79
LAB_00115c79:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x8
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00115b09
LAB_00115c8a:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x0011a520
LAB_00115c9d:
MOV RAX,qword ptr [RBP + -0xb8]
ADD RSP,0xe0
POP RBP
RET
|
/* argh::parser::TEMPNAMEPLACEHOLDERVALUE(std::initializer_list<char const* const>) const */
parser * __thiscall
argh::parser::operator()(parser *this,long param_2,int8 param_3,int8 param_4)
{
char *pcVar1;
ulong uVar2;
long lVar3;
int8 local_b0 [3];
allocator local_91;
string local_90 [32];
string local_70 [32];
int8 local_50;
int8 *local_48;
int8 *local_40;
int8 *local_38;
initializer_list<char_const*const> *local_30;
long local_28;
int8 local_20;
int8 local_18;
parser *local_10;
local_30 = (initializer_list<char_const*const> *)&local_20;
local_28 = param_2;
local_20 = param_3;
local_18 = param_4;
local_10 = this;
local_38 = (int8 *)std::initializer_list<char_const*const>::begin(local_30);
local_40 = (int8 *)std::initializer_list<char_const*const>::end(local_30);
while( true ) {
if (local_38 == local_40) {
bad_stream(this);
return this;
}
local_48 = local_38;
pcVar1 = (char *)*local_38;
std::allocator<char>::allocator();
/* try { // try from 00115b60 to 00115b6b has its CatchHandler @ 00115c1a */
std::__cxx11::string::string<std::allocator<char>>(local_90,pcVar1,&local_91);
/* try { // try from 00115b6e to 00115b84 has its CatchHandler @ 00115c2e */
trim_leading_dashes(local_70);
/* try { // try from 00115b87 to 00115b96 has its CatchHandler @ 00115c42 */
local_50 = std::
multimap<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find((multimap<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(param_2 + 0x18),local_70);
std::__cxx11::string::~string(local_70);
std::__cxx11::string::~string(local_90);
std::allocator<char>::~allocator((allocator<char> *)&local_91);
local_b0[0] = std::
multimap<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::end((multimap<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(param_2 + 0x18));
uVar2 = std::operator!=((_Rb_tree_const_iterator *)local_b0,(_Rb_tree_const_iterator *)&local_50
);
if ((uVar2 & 1) != 0) break;
local_38 = local_38 + 1;
}
lVar3 = std::_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>::
operator->((_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>
*)&local_50);
stringstream_proxy::stringstream_proxy((stringstream_proxy *)this,(string *)(lVar3 + 0x20));
return this;
}
|
|
64,796 |
argh::parser::operator()(std::initializer_list<char const* const>) const
|
Andrewchistyakov[P]flashcards_lyc/src/argh.h
|
inline string_stream parser::operator()(std::initializer_list<char const* const> init_list) const
{
for (auto& name : init_list)
{
auto optIt = params_.find(trim_leading_dashes(name));
if (params_.end() != optIt)
return string_stream(optIt->second);
}
return bad_stream();
}
|
O1
|
c
|
argh::parser::operator()(std::initializer_list<char const* const>) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x60(%rsp)
movq %rdi, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
testq %rcx, %rcx
sete %r13b
je 0x10415
movq %rsi, %r12
leaq 0x18(%rsi), %rax
movq %rax, 0x58(%rsp)
addq $0x20, %r12
shlq $0x3, 0x10(%rsp)
xorl %ebx, %ebx
leaq 0x18(%rsp), %rbp
leaq 0x38(%rsp), %r15
movq 0x60(%rsp), %rax
movq (%rax,%rbx), %rsi
movq %rbp, %rdi
leaq 0x7(%rsp), %rdx
callq 0x106b4
movq %rbp, %rdi
movl $0x2d, %esi
xorl %edx, %edx
callq 0xb380
cmpq $-0x1, %rax
je 0x10372
movq %r15, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0xb420
jmp 0x10391
leaq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x11e4e
movq 0x58(%rsp), %rdi
movq %r15, %r14
movq %r15, %rsi
callq 0x11bbc
movq %rax, %r15
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x103c0
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x103dc
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb400
cmpq %r15, %r12
jne 0x103f9
addq $0x8, %rbx
cmpq %rbx, 0x10(%rsp)
sete %r13b
movq %r14, %r15
jne 0x10330
jmp 0x10415
addq $0x40, %r15
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0xb6f0
testb $0x1, %r13b
je 0x10439
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xb2c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x4, %esi
callq 0xb710
movq 0x8(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x49b49(%rip), %rsi # 0x59fa0
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xb5f0
addq $0x78, %r14
movq %r14, %rdi
callq 0xb120
jmp 0x104b7
movq %rax, %rbx
jmp 0x10496
movq %rax, %rbx
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x10496
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x104b7
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x104b7
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb780
nop
|
_ZNK4argh6parserclESt16initializer_listIKPKcE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rsp+98h+var_38], rdx
mov [rsp+98h+var_90], rdi
mov [rsp+98h+var_88], rcx
test rcx, rcx
setz r13b
jz loc_10415
mov r12, rsi
lea rax, [rsi+18h]
mov [rsp+98h+var_40], rax
add r12, 20h ; ' '
shl [rsp+98h+var_88], 3
xor ebx, ebx
lea rbp, [rsp+98h+var_80]
lea r15, [rsp+98h+var_60]
loc_10330:
mov rax, [rsp+98h+var_38]
mov rsi, [rax+rbx]
mov rdi, rbp
lea rdx, [rsp+98h+var_91]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, rbp
mov esi, 2Dh ; '-'
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE17find_first_not_ofEcm; std::string::find_first_not_of(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_10372
mov rdi, r15
mov rsi, rbp
mov rdx, rax
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short loc_10391
loc_10372:
lea rax, [rsp+98h+var_50]
mov [rsp+98h+var_60], rax
mov rsi, [rsp+98h+var_80]
mov rdx, [rsp+98h+var_78]
add rdx, rsi
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
loc_10391:
mov rdi, [rsp+98h+var_40]
mov r14, r15
mov rsi, r15
call _ZNKSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EE4findERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(std::string const&)
mov r15, rax
mov rdi, [rsp+98h+var_60]; void *
lea rax, [rsp+98h+var_50]
cmp rdi, rax
jz short loc_103C0
mov rsi, [rsp+98h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_103C0:
mov rdi, [rsp+98h+var_80]; void *
lea rax, [rsp+98h+var_70]
cmp rdi, rax
jz short loc_103DC
mov rsi, [rsp+98h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_103DC:
cmp r12, r15
jnz short loc_103F9
add rbx, 8
cmp [rsp+98h+var_88], rbx
setz r13b
mov r15, r14
jnz loc_10330
jmp short loc_10415
loc_103F9:
add r15, 40h ; '@'
mov rdi, [rsp+98h+var_90]
mov rsi, r15
mov edx, 8
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::istringstream::basic_istringstream(std::string const&,std::_Ios_Openmode)
test r13b, 1
jz short loc_10439
loc_10415:
mov rbx, [rsp+98h+var_90]
mov rdi, rbx
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::istringstream::basic_istringstream(void)
mov rax, [rbx]
mov rax, [rax-18h]
lea rdi, [rbx+rax]
mov esi, [rbx+rax+20h]
or esi, 4
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_10439:
mov rax, [rsp+98h+var_90]
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEE_ptr
mov r14, [rsp+arg_0]
mov rdi, r14
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED2Ev; std::istringstream::~istringstream()
add r14, 78h ; 'x'
mov rdi, r14; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
jmp short loc_104B7
mov rbx, rax
jmp short loc_10496
mov rbx, rax
mov rdi, [rsp+arg_30]; void *
lea rax, [rsp+arg_40]
cmp rdi, rax
jz short loc_10496
mov rsi, [rsp+arg_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_10496:
mov rdi, [rsp+arg_10]; void *
lea rax, [rsp+arg_20]
cmp rdi, rax
jz short loc_104B7
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_104B7
mov rbx, rax
loc_104B7:
mov rdi, rbx
call __Unwind_Resume
|
_QWORD * argh::parser::operator()(_QWORD *a1, long long a2, long long a3, long long a4)
{
bool v4; // r13
long long v5; // rbx
void **v6; // r15
long long first_not_of; // rax
void **v8; // r14
long long v9; // r15
_QWORD *v10; // rbx
char v12; // [rsp+7h] [rbp-91h] BYREF
_QWORD *v13; // [rsp+8h] [rbp-90h]
long long v14; // [rsp+10h] [rbp-88h]
void *v15[2]; // [rsp+18h] [rbp-80h] BYREF
long long v16; // [rsp+28h] [rbp-70h] BYREF
void *v17; // [rsp+38h] [rbp-60h] BYREF
_QWORD v18[2]; // [rsp+48h] [rbp-50h] BYREF
long long v19; // [rsp+58h] [rbp-40h]
long long v20; // [rsp+60h] [rbp-38h]
v20 = a3;
v13 = a1;
v14 = a4;
v4 = a4 == 0;
if ( !a4 )
goto LABEL_14;
v19 = a2 + 24;
v14 *= 8LL;
v5 = 0LL;
v6 = &v17;
while ( 1 )
{
std::string::basic_string<std::allocator<char>>(v15, *(_QWORD *)(v20 + v5), &v12);
first_not_of = std::string::find_first_not_of(v15, 45LL, 0LL);
if ( first_not_of == -1 )
{
v17 = v18;
std::string::_M_construct<char *>(v6, v15[0], (char *)v15[0] + (unsigned long long)v15[1]);
}
else
{
std::string::substr(v6, v15, first_not_of, -1LL);
}
v8 = v6;
v9 = std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(
v19,
v6);
if ( v17 != v18 )
operator delete(v17, v18[0] + 1LL);
if ( v15[0] != &v16 )
operator delete(v15[0], v16 + 1);
if ( a2 + 32 != v9 )
break;
v5 += 8LL;
v4 = v14 == v5;
v6 = v8;
if ( v14 == v5 )
goto LABEL_14;
}
std::istringstream::basic_istringstream(v13, v9 + 64, 8LL);
if ( v4 )
{
LABEL_14:
v10 = v13;
std::istringstream::basic_istringstream(v13);
std::ios::clear(
(char *)v10 + *(_QWORD *)(*v10 - 24LL),
*(_DWORD *)((char *)v10 + *(_QWORD *)(*v10 - 24LL) + 32) | 4u);
}
return v13;
}
|
operator():
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDX
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x10],RCX
TEST RCX,RCX
SETZ R13B
JZ 0x00110415
MOV R12,RSI
LEA RAX,[RSI + 0x18]
MOV qword ptr [RSP + 0x58],RAX
ADD R12,0x20
SHL qword ptr [RSP + 0x10],0x3
XOR EBX,EBX
LEA RBP,[RSP + 0x18]
LEA R15,[RSP + 0x38]
LAB_00110330:
MOV RAX,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RAX + RBX*0x1]
LAB_00110339:
MOV RDI,RBP
LEA RDX,[RSP + 0x7]
CALL 0x001106b4
MOV RDI,RBP
MOV ESI,0x2d
XOR EDX,EDX
CALL 0x0010b380
CMP RAX,-0x1
JZ 0x00110372
LAB_0011035b:
MOV RDI,R15
MOV RSI,RBP
MOV RDX,RAX
MOV RCX,-0x1
CALL 0x0010b420
JMP 0x00110391
LAB_00110372:
LEA RAX,[RSP + 0x48]
MOV qword ptr [RSP + 0x38],RAX
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,RSI
MOV RDI,R15
CALL 0x00111e4e
LAB_00110391:
MOV RDI,qword ptr [RSP + 0x58]
MOV R14,R15
MOV RSI,R15
CALL 0x00111bbc
LAB_001103a1:
MOV R15,RAX
MOV RDI,qword ptr [RSP + 0x38]
LEA RAX,[RSP + 0x48]
CMP RDI,RAX
JZ 0x001103c0
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x0010b400
LAB_001103c0:
MOV RDI,qword ptr [RSP + 0x18]
LEA RAX,[RSP + 0x28]
CMP RDI,RAX
JZ 0x001103dc
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x0010b400
LAB_001103dc:
CMP R12,R15
JNZ 0x001103f9
ADD RBX,0x8
CMP qword ptr [RSP + 0x10],RBX
SETZ R13B
MOV R15,R14
JNZ 0x00110330
JMP 0x00110415
LAB_001103f9:
ADD R15,0x40
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R15
MOV EDX,0x8
CALL 0x0010b6f0
TEST R13B,0x1
JZ 0x00110439
LAB_00110415:
MOV RBX,qword ptr [RSP + 0x8]
MOV RDI,RBX
CALL 0x0010b2c0
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[RBX + RAX*0x1]
MOV ESI,dword ptr [RBX + RAX*0x1 + 0x20]
OR ESI,0x4
LAB_00110434:
CALL 0x0010b710
LAB_00110439:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* argh::parser::TEMPNAMEPLACEHOLDERVALUE(std::initializer_list<char const* const>) const */
istringstream * __thiscall
argh::parser::operator()(parser *this,long param_2,long param_3,long param_4)
{
parser *ppVar1;
long lVar2;
long lVar3;
bool bVar4;
allocator local_91;
parser *local_90;
long local_88;
long *local_80;
long local_78;
long local_70 [2];
long *local_60 [2];
long local_50 [2];
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*local_40;
long local_38;
bVar4 = param_4 == 0;
local_90 = this;
local_88 = param_4;
local_38 = param_3;
if (!bVar4) {
local_40 = (_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(param_2 + 0x18);
local_88 = param_4 << 3;
lVar3 = 0;
do {
/* try { // try from 00110339 to 00110345 has its CatchHandler @ 001104b4 */
std::__cxx11::string::string<std::allocator<char>>
((string *)&local_80,*(char **)(local_38 + lVar3),&local_91);
lVar2 = std::__cxx11::string::find_first_not_of((char)(string *)&local_80,0x2d);
if (lVar2 == -1) {
local_60[0] = local_50;
std::__cxx11::string::_M_construct<char*>
((string *)local_60,local_80,local_78 + (long)local_80);
}
else {
/* try { // try from 0011035b to 00110390 has its CatchHandler @ 00110472 */
std::__cxx11::string::substr((ulong)local_60,(ulong)&local_80);
}
/* try { // try from 00110391 to 001103a0 has its CatchHandler @ 00110477 */
lVar2 = std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find(local_40,(string *)local_60);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
if (local_80 != local_70) {
operator_delete(local_80,local_70[0] + 1);
}
if (param_2 + 0x20 != lVar2) {
std::__cxx11::istringstream::istringstream((istringstream *)local_90,lVar2 + 0x40,8);
if (!bVar4) {
return (istringstream *)local_90;
}
break;
}
lVar3 = lVar3 + 8;
bVar4 = local_88 == lVar3;
} while (!bVar4);
}
ppVar1 = local_90;
std::__cxx11::istringstream::istringstream((istringstream *)local_90);
/* try { // try from 00110434 to 00110438 has its CatchHandler @ 0011044d */
std::ios::clear((istringstream *)(ppVar1 + *(long *)(*(long *)ppVar1 + -0x18)),
*(uint *)(ppVar1 + *(long *)(*(long *)ppVar1 + -0x18) + 0x20) | 4);
return (istringstream *)local_90;
}
|
|
64,797 |
evmone::advanced::Instruction const* evmone::advanced::(anonymous namespace)::op<&void evmone::advanced::instr::impl<(evmone::Opcode)27, &evmone::instr::core::shl(evmone::StackTop)>(evmone::advanced::AdvancedExecutionState&)>(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&)
|
corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/advanced_instructions.cpp
|
const Instruction* op(const Instruction* instr, AdvancedExecutionState& state) noexcept
{
InstrFn(state);
return ++instr;
}
|
O3
|
cpp
|
evmone::advanced::Instruction const* evmone::advanced::(anonymous namespace)::op<&void evmone::advanced::instr::impl<(evmone::Opcode)27, &evmone::instr::core::shl(evmone::StackTop)>(evmone::advanced::AdvancedExecutionState&)>(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x228(%rsi), %r15
movq %rsi, %rdi
callq 0x41d26
movdqu 0xc0(%rax), %xmm0
movdqu 0xd0(%rax), %xmm1
movdqa 0x32e77(%rip), %xmm2 # 0x833b0
pshufb %xmm2, %xmm1
movdqu %xmm1, 0x20(%r15)
pshufb %xmm2, %xmm0
movdqu %xmm0, 0x30(%r15)
addq $0x20, 0x228(%rbx)
addq $0x10, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
|
_ZN6evmone8advanced12_GLOBAL__N_12opIXadL_ZNS0_5instr4implILNS_6OpcodeE74EXadL_ZNS_5instr4core11blobbasefeeENS_8StackTopERNS_14ExecutionStateEEEEEvRNS0_22AdvancedExecutionStateEEEEEPKNS0_11InstructionESF_SC_:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov r15, [rsi+228h]
mov rdi, rsi; this
call _ZN6evmone14ExecutionState14get_tx_contextEv; evmone::ExecutionState::get_tx_context(void)
movdqu xmm0, xmmword ptr [rax+0C0h]
movdqu xmm1, xmmword ptr [rax+0D0h]
movdqa xmm2, cs:xmmword_833B0
pshufb xmm1, xmm2
movdqu xmmword ptr [r15+20h], xmm1
pshufb xmm0, xmm2
movdqu xmmword ptr [r15+30h], xmm0
add qword ptr [rbx+228h], 20h ; ' '
add r14, 10h
mov rax, r14
pop rbx
pop r14
pop r15
retn
|
long long evmone::advanced::`anonymous namespace'::op<&void evmone::advanced::instr::impl<(evmone::Opcode)74,&evmone::instr::core::blobbasefee>>(
long long a1,
evmone::ExecutionState *a2)
{
__m128i *v2; // r15
const __m128i *tx_context; // rax
__m128i v4; // xmm0
__m128i si128; // xmm2
v2 = (__m128i *)*((_QWORD *)a2 + 69);
tx_context = (const __m128i *)evmone::ExecutionState::get_tx_context(a2);
v4 = _mm_loadu_si128(tx_context + 12);
si128 = _mm_load_si128((const __m128i *)&xmmword_833B0);
v2[2] = _mm_shuffle_epi8(_mm_loadu_si128(tx_context + 13), si128);
v2[3] = _mm_shuffle_epi8(v4, si128);
*((_QWORD *)a2 + 69) += 32LL;
return a1 + 16;
}
|
op<&(void_evmone::advanced::instr::impl<(evmone::Opcode)74,&evmone::instr::core::blobbasefee>(evmone::advanced::AdvancedExecutionState&))>:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV R15,qword ptr [RSI + 0x228]
MOV RDI,RSI
CALL 0x00141d26
MOVDQU XMM0,xmmword ptr [RAX + 0xc0]
MOVDQU XMM1,xmmword ptr [RAX + 0xd0]
MOVDQA XMM2,xmmword ptr [0x001833b0]
PSHUFB XMM1,XMM2
MOVDQU xmmword ptr [R15 + 0x20],XMM1
PSHUFB XMM0,XMM2
MOVDQU xmmword ptr [R15 + 0x30],XMM0
ADD qword ptr [RBX + 0x228],0x20
ADD R14,0x10
MOV RAX,R14
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* evmone::advanced::Instruction const* evmone::advanced::(anonymous namespace)::op<&(void
evmone::advanced::instr::impl<(evmone::Opcode)74,
&evmone::instr::core::blobbasefee>(evmone::advanced::AdvancedExecutionState&))>(evmone::advanced::Instruction
const*, evmone::advanced::AdvancedExecutionState&) */
Instruction *
evmone::advanced::(anonymous_namespace)::
op<&(void_evmone::advanced::instr::impl<(evmone::Opcode)74,&evmone::instr::core::blobbasefee>(evmone::advanced::AdvancedExecutionState&))>
(Instruction *param_1,AdvancedExecutionState *param_2)
{
long lVar1;
int1 auVar2 [16];
long lVar3;
int1 auVar4 [16];
int1 auVar5 [16];
lVar1 = *(long *)(param_2 + 0x228);
lVar3 = ExecutionState::get_tx_context((ExecutionState *)param_2);
auVar2 = _DAT_001833b0;
auVar4 = *(int1 (*) [16])(lVar3 + 0xc0);
auVar5 = pshufb(*(int1 (*) [16])(lVar3 + 0xd0),_DAT_001833b0);
*(int1 (*) [16])(lVar1 + 0x20) = auVar5;
auVar4 = pshufb(auVar4,auVar2);
*(int1 (*) [16])(lVar1 + 0x30) = auVar4;
*(long *)(param_2 + 0x228) = *(long *)(param_2 + 0x228) + 0x20;
return param_1 + 0x10;
}
|
|
64,798 |
link_to_file_list
|
eloqsql/mysys/mf_keycache.c
|
static void link_to_file_list(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, int file,
my_bool unlink_block)
{
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT(block->hash_link && block->hash_link->block == block);
DBUG_ASSERT(block->hash_link->file == file);
if (unlink_block)
unlink_changed(block);
link_changed(block, &keycache->file_blocks[FILE_HASH(file, keycache)]);
if (block->status & BLOCK_CHANGED)
{
block->status&= ~BLOCK_CHANGED;
keycache->blocks_changed--;
keycache->global_blocks_changed--;
}
}
|
O0
|
c
|
link_to_file_list:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
jmp 0xe973a
jmp 0xe973c
jmp 0xe973e
jmp 0xe9740
jmp 0xe9742
cmpb $0x0, -0x15(%rbp)
je 0xe9751
movq -0x10(%rbp), %rdi
callq 0xe9900
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rsi
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x3c(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
callq 0xe9b60
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xe97bf
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
andl $-0x21, %ecx
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x138(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
link_to_file_list_0:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, cl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_15], al
jmp short $+2
loc_E973A:
jmp short $+2
loc_E973C:
jmp short $+2
loc_E973E:
jmp short $+2
loc_E9740:
jmp short $+2
loc_E9742:
cmp [rbp+var_15], 0
jz short loc_E9751
mov rdi, [rbp+var_10]
call unlink_changed_0
loc_E9751:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov rsi, [rax+130h]
mov eax, [rbp+var_14]
mov rcx, [rbp+var_8]
mov ecx, [rcx+3Ch]
sub ecx, 1
and eax, ecx
mov eax, eax
shl rax, 3
add rsi, rax
call link_changed_0
mov rax, [rbp+var_10]
mov eax, [rax+50h]
and eax, 20h
cmp eax, 0
jz short loc_E97BF
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
and ecx, 0FFFFFFDFh
mov [rax+50h], ecx
mov rax, [rbp+var_8]
mov rcx, [rax+60h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+60h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+138h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+138h], rcx
loc_E97BF:
add rsp, 20h
pop rbp
retn
|
long long link_to_file_list_0(long long a1, long long a2, unsigned int a3, char a4)
{
long long result; // rax
if ( a4 )
unlink_changed_0(a2);
link_changed_0(a2, 8LL * ((*(_DWORD *)(a1 + 60) - 1) & a3) + *(_QWORD *)(a1 + 304));
result = *(_DWORD *)(a2 + 80) & 0x20;
if ( (_DWORD)result )
{
*(_DWORD *)(a2 + 80) &= ~0x20u;
--*(_QWORD *)(a1 + 96);
result = a1;
--*(_QWORD *)(a1 + 312);
}
return result;
}
|
link_to_file_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,CL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV byte ptr [RBP + -0x15],AL
JMP 0x001e973a
LAB_001e973a:
JMP 0x001e973c
LAB_001e973c:
JMP 0x001e973e
LAB_001e973e:
JMP 0x001e9740
LAB_001e9740:
JMP 0x001e9742
LAB_001e9742:
CMP byte ptr [RBP + -0x15],0x0
JZ 0x001e9751
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e9900
LAB_001e9751:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x130]
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x3c]
SUB ECX,0x1
AND EAX,ECX
MOV EAX,EAX
SHL RAX,0x3
ADD RSI,RAX
CALL 0x001e9b60
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x50]
AND EAX,0x20
CMP EAX,0x0
JZ 0x001e97bf
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
AND ECX,0xffffffdf
MOV dword ptr [RAX + 0x50],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x60]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x60],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x138]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x138],RCX
LAB_001e97bf:
ADD RSP,0x20
POP RBP
RET
|
void link_to_file_list(long param_1,long param_2,uint param_3,char param_4)
{
if (param_4 != '\0') {
unlink_changed(param_2);
}
link_changed(param_2,*(long *)(param_1 + 0x130) +
(ulong)(param_3 & *(int *)(param_1 + 0x3c) - 1U) * 8);
if ((*(uint *)(param_2 + 0x50) & 0x20) != 0) {
*(uint *)(param_2 + 0x50) = *(uint *)(param_2 + 0x50) & 0xffffffdf;
*(long *)(param_1 + 0x60) = *(long *)(param_1 + 0x60) + -1;
*(long *)(param_1 + 0x138) = *(long *)(param_1 + 0x138) + -1;
}
return;
}
|
|
64,799 |
cs_enter
|
eloqsql/strings/ctype.c
|
static int cs_enter(MY_XML_PARSER *st,const char *attr, size_t len)
{
struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
const struct my_cs_file_section_st *s= cs_file_sec(attr,len);
int state= s ? s->state : 0;
switch (state) {
case 0:
i->loader->reporter(WARNING_LEVEL, "Unknown LDML tag: '%.*s'", len, attr);
break;
case _CS_CHARSET:
my_charset_file_reset_charset(i);
break;
case _CS_COLLATION:
my_charset_file_reset_collation(i);
break;
case _CS_RESET:
return tailoring_append(st, " &", 0, NULL);
default:
break;
}
return MY_XML_OK;
}
|
O0
|
c
|
cs_enter:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x65850
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x63de6
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0x63ded
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x63ded
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x63e1f
jmp 0x63dff
movl -0x3c(%rbp), %eax
subl $0x8, %eax
je 0x63e4c
jmp 0x63e09
movl -0x3c(%rbp), %eax
subl $0x9, %eax
je 0x63e57
jmp 0x63e13
movl -0x3c(%rbp), %eax
subl $0x12d, %eax # imm = 0x12D
je 0x63e62
jmp 0x63e7e
movq -0x28(%rbp), %rax
movq 0x7a8(%rax), %rax
movq 0xa0(%rax), %r8
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %edi
leaq 0x1da71(%rip), %rsi # 0x818b6
movb $0x0, %al
callq *%r8
jmp 0x63e80
movq -0x28(%rbp), %rdi
callq 0x657f0
jmp 0x63e80
movq -0x28(%rbp), %rdi
callq 0x65820
jmp 0x63e80
movq -0x10(%rbp), %rdi
leaq 0x1da62(%rip), %rsi # 0x818cf
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x658e0
movl %eax, -0x4(%rbp)
jmp 0x63e87
jmp 0x63e80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
|
cs_enter:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+140h]
mov [rbp+var_28], rax
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call cs_file_sec
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_63DE6
mov rax, [rbp+var_30]
mov eax, [rax]
mov [rbp+var_38], eax
jmp short loc_63DED
loc_63DE6:
xor eax, eax
mov [rbp+var_38], eax
jmp short $+2
loc_63DED:
mov eax, [rbp+var_38]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
mov [rbp+var_3C], eax
test eax, eax
jz short loc_63E1F
jmp short $+2
loc_63DFF:
mov eax, [rbp+var_3C]
sub eax, 8
jz short loc_63E4C
jmp short $+2
loc_63E09:
mov eax, [rbp+var_3C]
sub eax, 9
jz short loc_63E57
jmp short $+2
loc_63E13:
mov eax, [rbp+var_3C]
sub eax, 12Dh
jz short loc_63E62
jmp short loc_63E7E
loc_63E1F:
mov rax, [rbp+var_28]
mov rax, [rax+7A8h]
mov r8, [rax+0A0h]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_18]
mov edi, 1
lea rsi, aUnknownLdmlTag; "Unknown LDML tag: '%.*s'"
mov al, 0
call r8
jmp short loc_63E80
loc_63E4C:
mov rdi, [rbp+var_28]
call my_charset_file_reset_charset
jmp short loc_63E80
loc_63E57:
mov rdi, [rbp+var_28]
call my_charset_file_reset_collation
jmp short loc_63E80
loc_63E62:
mov rdi, [rbp+var_10]
lea rsi, asc_818CF; " &"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_4], eax
jmp short loc_63E87
loc_63E7E:
jmp short $+2
loc_63E80:
mov [rbp+var_4], 0
loc_63E87:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long cs_enter(long long a1, const char *a2, long long a3)
{
int v4; // [rsp+8h] [rbp-38h]
int *v5; // [rsp+10h] [rbp-30h]
long long v6; // [rsp+18h] [rbp-28h]
int v7; // [rsp+20h] [rbp-20h]
v7 = a3;
v6 = *(_QWORD *)(a1 + 320);
v5 = (int *)cs_file_sec(a2, a3);
if ( v5 )
v4 = *v5;
else
v4 = 0;
switch ( v4 )
{
case 0:
(*(void (**)(long long, const char *, ...))(*(_QWORD *)(v6 + 1960) + 160LL))(
1LL,
"Unknown LDML tag: '%.*s'",
v7,
a2);
return 0;
case 8:
my_charset_file_reset_charset(v6);
return 0;
case 9:
my_charset_file_reset_collation(v6);
return 0;
}
if ( v4 != 301 )
return 0;
return (unsigned int)tailoring_append(a1, " &", 0LL);
}
|
cs_enter:
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 RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x140]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00165850
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00163de6
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
JMP 0x00163ded
LAB_00163de6:
XOR EAX,EAX
MOV dword ptr [RBP + -0x38],EAX
JMP 0x00163ded
LAB_00163ded:
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x3c],EAX
TEST EAX,EAX
JZ 0x00163e1f
JMP 0x00163dff
LAB_00163dff:
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x8
JZ 0x00163e4c
JMP 0x00163e09
LAB_00163e09:
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x9
JZ 0x00163e57
JMP 0x00163e13
LAB_00163e13:
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x12d
JZ 0x00163e62
JMP 0x00163e7e
LAB_00163e1f:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x7a8]
MOV R8,qword ptr [RAX + 0xa0]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV EDI,0x1
LEA RSI,[0x1818b6]
MOV AL,0x0
CALL R8
JMP 0x00163e80
LAB_00163e4c:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001657f0
JMP 0x00163e80
LAB_00163e57:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00165820
JMP 0x00163e80
LAB_00163e62:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1818cf]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001658e0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00163e87
LAB_00163e7e:
JMP 0x00163e80
LAB_00163e80:
MOV dword ptr [RBP + -0x4],0x0
LAB_00163e87:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 cs_enter(long param_1,int8 param_2,int8 param_3)
{
long lVar1;
int4 uVar2;
int *piVar3;
int local_40;
lVar1 = *(long *)(param_1 + 0x140);
piVar3 = (int *)cs_file_sec(param_2,param_3);
if (piVar3 == (int *)0x0) {
local_40 = 0;
}
else {
local_40 = *piVar3;
}
if (local_40 == 0) {
(**(code **)(*(long *)(lVar1 + 0x7a8) + 0xa0))(1,"Unknown LDML tag: \'%.*s\'",param_3,param_2);
}
else if (local_40 == 8) {
my_charset_file_reset_charset(lVar1);
}
else if (local_40 == 9) {
my_charset_file_reset_collation(lVar1);
}
else if (local_40 == 0x12d) {
uVar2 = tailoring_append(param_1,&DAT_001818cf,0);
return uVar2;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.