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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
6,400 | my_strdup | eloqsql/mysys/my_malloc.c | char *my_strdup(PSI_memory_key key, const char *from, myf my_flags)
{
char *ptr;
size_t length= strlen(from)+1;
DBUG_ENTER("my_strdup");
if ((ptr= (char*) my_malloc(key, length, my_flags)))
memcpy(ptr, from, length);
DBUG_RETURN(ptr);
} | O3 | c | my_strdup:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %r12d
movq %rsi, %rdi
callq 0x2a350
movq %rax, %r14
incq %r14
movl %r12d, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0xa4969
testq %rax, %rax
je 0xa4c77
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a0a0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_strdup:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r15, rdx
mov rbx, rsi
mov r12d, edi
mov rdi, rsi
call _strlen
mov r14, rax
inc r14
mov edi, r12d
mov rsi, r14
mov rdx, r15
call my_malloc
test rax, rax
jz short loc_A4C77
mov rdi, rax
mov rsi, rbx
mov rdx, r14
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _memcpy
loc_A4C77:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_strdup(unsigned int a1, long long a2, int a3)
{
unsigned long long v4; // r14
long long result; // rax
v4 = strlen(a2) + 1;
result = my_malloc(a1, v4, a3);
if ( result )
return memcpy(result, a2, v4);
return result;
}
| my_strdup:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15,RDX
MOV RBX,RSI
MOV R12D,EDI
MOV RDI,RSI
CALL 0x0012a350
MOV R14,RAX
INC R14
MOV EDI,R12D
MOV RSI,R14
MOV RDX,R15
CALL 0x001a4969
TEST RAX,RAX
JZ 0x001a4c77
MOV RDI,RAX
MOV RSI,RBX
MOV RDX,R14
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0012a0a0
LAB_001a4c77:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void my_strdup(int4 param_1,char *param_2,int8 param_3)
{
size_t sVar1;
void *__dest;
sVar1 = strlen(param_2);
__dest = (void *)my_malloc(param_1,sVar1 + 1,param_3);
if (__dest != (void *)0x0) {
memcpy(__dest,param_2,sVar1 + 1);
return;
}
return;
}
|
|
6,401 | is_not_initialized | eloqsql/build_O0/libmariadb/libmariadb/ma_client_plugin.c | static int is_not_initialized(MYSQL *mysql, const char *name)
{
if (initialized)
return 0;
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD,
SQLSTATE_UNKNOWN, ER(CR_AUTH_PLUGIN_CANNOT_LOAD),
name, "not initialized");
return 1;
} | O0 | c | is_not_initialized:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpb $0x0, 0x2c179(%rip) # 0x61c60
je 0x35af2
movl $0x0, -0x4(%rbp)
jmp 0x35b2c
movq -0x10(%rbp), %rdi
leaq 0x2a3e3(%rip), %rax # 0x5fee0
movq (%rax), %rdx
leaq 0x2a3e9(%rip), %rax # 0x5fef0
movq 0x1d8(%rax), %rcx
movq -0x18(%rbp), %r8
movl $0x80b, %esi # imm = 0x80B
leaq 0x16552(%rip), %r9 # 0x4c070
movb $0x0, %al
callq 0x15e40
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| is_not_initialized:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp cs:initialized, 0
jz short loc_35AF2
mov [rbp+var_4], 0
jmp short loc_35B2C
loc_35AF2:
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
mov r8, [rbp+var_18]
mov esi, 80Bh
lea r9, aNotInitialized; "not initialized"
mov al, 0
call my_set_error
mov [rbp+var_4], 1
loc_35B2C:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long is_not_initialized(long long a1, long long a2)
{
if ( initialized )
{
return 0;
}
else
{
my_set_error(a1, 0x80Bu, (long long)SQLSTATE_UNKNOWN, (long long)client_errors[59], a2, "not initialized");
return 1;
}
}
| is_not_initialized:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP byte ptr [0x00161c60],0x0
JZ 0x00135af2
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00135b2c
LAB_00135af2:
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x15fee0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x15fef0]
MOV RCX,qword ptr [RAX + 0x1d8]
MOV R8,qword ptr [RBP + -0x18]
MOV ESI,0x80b
LEA R9,[0x14c070]
MOV AL,0x0
CALL 0x00115e40
MOV dword ptr [RBP + -0x4],0x1
LAB_00135b2c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
bool is_not_initialized(int8 param_1,int8 param_2)
{
bool bVar1;
bVar1 = initialized == '\0';
if (bVar1) {
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____001600c8,
param_2,"not initialized");
}
return bVar1;
}
|
|
6,402 | my_wc_mb_cp932 | eloqsql/strings/ctype-cp932.c | static int
my_wc_mb_cp932(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if ((int) wc < 0x80) /* ASCII: [U+0000..U+007F] -> [00-7F] */
{
/*
This branch is for performance purposes on ASCII range,
to avoid using unicode_to_cp932[]: about 10% improvement.
*/
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= (uchar) wc;
return 1;
}
if (wc > 0xFFFF ||
!(code= unicode_to_cp932[wc])) /* Bad Unicode code point */
return MY_CS_ILUNI;
if (code <= 0xFF)
{
/* JIS-X-0201 HALF WIDTH KATAKANA [U+FF61..U+FF9F] -> [A1..DF] */
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= code;
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, code); /* JIS-X-0208(MS) */
return 2;
} | O0 | c | my_wc_mb_cp932:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jge 0x39ffd
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x39fe5
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x3a094
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3a094
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
ja 0x3a01e
movq -0x18(%rbp), %rcx
leaq 0x7dcae(%rip), %rax # 0xb7cc0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x3a027
movl $0x0, -0x4(%rbp)
jmp 0x3a094
cmpl $0xff, -0x2c(%rbp)
jg 0x3a057
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x3a043
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x3a094
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3a094
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x3a06e
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x3a094
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| my_wc_mb_cp932:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
cmp eax, 80h
jge short loc_39FFD
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_39FE5
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_3A094
loc_39FE5:
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_3A094
loc_39FFD:
cmp [rbp+var_18], 0FFFFh
ja short loc_3A01E
mov rcx, [rbp+var_18]
lea rax, unicode_to_cp932
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_3A027
loc_3A01E:
mov [rbp+var_4], 0
jmp short loc_3A094
loc_3A027:
cmp [rbp+var_2C], 0FFh
jg short loc_3A057
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_3A043
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_3A094
loc_3A043:
mov eax, [rbp+var_2C]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_3A094
loc_3A057:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_3A06E
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_3A094
loc_3A06E:
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
loc_3A094:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_wc_mb_cp932(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
unsigned __int16 v5; // [rsp+0h] [rbp-2Ch]
if ( (int)a2 >= 128 )
{
if ( a2 <= 0xFFFF && (v5 = unicode_to_cp932[a2]) != 0 )
{
if ( unicode_to_cp932[a2] > 0xFFu )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = HIBYTE(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else if ( (unsigned long long)a3 < a4 )
{
*a3 = v5;
return 1;
}
else
{
return (unsigned int)-101;
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)a3 < a4 )
{
*a3 = a2;
return 1;
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_cp932:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JGE 0x00139ffd
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00139fe5
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0013a094
LAB_00139fe5:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013a094
LAB_00139ffd:
CMP qword ptr [RBP + -0x18],0xffff
JA 0x0013a01e
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x1b7cc0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x0013a027
LAB_0013a01e:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013a094
LAB_0013a027:
CMP dword ptr [RBP + -0x2c],0xff
JG 0x0013a057
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0013a043
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0013a094
LAB_0013a043:
MOV EAX,dword ptr [RBP + -0x2c]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013a094
LAB_0013a057:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0013a06e
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0013a094
LAB_0013a06e:
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
LAB_0013a094:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_cp932(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
ushort uVar1;
int4 local_c;
if ((int)param_2 < 0x80) {
if (param_3 < param_4) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
}
else if ((param_2 < 0x10000) && (uVar1 = *(ushort *)(unicode_to_cp932 + param_2 * 2), uVar1 != 0))
{
if (uVar1 < 0x100) {
if (param_3 < param_4) {
*param_3 = (char)uVar1;
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)(uVar1 >> 8);
param_3[1] = (char)uVar1;
local_c = 2;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
6,403 | 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>>>>>::lexer(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>>>>&&, bool) | monkey531[P]llama/common/./json.hpp | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | O1 | 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>>>>>::lexer(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>>>>&&, bool):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
movl $0xffffffff, 0x14(%rdi) # imm = 0xFFFFFFFF
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x13415(%rip), %rcx # 0xa9d45
movq %rcx, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
movq %rax, 0x88(%rdi)
callq 0x18cd0
movq (%rax), %rax
testq %rax, %rax
je 0x96951
movsbl (%rax), %eax
jmp 0x96956
movl $0x2e, %eax
movl %eax, 0x90(%rbx)
popq %rbx
retq
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEEC2EOSM_b:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [rdi], xmm0
mov [rdi+10h], dl
mov dword ptr [rdi+14h], 0FFFFFFFFh
xor eax, eax
mov [rdi+18h], al
lea rcx, [rdi+60h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+40h], xmm0
mov [rdi+50h], rcx
mov [rdi+58h], rax
mov [rdi+60h], al
lea rcx, aEndIndexOutOfB+19h; ""
mov [rdi+70h], rcx
movups xmmword ptr [rdi+78h], xmm0
mov [rdi+88h], rax
call _localeconv
mov rax, [rax]
test rax, rax
jz short loc_96951
movsx eax, byte ptr [rax]
jmp short loc_96956
loc_96951:
mov eax, 2Eh ; '.'
loc_96956:
mov [rbx+90h], eax
pop rbx
retn
| 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>>>::lexer(
long long a1,
_OWORD *a2,
char a3)
{
char *v3; // rax
long long result; // rax
*(_OWORD *)a1 = *a2;
*(_BYTE *)(a1 + 16) = a3;
*(_DWORD *)(a1 + 20) = -1;
*(_BYTE *)(a1 + 24) = 0;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
*(_QWORD *)(a1 + 112) = "";
*(_OWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
v3 = *(char **)localeconv(a1);
if ( v3 )
result = (unsigned int)*v3;
else
result = 46LL;
*(_DWORD *)(a1 + 144) = result;
return result;
}
| lexer:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS xmmword ptr [RDI],XMM0
MOV byte ptr [RDI + 0x10],DL
MOV dword ptr [RDI + 0x14],0xffffffff
XOR EAX,EAX
MOV byte ptr [RDI + 0x18],AL
LEA RCX,[RDI + 0x60]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOV qword ptr [RDI + 0x50],RCX
MOV qword ptr [RDI + 0x58],RAX
MOV byte ptr [RDI + 0x60],AL
LEA RCX,[0x1a9d45]
MOV qword ptr [RDI + 0x70],RCX
MOVUPS xmmword ptr [RDI + 0x78],XMM0
MOV qword ptr [RDI + 0x88],RAX
CALL 0x00118cd0
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00196951
MOVSX EAX,byte ptr [RAX]
JMP 0x00196956
LAB_00196951:
MOV EAX,0x2e
LAB_00196956:
MOV dword ptr [RBX + 0x90],EAX
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >
>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >&&, bool) */
void __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>>>
::lexer(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,iterator_input_adapter *param_1,bool param_2)
{
int8 uVar1;
int iVar2;
lconv *plVar3;
uVar1 = *(int8 *)(param_1 + 8);
*(int8 *)this = *(int8 *)param_1;
*(int8 *)(this + 8) = uVar1;
this[0x10] = (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>>>
)param_2;
*(int4 *)(this + 0x14) = 0xffffffff;
this[0x18] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(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 + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x0;
*(char **)(this + 0x70) = "";
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
plVar3 = localeconv();
if (plVar3->decimal_point == (char *)0x0) {
iVar2 = 0x2e;
}
else {
iVar2 = (int)*plVar3->decimal_point;
}
*(int *)(this + 0x90) = iVar2;
return;
}
|
|
6,404 | LoadRandomSequence | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | int *LoadRandomSequence(unsigned int count, int min, int max)
{
int *values = NULL;
#if defined(SUPPORT_RPRAND_GENERATOR)
values = rprand_load_sequence(count, min, max);
#else
if (count > ((unsigned int)abs(max - min) + 1)) return values; // Security check
values = (int *)RL_CALLOC(count, sizeof(int));
int value = 0;
bool dupValue = false;
for (int i = 0; i < (int)count;)
{
value = (rand()%(abs(max - min) + 1) + min);
dupValue = false;
for (int j = 0; j < i; j++)
{
if (values[j] == value)
{
dupValue = true;
break;
}
}
if (!dupValue)
{
values[i] = value;
i++;
}
}
#endif
return values;
} | O0 | c | LoadRandomSequence:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0xc8b30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| LoadRandomSequence:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov [rbp+var_18], 0
mov edi, [rbp+var_4]
mov esi, [rbp+var_8]
mov edx, [rbp+var_C]
call rprand_load_sequence
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| long long LoadRandomSequence(unsigned int a1, int a2, int a3)
{
return rprand_load_sequence(a1, a2, a3);
}
| LoadRandomSequence:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV qword ptr [RBP + -0x18],0x0
MOV EDI,dword ptr [RBP + -0x4]
MOV ESI,dword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0xc]
CALL 0x001c8b30
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
int8 LoadRandomSequence(int4 param_1,int4 param_2,int4 param_3)
{
int8 uVar1;
uVar1 = rprand_load_sequence(param_1,param_2,param_3);
return uVar1;
}
|
|
6,405 | LoadRandomSequence | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | int *LoadRandomSequence(unsigned int count, int min, int max)
{
int *values = NULL;
#if defined(SUPPORT_RPRAND_GENERATOR)
values = rprand_load_sequence(count, min, max);
#else
if (count > ((unsigned int)abs(max - min) + 1)) return values; // Security check
values = (int *)RL_CALLOC(count, sizeof(int));
int value = 0;
bool dupValue = false;
for (int i = 0; i < (int)count;)
{
value = (rand()%(abs(max - min) + 1) + min);
dupValue = false;
for (int j = 0; j < i; j++)
{
if (values[j] == value)
{
dupValue = true;
break;
}
}
if (!dupValue)
{
values[i] = value;
i++;
}
}
#endif
return values;
} | O2 | c | LoadRandomSequence:
jmp 0x5dee6
| LoadRandomSequence:
jmp rprand_load_sequence
| // attributes: thunk
long long LoadRandomSequence(unsigned int a1, int a2, int a3)
{
return rprand_load_sequence(a1, a2, a3);
}
| LoadRandomSequence:
JMP 0x0015dee6
|
void * LoadRandomSequence(uint param_1,int param_2,int param_3)
{
long lVar1;
void *pvVar2;
ulong uVar3;
int iVar4;
uint uVar5;
int iVar6;
param_3 = param_3 - param_2;
iVar6 = -param_3;
if (0 < param_3) {
iVar6 = param_3;
}
uVar5 = 0;
if (iVar6 + 1U < param_1) {
pvVar2 = (void *)0x0;
}
else {
pvVar2 = calloc((ulong)param_1,4);
LAB_0015df25:
if (uVar5 < param_1) {
uVar3 = rprand_xoshiro();
iVar4 = (int)((uVar3 & 0xffffffff) % (ulong)(iVar6 + 1U)) + param_2;
uVar3 = 0;
do {
if (uVar5 == uVar3) {
*(int *)((long)pvVar2 + (ulong)uVar5 * 4) = iVar4;
uVar5 = uVar5 + 1;
break;
}
lVar1 = uVar3 * 4;
uVar3 = uVar3 + 1;
} while (*(int *)((long)pvVar2 + lVar1) != iVar4);
goto LAB_0015df25;
}
}
return pvVar2;
}
|
|
6,406 | LoadRandomSequence | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | int *LoadRandomSequence(unsigned int count, int min, int max)
{
int *values = NULL;
#if defined(SUPPORT_RPRAND_GENERATOR)
values = rprand_load_sequence(count, min, max);
#else
if (count > ((unsigned int)abs(max - min) + 1)) return values; // Security check
values = (int *)RL_CALLOC(count, sizeof(int));
int value = 0;
bool dupValue = false;
for (int i = 0; i < (int)count;)
{
value = (rand()%(abs(max - min) + 1) + min);
dupValue = false;
for (int j = 0; j < i; j++)
{
if (values[j] == value)
{
dupValue = true;
break;
}
}
if (!dupValue)
{
values[i] = value;
i++;
}
}
#endif
return values;
} | O3 | c | LoadRandomSequence:
jmp 0x6f3f0
| LoadRandomSequence:
jmp rprand_load_sequence
| // attributes: thunk
long long LoadRandomSequence(unsigned int a1, int a2, int a3)
{
return rprand_load_sequence(a1, a2, a3);
}
| LoadRandomSequence:
JMP 0x0016f3f0
|
void * LoadRandomSequence(uint param_1,int param_2,int param_3)
{
uint uVar1;
void *pvVar2;
ulong uVar3;
int iVar4;
uint uVar5;
uint uVar6;
uint uVar7;
ulong uVar8;
int iVar9;
param_3 = param_3 - param_2;
iVar9 = -param_3;
if (0 < param_3) {
iVar9 = param_3;
}
if (iVar9 + 1U < param_1) {
pvVar2 = (void *)0x0;
}
else {
pvVar2 = calloc((ulong)param_1,4);
if (param_1 != 0) {
uVar7 = 0;
do {
iVar4 = ((rprand_state_1 * 0x280 | rprand_state_1 * 5 >> 0x19) * 9) % (iVar9 + 1U) + param_2
;
if (uVar7 == 0) {
uVar3 = 0;
}
else {
uVar3 = (ulong)uVar7;
uVar8 = 0;
do {
if (*(int *)((long)pvVar2 + uVar8 * 4) == iVar4) goto LAB_0016f47b;
uVar8 = uVar8 + 1;
} while (uVar3 != uVar8);
}
*(int *)((long)pvVar2 + uVar3 * 4) = iVar4;
uVar7 = uVar7 + 1;
LAB_0016f47b:
uVar1 = rprand_state_1 << 9;
uVar6 = rprand_state_2 ^ rprand_state_0;
uVar5 = rprand_state_3 ^ rprand_state_1;
rprand_state_1 = rprand_state_1 ^ uVar6;
rprand_state_0 = rprand_state_0 ^ uVar5;
rprand_state_2 = uVar6 ^ uVar1;
rprand_state_3 = uVar5 << 0xb | uVar5 >> 0x15;
} while (uVar7 < param_1);
}
}
return pvVar2;
}
|
|
6,407 | lo0bits | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static int lo0bits(ULong *y)
{
register int k;
register ULong x= *y;
if (x & 7)
{
if (x & 1)
return 0;
if (x & 2)
{
*y= x >> 1;
return 1;
}
*y= x >> 2;
return 2;
}
k= 0;
if (!(x & 0xffff))
{
k= 16;
x>>= 16;
}
if (!(x & 0xff))
{
k+= 8;
x>>= 8;
}
if (!(x & 0xf))
{
k+= 4;
x>>= 4;
}
if (!(x & 0x3))
{
k+= 2;
x>>= 2;
}
if (!(x & 1))
{
k++;
x>>= 1;
if (!x)
return 32;
}
*y= x;
return k;
} | O3 | c | lo0bits:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %ecx
testb $0x7, %cl
je 0x29f50
xorl %eax, %eax
testb $0x1, %cl
jne 0x29fb7
testb $0x2, %cl
jne 0x29fae
shrl $0x2, %ecx
movl $0x2, %eax
jmp 0x29fb5
movl %ecx, %eax
shrl $0x10, %eax
xorl %edx, %edx
testl $0xfff8, %ecx # imm = 0xFFF8
cmovnel %ecx, %eax
sete %dl
shll $0x4, %edx
leal 0x8(%rdx), %ecx
movl %eax, %esi
shrl $0x8, %esi
testb %al, %al
cmovnel %edx, %ecx
cmovnel %eax, %esi
leal 0x4(%rcx), %edx
movl %esi, %r8d
shrl $0x4, %r8d
testb $0xf, %sil
cmovnel %ecx, %edx
cmovnel %esi, %r8d
leal 0x2(%rdx), %eax
movl %r8d, %ecx
shrl $0x2, %ecx
testb $0x3, %r8b
cmovnel %edx, %eax
cmovnel %r8d, %ecx
testb $0x1, %cl
jne 0x29fb5
testl %ecx, %ecx
je 0x29fb9
incl %eax
shrl %ecx
jmp 0x29fb5
shrl %ecx
movl $0x1, %eax
movl %ecx, (%rdi)
popq %rbp
retq
movl $0x20, %eax
jmp 0x29fb7
| lo0bits:
push rbp
mov rbp, rsp
mov ecx, [rdi]
test cl, 7
jz short loc_29F50
xor eax, eax
test cl, 1
jnz short loc_29FB7
test cl, 2
jnz short loc_29FAE
shr ecx, 2
mov eax, 2
jmp short loc_29FB5
loc_29F50:
mov eax, ecx
shr eax, 10h
xor edx, edx
test ecx, 0FFF8h
cmovnz eax, ecx
setz dl
shl edx, 4
lea ecx, [rdx+8]
mov esi, eax
shr esi, 8
test al, al
cmovnz ecx, edx
cmovnz esi, eax
lea edx, [rcx+4]
mov r8d, esi
shr r8d, 4
test sil, 0Fh
cmovnz edx, ecx
cmovnz r8d, esi
lea eax, [rdx+2]
mov ecx, r8d
shr ecx, 2
test r8b, 3
cmovnz eax, edx
cmovnz ecx, r8d
test cl, 1
jnz short loc_29FB5
test ecx, ecx
jz short loc_29FB9
inc eax
shr ecx, 1
jmp short loc_29FB5
loc_29FAE:
shr ecx, 1
mov eax, 1
loc_29FB5:
mov [rdi], ecx
loc_29FB7:
pop rbp
retn
loc_29FB9:
mov eax, 20h ; ' '
jmp short loc_29FB7
| long long lo0bits(unsigned int *a1)
{
unsigned int v1; // ecx
long long result; // rax
unsigned int v3; // ecx
unsigned int v4; // eax
int v5; // edx
int v6; // edx
int v7; // ecx
unsigned int v8; // esi
unsigned int v9; // edx
unsigned int v10; // r8d
v1 = *a1;
if ( (*a1 & 7) != 0 )
{
result = 0LL;
if ( (v1 & 1) != 0 )
return result;
if ( (v1 & 2) != 0 )
{
v3 = v1 >> 1;
result = 1LL;
}
else
{
v3 = v1 >> 2;
result = 2LL;
}
}
else
{
v4 = HIWORD(v1);
v5 = 0;
if ( (v1 & 0xFFF8) != 0 )
v4 = *a1;
LOBYTE(v5) = (*a1 & 0xFFF8) == 0;
v6 = 16 * v5;
v7 = v6 + 8;
v8 = v4 >> 8;
if ( (_BYTE)v4 )
{
v7 = v6;
v8 = v4;
}
v9 = v7 + 4;
v10 = v8 >> 4;
if ( (v8 & 0xF) != 0 )
{
v9 = v7;
v10 = v8;
}
result = v9 + 2;
v3 = v10 >> 2;
if ( (v10 & 3) != 0 )
{
result = v9;
v3 = v10;
}
if ( (v3 & 1) == 0 )
{
if ( !v3 )
return 32LL;
result = (unsigned int)(result + 1);
v3 >>= 1;
}
}
*a1 = v3;
return result;
}
| lo0bits:
PUSH RBP
MOV RBP,RSP
MOV ECX,dword ptr [RDI]
TEST CL,0x7
JZ 0x00129f50
XOR EAX,EAX
TEST CL,0x1
JNZ 0x00129fb7
TEST CL,0x2
JNZ 0x00129fae
SHR ECX,0x2
MOV EAX,0x2
JMP 0x00129fb5
LAB_00129f50:
MOV EAX,ECX
SHR EAX,0x10
XOR EDX,EDX
TEST ECX,0xfff8
CMOVNZ EAX,ECX
SETZ DL
SHL EDX,0x4
LEA ECX,[RDX + 0x8]
MOV ESI,EAX
SHR ESI,0x8
TEST AL,AL
CMOVNZ ECX,EDX
CMOVNZ ESI,EAX
LEA EDX,[RCX + 0x4]
MOV R8D,ESI
SHR R8D,0x4
TEST SIL,0xf
CMOVNZ EDX,ECX
CMOVNZ R8D,ESI
LEA EAX,[RDX + 0x2]
MOV ECX,R8D
SHR ECX,0x2
TEST R8B,0x3
CMOVNZ EAX,EDX
CMOVNZ ECX,R8D
TEST CL,0x1
JNZ 0x00129fb5
TEST ECX,ECX
JZ 0x00129fb9
INC EAX
SHR ECX,0x1
JMP 0x00129fb5
LAB_00129fae:
SHR ECX,0x1
MOV EAX,0x1
LAB_00129fb5:
MOV dword ptr [RDI],ECX
LAB_00129fb7:
POP RBP
RET
LAB_00129fb9:
MOV EAX,0x20
JMP 0x00129fb7
|
int lo0bits(uint *param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
bool bVar5;
uVar3 = *param_1;
if ((uVar3 & 7) == 0) {
bVar5 = (uVar3 & 0xfff8) == 0;
uVar1 = uVar3 >> 0x10;
if (!bVar5) {
uVar1 = uVar3;
}
iVar4 = (uint)bVar5 * 0x10;
uVar3 = uVar1 >> 8;
iVar2 = iVar4 + 8;
if ((char)uVar1 != '\0') {
uVar3 = uVar1;
iVar2 = iVar4;
}
uVar1 = uVar3 >> 4;
iVar4 = iVar2 + 4;
if ((uVar3 & 0xf) != 0) {
uVar1 = uVar3;
iVar4 = iVar2;
}
uVar3 = uVar1 >> 2;
iVar2 = iVar4 + 2;
if ((uVar1 & 3) != 0) {
uVar3 = uVar1;
iVar2 = iVar4;
}
if ((uVar3 & 1) == 0) {
if (uVar3 == 0) {
return 0x20;
}
iVar2 = iVar2 + 1;
uVar3 = uVar3 >> 1;
}
}
else {
if ((uVar3 & 1) != 0) {
return 0;
}
if ((uVar3 & 2) == 0) {
uVar3 = uVar3 >> 2;
iVar2 = 2;
}
else {
uVar3 = uVar3 >> 1;
iVar2 = 1;
}
}
*param_1 = uVar3;
return iVar2;
}
|
|
6,408 | my_strnncoll_win1250ch | eloqsql/strings/ctype-win1250ch.c | static int my_strnncoll_win1250ch(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s1, size_t len1,
const uchar *s2, size_t len2,
my_bool s2_is_prefix)
{
int v1, v2;
const uchar *p1, * p2;
int pass1 = 0, pass2 = 0;
int diff;
if (s2_is_prefix && len1 > len2)
len1=len2;
p1 = s1; p2 = s2;
do
{
NEXT_CMP_VALUE(s1, p1, pass1, v1, (int)len1);
NEXT_CMP_VALUE(s2, p2, pass2, v2, (int)len2);
if ((diff = v1 - v2))
return diff;
} while (v1);
return 0;
} | O0 | c | my_strnncoll_win1250ch:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
movl $0x0, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x0, %eax
je 0x714eb
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x714eb
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x714fd
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x71544
cmpl $0x0, -0x54(%rbp)
jne 0x71536
movq -0x20(%rbp), %rax
cmpl $0x0, %eax
jle 0x71536
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x71542
movl $0x0, -0x38(%rbp)
jmp 0x716b8
jmp 0x71544
cmpl $0x0, -0x54(%rbp)
jne 0x71566
movq -0x48(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x14b0e6(%rip), %rax # 0x1bc640
movzbl (%rax,%rcx), %eax
movl %eax, -0x8c(%rbp)
jmp 0x71580
movq -0x48(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x31acfa(%rip), %rax # 0x38c270
movzbl (%rax,%rcx), %eax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpl $0xff, -0x38(%rbp)
jne 0x716ac
movl $0x0, -0x60(%rbp)
cmpl $0x50, -0x60(%rbp)
jge 0x716aa
movslq -0x60(%rbp), %rcx
leaq 0x162f6e(%rip), %rax # 0x1d4520
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x8d(%rbp)
je 0x71614
movq -0x70(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rax, %rcx
movq -0x20(%rbp), %rax
movslq %eax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x8d(%rbp)
jge 0x71614
movq -0x68(%rbp), %rax
movzbl (%rax), %eax
movq -0x70(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x8d(%rbp)
movb -0x8d(%rbp), %al
testb $0x1, %al
jne 0x71620
jmp 0x7163a
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x715c8
movq -0x68(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x7169a
cmpl $0x0, -0x54(%rbp)
jne 0x71667
movslq -0x60(%rbp), %rcx
leaq 0x162ecc(%rip), %rax # 0x1d4520
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x8(%rax), %eax
movl %eax, -0x94(%rbp)
jmp 0x71683
movslq -0x60(%rbp), %rcx
leaq 0x162eae(%rip), %rax # 0x1d4520
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x9(%rax), %eax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x70(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x716aa
jmp 0x7169c
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x7159d
jmp 0x716ac
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x716ba
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x71701
cmpl $0x0, -0x58(%rbp)
jne 0x716f3
movq -0x30(%rbp), %rax
cmpl $0x0, %eax
jle 0x716f3
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x716ff
movl $0x0, -0x3c(%rbp)
jmp 0x71887
jmp 0x71701
cmpl $0x0, -0x58(%rbp)
jne 0x71723
movq -0x50(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x14af29(%rip), %rax # 0x1bc640
movzbl (%rax,%rcx), %eax
movl %eax, -0x98(%rbp)
jmp 0x7173d
movq -0x50(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x31ab3d(%rip), %rax # 0x38c270
movzbl (%rax,%rcx), %eax
movl %eax, -0x98(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0xff, -0x3c(%rbp)
jne 0x7187b
movl $0x0, -0x74(%rbp)
cmpl $0x50, -0x74(%rbp)
jge 0x71879
movslq -0x74(%rbp), %rcx
leaq 0x162db1(%rip), %rax # 0x1d4520
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x99(%rbp)
je 0x717da
movq -0x88(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rax, %rcx
movq -0x30(%rbp), %rax
movslq %eax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x99(%rbp)
jge 0x717da
movq -0x80(%rbp), %rax
movzbl (%rax), %eax
movq -0x88(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x99(%rbp)
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x717e6
jmp 0x71806
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x71788
movq -0x80(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x71869
cmpl $0x0, -0x58(%rbp)
jne 0x71833
movslq -0x74(%rbp), %rcx
leaq 0x162d00(%rip), %rax # 0x1d4520
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x8(%rax), %eax
movl %eax, -0xa0(%rbp)
jmp 0x7184f
movslq -0x74(%rbp), %rcx
leaq 0x162ce2(%rip), %rax # 0x1d4520
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x9(%rax), %eax
movl %eax, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x88(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x71879
jmp 0x7186b
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x7175a
jmp 0x7187b
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
subl -0x3c(%rbp), %eax
movl %eax, -0x5c(%rbp)
cmpl $0x0, %eax
je 0x7189d
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x718b0
jmp 0x7189f
cmpl $0x0, -0x38(%rbp)
jne 0x714fb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnncoll_win1250ch:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, r9b
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_31], al
mov [rbp+var_54], 0
mov [rbp+var_58], 0
movsx eax, [rbp+var_31]
cmp eax, 0
jz short loc_714EB
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jbe short loc_714EB
mov rax, [rbp+var_30]
mov [rbp+var_20], rax
loc_714EB:
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
loc_714FB:
jmp short $+2
loc_714FD:
mov rax, [rbp+var_48]
mov rcx, [rbp+var_18]
sub rax, rcx
mov rcx, [rbp+var_20]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_71544
cmp [rbp+var_54], 0
jnz short loc_71536
mov rax, [rbp+var_20]
cmp eax, 0
jle short loc_71536
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov eax, [rbp+var_54]
add eax, 1
mov [rbp+var_54], eax
jmp short loc_71542
loc_71536:
mov [rbp+var_38], 0
jmp loc_716B8
loc_71542:
jmp short $+2
loc_71544:
cmp [rbp+var_54], 0
jnz short loc_71566
mov rax, [rbp+var_48]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, _sort_order_win1250ch1
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_8C], eax
jmp short loc_71580
loc_71566:
mov rax, [rbp+var_48]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, _sort_order_win1250ch2
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_8C], eax
loc_71580:
mov eax, [rbp+var_8C]
mov [rbp+var_38], eax
cmp [rbp+var_38], 0FFh
jnz loc_716AC
mov [rbp+var_60], 0
loc_7159D:
cmp [rbp+var_60], 50h ; 'P'
jge loc_716AA
movsxd rcx, [rbp+var_60]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_68], rax
mov rax, [rbp+var_48]
mov [rbp+var_70], rax
loc_715C8:
mov rax, [rbp+var_68]
movzx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_8D], al
jz short loc_71614
mov rcx, [rbp+var_70]
mov rax, [rbp+var_18]
sub rcx, rax
mov rax, [rbp+var_20]
movsxd rdx, eax
xor eax, eax
cmp rcx, rdx
mov [rbp+var_8D], al
jge short loc_71614
mov rax, [rbp+var_68]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_70]
movzx ecx, byte ptr [rcx]
cmp eax, ecx
setz al
mov [rbp+var_8D], al
loc_71614:
mov al, [rbp+var_8D]
test al, 1
jnz short loc_71620
jmp short loc_7163A
loc_71620:
mov rax, [rbp+var_68]
add rax, 1
mov [rbp+var_68], rax
mov rax, [rbp+var_70]
add rax, 1
mov [rbp+var_70], rax
jmp short loc_715C8
loc_7163A:
mov rax, [rbp+var_68]
cmp byte ptr [rax], 0
jnz short loc_7169A
cmp [rbp+var_54], 0
jnz short loc_71667
movsxd rcx, [rbp+var_60]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
movzx eax, byte ptr [rax+8]
mov [rbp+var_94], eax
jmp short loc_71683
loc_71667:
movsxd rcx, [rbp+var_60]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
movzx eax, byte ptr [rax+9]
mov [rbp+var_94], eax
loc_71683:
mov eax, [rbp+var_94]
mov [rbp+var_38], eax
mov rax, [rbp+var_70]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_48], rax
jmp short loc_716AA
loc_7169A:
jmp short $+2
loc_7169C:
mov eax, [rbp+var_60]
add eax, 1
mov [rbp+var_60], eax
jmp loc_7159D
loc_716AA:
jmp short $+2
loc_716AC:
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_48], rax
loc_716B8:
jmp short $+2
loc_716BA:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_71701
cmp [rbp+var_58], 0
jnz short loc_716F3
mov rax, [rbp+var_30]
cmp eax, 0
jle short loc_716F3
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
mov eax, [rbp+var_58]
add eax, 1
mov [rbp+var_58], eax
jmp short loc_716FF
loc_716F3:
mov [rbp+var_3C], 0
jmp loc_71887
loc_716FF:
jmp short $+2
loc_71701:
cmp [rbp+var_58], 0
jnz short loc_71723
mov rax, [rbp+var_50]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, _sort_order_win1250ch1
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_98], eax
jmp short loc_7173D
loc_71723:
mov rax, [rbp+var_50]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, _sort_order_win1250ch2
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_98], eax
loc_7173D:
mov eax, [rbp+var_98]
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0FFh
jnz loc_7187B
mov [rbp+var_74], 0
loc_7175A:
cmp [rbp+var_74], 50h ; 'P'
jge loc_71879
movsxd rcx, [rbp+var_74]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_80], rax
mov rax, [rbp+var_50]
mov [rbp+var_88], rax
loc_71788:
mov rax, [rbp+var_80]
movzx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_99], al
jz short loc_717DA
mov rcx, [rbp+var_88]
mov rax, [rbp+var_28]
sub rcx, rax
mov rax, [rbp+var_30]
movsxd rdx, eax
xor eax, eax
cmp rcx, rdx
mov [rbp+var_99], al
jge short loc_717DA
mov rax, [rbp+var_80]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_88]
movzx ecx, byte ptr [rcx]
cmp eax, ecx
setz al
mov [rbp+var_99], al
loc_717DA:
mov al, [rbp+var_99]
test al, 1
jnz short loc_717E6
jmp short loc_71806
loc_717E6:
mov rax, [rbp+var_80]
add rax, 1
mov [rbp+var_80], rax
mov rax, [rbp+var_88]
add rax, 1
mov [rbp+var_88], rax
jmp short loc_71788
loc_71806:
mov rax, [rbp+var_80]
cmp byte ptr [rax], 0
jnz short loc_71869
cmp [rbp+var_58], 0
jnz short loc_71833
movsxd rcx, [rbp+var_74]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
movzx eax, byte ptr [rax+8]
mov [rbp+var_A0], eax
jmp short loc_7184F
loc_71833:
movsxd rcx, [rbp+var_74]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
movzx eax, byte ptr [rax+9]
mov [rbp+var_A0], eax
loc_7184F:
mov eax, [rbp+var_A0]
mov [rbp+var_3C], eax
mov rax, [rbp+var_88]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_50], rax
jmp short loc_71879
loc_71869:
jmp short $+2
loc_7186B:
mov eax, [rbp+var_74]
add eax, 1
mov [rbp+var_74], eax
jmp loc_7175A
loc_71879:
jmp short $+2
loc_7187B:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
loc_71887:
mov eax, [rbp+var_38]
sub eax, [rbp+var_3C]
mov [rbp+var_5C], eax
cmp eax, 0
jz short loc_7189D
mov eax, [rbp+var_5C]
mov [rbp+var_4], eax
jmp short loc_718B0
loc_7189D:
jmp short $+2
loc_7189F:
cmp [rbp+var_38], 0
jnz loc_714FB
mov [rbp+var_4], 0
loc_718B0:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long my_strnncoll_win1250ch(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
char a6)
{
int v7; // [rsp+0h] [rbp-A0h]
bool v8; // [rsp+7h] [rbp-99h]
int v9; // [rsp+8h] [rbp-98h]
int v10; // [rsp+Ch] [rbp-94h]
bool v11; // [rsp+13h] [rbp-8Dh]
int v12; // [rsp+14h] [rbp-8Ch]
unsigned __int8 *m; // [rsp+18h] [rbp-88h]
_BYTE *v14; // [rsp+20h] [rbp-80h]
int k; // [rsp+2Ch] [rbp-74h]
unsigned __int8 *j; // [rsp+30h] [rbp-70h]
_BYTE *v17; // [rsp+38h] [rbp-68h]
int i; // [rsp+40h] [rbp-60h]
int v19; // [rsp+48h] [rbp-58h]
int v20; // [rsp+4Ch] [rbp-54h]
unsigned __int8 *v21; // [rsp+50h] [rbp-50h]
unsigned __int8 *v22; // [rsp+58h] [rbp-48h]
int v23; // [rsp+64h] [rbp-3Ch]
int v24; // [rsp+68h] [rbp-38h]
int v25; // [rsp+80h] [rbp-20h]
v25 = a3;
v20 = 0;
v19 = 0;
if ( a6 && a3 > a5 )
v25 = a5;
v22 = a2;
v21 = a4;
do
{
if ( v22 - a2 >= v25 )
{
if ( v20 || v25 <= 0 )
{
v24 = 0;
goto LABEL_29;
}
v22 = a2;
v20 = 1;
}
if ( v20 )
v12 = sort_order_win1250ch2[*v22];
else
v12 = sort_order_win1250ch1[*v22];
v24 = v12;
if ( v12 == 255 )
{
for ( i = 0; i < 80; ++i )
{
v17 = *(&doubles_0 + 2 * i);
for ( j = v22; ; ++j )
{
v11 = 0;
if ( *v17 )
{
v11 = 0;
if ( j - a2 < v25 )
v11 = (unsigned __int8)*v17 == *j;
}
if ( !v11 )
break;
++v17;
}
if ( !*v17 )
{
if ( v20 )
v10 = *((unsigned __int8 *)&doubles_0 + 16 * i + 9);
else
v10 = *((unsigned __int8 *)&doubles_0 + 16 * i + 8);
v24 = v10;
v22 = j - 1;
break;
}
}
}
++v22;
LABEL_29:
if ( v21 - a4 >= (int)a5 )
{
if ( v19 || (int)a5 <= 0 )
{
v23 = 0;
goto LABEL_53;
}
v21 = a4;
v19 = 1;
}
if ( v19 )
v9 = sort_order_win1250ch2[*v21];
else
v9 = sort_order_win1250ch1[*v21];
v23 = v9;
if ( v9 == 255 )
{
for ( k = 0; k < 80; ++k )
{
v14 = *(&doubles_0 + 2 * k);
for ( m = v21; ; ++m )
{
v8 = 0;
if ( *v14 )
{
v8 = 0;
if ( m - a4 < (int)a5 )
v8 = (unsigned __int8)*v14 == *m;
}
if ( !v8 )
break;
++v14;
}
if ( !*v14 )
{
if ( v19 )
v7 = *((unsigned __int8 *)&doubles_0 + 16 * k + 9);
else
v7 = *((unsigned __int8 *)&doubles_0 + 16 * k + 8);
v23 = v7;
v21 = m - 1;
break;
}
}
}
++v21;
LABEL_53:
if ( v24 != v23 )
return (unsigned int)(v24 - v23);
}
while ( v24 );
return 0;
}
| my_strnncoll_win1250ch:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,R9B
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV byte ptr [RBP + -0x31],AL
MOV dword ptr [RBP + -0x54],0x0
MOV dword ptr [RBP + -0x58],0x0
MOVSX EAX,byte ptr [RBP + -0x31]
CMP EAX,0x0
JZ 0x001714eb
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x001714eb
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x20],RAX
LAB_001714eb:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
LAB_001714fb:
JMP 0x001714fd
LAB_001714fd:
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
CMP RAX,RCX
JL 0x00171544
CMP dword ptr [RBP + -0x54],0x0
JNZ 0x00171536
MOV RAX,qword ptr [RBP + -0x20]
CMP EAX,0x0
JLE 0x00171536
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x00171542
LAB_00171536:
MOV dword ptr [RBP + -0x38],0x0
JMP 0x001716b8
LAB_00171542:
JMP 0x00171544
LAB_00171544:
CMP dword ptr [RBP + -0x54],0x0
JNZ 0x00171566
MOV RAX,qword ptr [RBP + -0x48]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x2bc640]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x8c],EAX
JMP 0x00171580
LAB_00171566:
MOV RAX,qword ptr [RBP + -0x48]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x48c270]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x8c],EAX
LAB_00171580:
MOV EAX,dword ptr [RBP + -0x8c]
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0xff
JNZ 0x001716ac
MOV dword ptr [RBP + -0x60],0x0
LAB_0017159d:
CMP dword ptr [RBP + -0x60],0x50
JGE 0x001716aa
MOVSXD RCX,dword ptr [RBP + -0x60]
LEA RAX,[0x2d4520]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x70],RAX
LAB_001715c8:
MOV RAX,qword ptr [RBP + -0x68]
MOVZX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x8d],AL
JZ 0x00171614
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x18]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RDX,EAX
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0x8d],AL
JGE 0x00171614
MOV RAX,qword ptr [RBP + -0x68]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x70]
MOVZX ECX,byte ptr [RCX]
CMP EAX,ECX
SETZ AL
MOV byte ptr [RBP + -0x8d],AL
LAB_00171614:
MOV AL,byte ptr [RBP + -0x8d]
TEST AL,0x1
JNZ 0x00171620
JMP 0x0017163a
LAB_00171620:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0x1
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001715c8
LAB_0017163a:
MOV RAX,qword ptr [RBP + -0x68]
CMP byte ptr [RAX],0x0
JNZ 0x0017169a
CMP dword ptr [RBP + -0x54],0x0
JNZ 0x00171667
MOVSXD RCX,dword ptr [RBP + -0x60]
LEA RAX,[0x2d4520]
SHL RCX,0x4
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x94],EAX
JMP 0x00171683
LAB_00171667:
MOVSXD RCX,dword ptr [RBP + -0x60]
LEA RAX,[0x2d4520]
SHL RCX,0x4
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX + 0x9]
MOV dword ptr [RBP + -0x94],EAX
LAB_00171683:
MOV EAX,dword ptr [RBP + -0x94]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001716aa
LAB_0017169a:
JMP 0x0017169c
LAB_0017169c:
MOV EAX,dword ptr [RBP + -0x60]
ADD EAX,0x1
MOV dword ptr [RBP + -0x60],EAX
JMP 0x0017159d
LAB_001716aa:
JMP 0x001716ac
LAB_001716ac:
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
LAB_001716b8:
JMP 0x001716ba
LAB_001716ba:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JL 0x00171701
CMP dword ptr [RBP + -0x58],0x0
JNZ 0x001716f3
MOV RAX,qword ptr [RBP + -0x30]
CMP EAX,0x0
JLE 0x001716f3
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x58]
ADD EAX,0x1
MOV dword ptr [RBP + -0x58],EAX
JMP 0x001716ff
LAB_001716f3:
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x00171887
LAB_001716ff:
JMP 0x00171701
LAB_00171701:
CMP dword ptr [RBP + -0x58],0x0
JNZ 0x00171723
MOV RAX,qword ptr [RBP + -0x50]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x2bc640]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x98],EAX
JMP 0x0017173d
LAB_00171723:
MOV RAX,qword ptr [RBP + -0x50]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x48c270]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x98],EAX
LAB_0017173d:
MOV EAX,dword ptr [RBP + -0x98]
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0xff
JNZ 0x0017187b
MOV dword ptr [RBP + -0x74],0x0
LAB_0017175a:
CMP dword ptr [RBP + -0x74],0x50
JGE 0x00171879
MOVSXD RCX,dword ptr [RBP + -0x74]
LEA RAX,[0x2d4520]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x88],RAX
LAB_00171788:
MOV RAX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x99],AL
JZ 0x001717da
MOV RCX,qword ptr [RBP + -0x88]
MOV RAX,qword ptr [RBP + -0x28]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RDX,EAX
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0x99],AL
JGE 0x001717da
MOV RAX,qword ptr [RBP + -0x80]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x88]
MOVZX ECX,byte ptr [RCX]
CMP EAX,ECX
SETZ AL
MOV byte ptr [RBP + -0x99],AL
LAB_001717da:
MOV AL,byte ptr [RBP + -0x99]
TEST AL,0x1
JNZ 0x001717e6
JMP 0x00171806
LAB_001717e6:
MOV RAX,qword ptr [RBP + -0x80]
ADD RAX,0x1
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,0x1
MOV qword ptr [RBP + -0x88],RAX
JMP 0x00171788
LAB_00171806:
MOV RAX,qword ptr [RBP + -0x80]
CMP byte ptr [RAX],0x0
JNZ 0x00171869
CMP dword ptr [RBP + -0x58],0x0
JNZ 0x00171833
MOVSXD RCX,dword ptr [RBP + -0x74]
LEA RAX,[0x2d4520]
SHL RCX,0x4
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX + 0x8]
MOV dword ptr [RBP + -0xa0],EAX
JMP 0x0017184f
LAB_00171833:
MOVSXD RCX,dword ptr [RBP + -0x74]
LEA RAX,[0x2d4520]
SHL RCX,0x4
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX + 0x9]
MOV dword ptr [RBP + -0xa0],EAX
LAB_0017184f:
MOV EAX,dword ptr [RBP + -0xa0]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00171879
LAB_00171869:
JMP 0x0017186b
LAB_0017186b:
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOV dword ptr [RBP + -0x74],EAX
JMP 0x0017175a
LAB_00171879:
JMP 0x0017187b
LAB_0017187b:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
LAB_00171887:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x5c],EAX
CMP EAX,0x0
JZ 0x0017189d
MOV EAX,dword ptr [RBP + -0x5c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001718b0
LAB_0017189d:
JMP 0x0017189f
LAB_0017189f:
CMP dword ptr [RBP + -0x38],0x0
JNZ 0x001714fb
MOV dword ptr [RBP + -0x4],0x0
LAB_001718b0:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int my_strnncoll_win1250ch
(int8 param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
char param_6)
{
byte bVar1;
bool bVar2;
bool bVar3;
int iVar4;
bool bVar5;
uint local_a8;
uint local_a0;
uint local_9c;
uint local_94;
byte *local_90;
byte *local_88;
int local_7c;
byte *local_78;
byte *local_70;
int local_68;
byte *local_58;
byte *local_50;
uint local_44;
uint local_40;
ulong local_28;
bVar2 = false;
bVar3 = false;
local_58 = param_4;
local_50 = param_2;
local_28 = param_3;
if ((param_6 != '\0') && (param_5 < param_3)) {
local_28 = param_5;
}
do {
iVar4 = (int)local_28;
if ((long)local_50 - (long)param_2 < (long)iVar4) {
LAB_00171544:
if (bVar2) {
bVar1 = _sort_order_win1250ch2[*local_50];
}
else {
bVar1 = _sort_order_win1250ch1[*local_50];
}
local_94 = (uint)bVar1;
local_40 = local_94;
if (local_94 == 0xff) {
for (local_68 = 0; local_68 < 0x50; local_68 = local_68 + 1) {
local_70 = *(byte **)(doubles + (long)local_68 * 0x10);
local_78 = local_50;
while( true ) {
bVar5 = false;
if ((*local_70 != 0) && (bVar5 = false, (long)local_78 - (long)param_2 < (long)iVar4)) {
bVar5 = *local_70 == *local_78;
}
if (!bVar5) break;
local_70 = local_70 + 1;
local_78 = local_78 + 1;
}
if (*local_70 == 0) {
if (bVar2) {
bVar1 = doubles[(long)local_68 * 0x10 + 9];
}
else {
bVar1 = doubles[(long)local_68 * 0x10 + 8];
}
local_9c = (uint)bVar1;
local_40 = local_9c;
local_50 = local_78 + -1;
break;
}
}
}
local_50 = local_50 + 1;
}
else {
if ((!bVar2) && (0 < iVar4)) {
bVar2 = true;
local_50 = param_2;
goto LAB_00171544;
}
local_40 = 0;
}
iVar4 = (int)param_5;
if ((long)local_58 - (long)param_4 < (long)iVar4) {
LAB_00171701:
if (bVar3) {
bVar1 = _sort_order_win1250ch2[*local_58];
}
else {
bVar1 = _sort_order_win1250ch1[*local_58];
}
local_a0 = (uint)bVar1;
local_44 = local_a0;
if (local_a0 == 0xff) {
for (local_7c = 0; local_7c < 0x50; local_7c = local_7c + 1) {
local_88 = *(byte **)(doubles + (long)local_7c * 0x10);
local_90 = local_58;
while( true ) {
bVar5 = false;
if ((*local_88 != 0) && (bVar5 = false, (long)local_90 - (long)param_4 < (long)iVar4)) {
bVar5 = *local_88 == *local_90;
}
if (!bVar5) break;
local_88 = local_88 + 1;
local_90 = local_90 + 1;
}
if (*local_88 == 0) {
if (bVar3) {
bVar1 = doubles[(long)local_7c * 0x10 + 9];
}
else {
bVar1 = doubles[(long)local_7c * 0x10 + 8];
}
local_a8 = (uint)bVar1;
local_44 = local_a8;
local_58 = local_90 + -1;
break;
}
}
}
local_58 = local_58 + 1;
}
else {
if ((!bVar3) && (0 < iVar4)) {
bVar3 = true;
local_58 = param_4;
goto LAB_00171701;
}
local_44 = 0;
}
if (local_40 - local_44 != 0) {
return local_40 - local_44;
}
if (local_40 == 0) {
return 0;
}
} while( true );
}
|
|
6,409 | skip_trailing_space | eloqsql/strings/strings_def.h | static inline const uchar *skip_trailing_space(const uchar *ptr,size_t len)
{
const uchar *end= ptr + len;
if (len > 20)
{
const uchar *end_words= (const uchar *)(intptr)
(((ulonglong)(intptr)end) / SIZEOF_INT * SIZEOF_INT);
const uchar *start_words= (const uchar *)(intptr)
((((ulonglong)(intptr)ptr) + SIZEOF_INT - 1) / SIZEOF_INT * SIZEOF_INT);
DBUG_ASSERT(((ulonglong)(intptr)ptr) >= SIZEOF_INT);
if (end_words > ptr)
{
while (end > end_words && end[-1] == 0x20)
end--;
if (end[-1] == 0x20 && start_words < end_words)
while (end > start_words && ((unsigned *)end)[-1] == SPACE_INT)
end -= SIZEOF_INT;
}
}
while (end > ptr && end[-1] == 0x20)
end--;
return (end);
} | O0 | c | skip_trailing_space:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x14, -0x10(%rbp)
jbe 0x35aaa
movq -0x18(%rbp), %rax
shrq $0x2, %rax
shlq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
shlq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x35a0d
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jbe 0x35aa8
jmp 0x35a1d
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x29(%rbp)
jbe 0x35a3d
movq -0x18(%rbp), %rax
movzbl -0x1(%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x35a46
jmp 0x35a54
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x35a1d
movq -0x18(%rbp), %rax
movzbl -0x1(%rax), %eax
cmpl $0x20, %eax
jne 0x35aa6
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x35aa6
jmp 0x35a6d
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x2a(%rbp)
jbe 0x35a8d
movq -0x18(%rbp), %rax
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x35a96
jmp 0x35aa4
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x35a6d
jmp 0x35aa6
jmp 0x35aa8
jmp 0x35aaa
jmp 0x35aac
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x2b(%rbp)
jbe 0x35acc
movq -0x18(%rbp), %rax
movzbl -0x1(%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
testb $0x1, %al
jne 0x35ad5
jmp 0x35ae3
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x35aac
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| skip_trailing_space:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_18], rax
cmp [rbp+var_10], 14h
jbe loc_35AAA
mov rax, [rbp+var_18]
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov rax, [rbp+var_8]
add rax, 4
sub rax, 1
shr rax, 2
shl rax, 2
mov [rbp+var_28], rax
jmp short $+2
loc_35A0D:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_8]
jbe loc_35AA8
jmp short $+2
loc_35A1D:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_20]
mov [rbp+var_29], al
jbe short loc_35A3D
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax-1]
cmp eax, 20h ; ' '
setz al
mov [rbp+var_29], al
loc_35A3D:
mov al, [rbp+var_29]
test al, 1
jnz short loc_35A46
jmp short loc_35A54
loc_35A46:
mov rax, [rbp+var_18]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_18], rax
jmp short loc_35A1D
loc_35A54:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax-1]
cmp eax, 20h ; ' '
jnz short loc_35AA6
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jnb short loc_35AA6
jmp short $+2
loc_35A6D:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_2A], al
jbe short loc_35A8D
mov rax, [rbp+var_18]
cmp dword ptr [rax-4], 20202020h
setz al
mov [rbp+var_2A], al
loc_35A8D:
mov al, [rbp+var_2A]
test al, 1
jnz short loc_35A96
jmp short loc_35AA4
loc_35A96:
mov rax, [rbp+var_18]
add rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rax
jmp short loc_35A6D
loc_35AA4:
jmp short $+2
loc_35AA6:
jmp short $+2
loc_35AA8:
jmp short $+2
loc_35AAA:
jmp short $+2
loc_35AAC:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_8]
mov [rbp+var_2B], al
jbe short loc_35ACC
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax-1]
cmp eax, 20h ; ' '
setz al
mov [rbp+var_2B], al
loc_35ACC:
mov al, [rbp+var_2B]
test al, 1
jnz short loc_35AD5
jmp short loc_35AE3
loc_35AD5:
mov rax, [rbp+var_18]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_18], rax
jmp short loc_35AAC
loc_35AE3:
mov rax, [rbp+var_18]
pop rbp
retn
| unsigned long long skip_trailing_space(unsigned long long a1, unsigned long long a2)
{
bool v3; // [rsp+1h] [rbp-2Bh]
bool v4; // [rsp+2h] [rbp-2Ah]
bool v5; // [rsp+3h] [rbp-29h]
unsigned long long v6; // [rsp+4h] [rbp-28h]
unsigned long long v7; // [rsp+Ch] [rbp-20h]
unsigned long long v8; // [rsp+14h] [rbp-18h]
v8 = a2 + a1;
if ( a2 > 0x14 )
{
v7 = 4 * (v8 >> 2);
v6 = 4 * ((a1 + 3) >> 2);
if ( v7 > a1 )
{
while ( 1 )
{
v5 = 0;
if ( v8 > v7 )
v5 = *(_BYTE *)(v8 - 1) == 32;
if ( !v5 )
break;
--v8;
}
if ( *(_BYTE *)(v8 - 1) == 32 && v6 < v7 )
{
while ( 1 )
{
v4 = 0;
if ( v8 > v6 )
v4 = *(_DWORD *)(v8 - 4) == 538976288;
if ( !v4 )
break;
v8 -= 4LL;
}
}
}
}
while ( 1 )
{
v3 = 0;
if ( v8 > a1 )
v3 = *(_BYTE *)(v8 - 1) == 32;
if ( !v3 )
break;
--v8;
}
return v8;
}
| skip_trailing_space:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x10],0x14
JBE 0x00135aaa
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x4
SUB RAX,0x1
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00135a0d
LAB_00135a0d:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x8]
JBE 0x00135aa8
JMP 0x00135a1d
LAB_00135a1d:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x29],AL
JBE 0x00135a3d
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x20
SETZ AL
MOV byte ptr [RBP + -0x29],AL
LAB_00135a3d:
MOV AL,byte ptr [RBP + -0x29]
TEST AL,0x1
JNZ 0x00135a46
JMP 0x00135a54
LAB_00135a46:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00135a1d
LAB_00135a54:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x20
JNZ 0x00135aa6
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00135aa6
JMP 0x00135a6d
LAB_00135a6d:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x2a],AL
JBE 0x00135a8d
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + -0x4],0x20202020
SETZ AL
MOV byte ptr [RBP + -0x2a],AL
LAB_00135a8d:
MOV AL,byte ptr [RBP + -0x2a]
TEST AL,0x1
JNZ 0x00135a96
JMP 0x00135aa4
LAB_00135a96:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,-0x4
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00135a6d
LAB_00135aa4:
JMP 0x00135aa6
LAB_00135aa6:
JMP 0x00135aa8
LAB_00135aa8:
JMP 0x00135aaa
LAB_00135aaa:
JMP 0x00135aac
LAB_00135aac:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x8]
MOV byte ptr [RBP + -0x2b],AL
JBE 0x00135acc
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x20
SETZ AL
MOV byte ptr [RBP + -0x2b],AL
LAB_00135acc:
MOV AL,byte ptr [RBP + -0x2b]
TEST AL,0x1
JNZ 0x00135ad5
JMP 0x00135ae3
LAB_00135ad5:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00135aac
LAB_00135ae3:
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
ulong skip_trailing_space(ulong param_1,ulong param_2)
{
ulong uVar1;
ulong uVar2;
bool bVar3;
ulong local_20;
local_20 = param_1 + param_2;
if (0x14 < param_2) {
uVar1 = local_20 & 0xfffffffffffffffc;
uVar2 = param_1 + 3 & 0xfffffffffffffffc;
if (param_1 < uVar1) {
while( true ) {
bVar3 = false;
if (uVar1 < local_20) {
bVar3 = *(char *)(local_20 - 1) == ' ';
}
if (!bVar3) break;
local_20 = local_20 - 1;
}
if ((*(char *)(local_20 - 1) == ' ') && (uVar2 < uVar1)) {
while( true ) {
bVar3 = false;
if (uVar2 < local_20) {
bVar3 = *(int *)(local_20 - 4) == 0x20202020;
}
if (!bVar3) break;
local_20 = local_20 - 4;
}
}
}
}
while( true ) {
bVar3 = false;
if (param_1 < local_20) {
bVar3 = *(char *)(local_20 - 1) == ' ';
}
if (!bVar3) break;
local_20 = local_20 - 1;
}
return local_20;
}
|
|
6,410 | nlohmann::json_abi_v3_11_3::detail::parse_error nlohmann::json_abi_v3_11_3::detail::parse_error::create<std::nullptr_t, 0>(int, nlohmann::json_abi_v3_11_3::detail::position_t const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t) | monkey531[P]llama/common/./json.hpp | static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("parse_error", id_), "parse error",
position_string(pos), ": ", exception::diagnostics(context), what_arg);
return {id_, pos.chars_read_total, w.c_str()};
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::parse_error nlohmann::json_abi_v3_11_3::detail::parse_error::create<std::nullptr_t, 0>(int, nlohmann::json_abi_v3_11_3::detail::position_t const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8bac5(%rip), %rsi # 0xb6f4c
leaq 0x8bac9(%rip), %rdx # 0xb6f57
leaq 0x8(%rsp), %rdi
callq 0x32ea4
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x29158
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x317d4
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq %r15, (%rsp)
leaq 0x8ba81(%rip), %rdx # 0xb6f58
leaq 0x8fd3c(%rip), %r8 # 0xbb21a
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r9
callq 0x316cb
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2b511
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x196b0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b52c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x196b0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b547
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x196b0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b55e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
movq (%r14), %r14
movq 0x88(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x293c0
leaq 0xc1a0e(%rip), %rax # 0xecf88
movq %rax, (%rbx)
movq %r14, 0x20(%rbx)
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b5a2
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x196b0
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b64f
movq 0x98(%rsp), %rsi
jmp 0x2b642
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2b5f3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x196b0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b613
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x2b613
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b633
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x2b633
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b64f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x2b64f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x19be0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov r15, rcx
mov r14, rdx
mov ebp, esi
mov rbx, rdi
lea r12, [rsp+0D8h+var_C0]
mov [r12-10h], r12
lea rsi, aParseError; "parse_error"
lea rdx, aParseError+0Bh; ""
lea rdi, [rsp+0D8h+var_D0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+0D8h+var_70]; int
lea rsi, [rsp+0D8h+var_D0]; int
mov edx, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; nlohmann::json_abi_v3_11_3::detail::exception::name(std::string const&,int)
lea rdi, [rsp+0D8h+var_90]; int
mov rsi, r14; int
call _ZN8nlohmann16json_abi_v3_11_36detail11parse_error15position_stringB5cxx11ERKNS1_10position_tE; nlohmann::json_abi_v3_11_3::detail::parse_error::position_string(nlohmann::json_abi_v3_11_3::detail::position_t const&)
lea r13, [rsp+0D8h+var_A0]
mov [r13-10h], r13
mov qword ptr [r13-8], 0
mov byte ptr [r13+0], 0
mov [rsp+0D8h+var_D8], r15
lea rdx, aParseError_0; "parse error"
lea r8, aSubtype+9; ": "
lea rdi, [rsp+0D8h+var_50]
lea rsi, [rsp+0D8h+var_70]
lea rcx, [rsp+0D8h+var_90]
lea r9, [rsp+0D8h+var_B0]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS8_RA12_KcS8_RA3_S9_S8_RKS8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,char const(&)[12],std::string,char const(&)[3],std::string,std::string const&>(std::string,char const(&)[12],std::string,char const(&)[3],std::string,std::string const&)
mov rdi, [rsp+0D8h+var_B0]; void *
cmp rdi, r13
jz short loc_2B511
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2B511:
lea rax, [rsp+0D8h+var_80]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2B52C
mov rsi, [rsp+0D8h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2B52C:
lea rax, [rsp+0D8h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2B547
mov rsi, [rsp+0D8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2B547:
mov rdi, [rsp+0D8h+var_D0]; void *
cmp rdi, r12
jz short loc_2B55E
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2B55E:
mov r14, [r14]
mov rdx, [rsp+0D8h+var_50]; char *
mov rdi, rbx; this
mov esi, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exceptionC2EiPKc; nlohmann::json_abi_v3_11_3::detail::exception::exception(int,char const*)
lea rax, off_ECF88
mov [rbx], rax
mov [rbx+20h], r14
lea rax, [rsp+0D8h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2B5A2
mov rsi, [rsp+0D8h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2B5A2:
mov rax, rbx
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rax, [rsp+arg_90]
mov rdi, [rax-10h]
cmp rdi, rax
jz loc_2B64F
mov rsi, [rsp+arg_90]
jmp short loc_2B642
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_2B5F3
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2B5F3:
lea rax, [rsp+arg_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2B613
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2B613
mov rbx, rax
loc_2B613:
lea rax, [rsp+arg_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2B633
mov rsi, [rsp+arg_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2B633
mov rbx, rax
loc_2B633:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_2B64F
mov rsi, [rsp+arg_10]
loc_2B642:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2B64F
mov rbx, rax
loc_2B64F:
mov rdi, rbx
call __Unwind_Resume
| nlohmann::json_abi_v3_11_3::detail::exception * ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
nlohmann::json_abi_v3_11_3::detail::exception *this,
int a2,
long long *a3,
long long a4)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // r14
void *v12; // [rsp+0h] [rbp-D8h]
void *v13[2]; // [rsp+8h] [rbp-D0h] BYREF
_QWORD v14[2]; // [rsp+18h] [rbp-C0h] BYREF
void *v15; // [rsp+28h] [rbp-B0h] BYREF
long long v16; // [rsp+30h] [rbp-A8h]
_QWORD v17[2]; // [rsp+38h] [rbp-A0h] BYREF
int v18[4]; // [rsp+48h] [rbp-90h] BYREF
long long v19; // [rsp+58h] [rbp-80h] BYREF
int v20[4]; // [rsp+68h] [rbp-70h] BYREF
long long v21; // [rsp+78h] [rbp-60h] BYREF
char *v22; // [rsp+88h] [rbp-50h] BYREF
long long v23; // [rsp+98h] [rbp-40h] BYREF
v13[0] = v14;
std::string::_M_construct<char const*>(v13, "parse_error", "");
nlohmann::json_abi_v3_11_3::detail::exception::name((long long)v20, (long long)v13, a2);
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](
(int)v18,
(int)a3,
v6,
v7,
v8,
v9,
v12,
(int)v13[0],
(long long)v13[1],
v14[0],
(void *)v14[1],
(int)v15,
v16);
v15 = v17;
v16 = 0LL;
LOBYTE(v17[0]) = 0;
nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,char const(&)[12],std::string,char const(&)[3],std::string,std::string const&>(
(unsigned int)&v22,
(unsigned int)v20,
(unsigned int)"parse error",
(unsigned int)v18,
(unsigned int)": ",
(unsigned int)&v15,
a4);
if ( v15 != v17 )
operator delete(v15, v17[0] + 1LL);
if ( *(long long **)v18 != &v19 )
operator delete(*(void **)v18, v19 + 1);
if ( *(long long **)v20 != &v21 )
operator delete(*(void **)v20, v21 + 1);
if ( v13[0] != v14 )
operator delete(v13[0], v14[0] + 1LL);
v10 = *a3;
nlohmann::json_abi_v3_11_3::detail::exception::exception(this, a2, v22);
*(_QWORD *)this = off_ECF88;
*((_QWORD *)this + 4) = v10;
if ( v22 != (char *)&v23 )
operator delete(v22, v23 + 1);
return this;
}
| _ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R15,RCX
MOV R14,RDX
MOV EBP,ESI
MOV RBX,RDI
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
LAB_0012b480:
LEA RSI,[0x1b6f4c]
LEA RDX,[0x1b6f57]
LEA RDI,[RSP + 0x8]
CALL 0x00132ea4
LAB_0012b498:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x8]
MOV EDX,EBP
CALL 0x00129158
LAB_0012b4a9:
LEA RDI,[RSP + 0x48]
MOV RSI,R14
CALL 0x001317d4
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
MOV qword ptr [R13 + -0x8],0x0
MOV byte ptr [R13],0x0
LAB_0012b4cc:
MOV qword ptr [RSP],R15
LEA RDX,[0x1b6f58]
LEA R8,[0x1bb21a]
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x68]
LEA RCX,[RSP + 0x48]
LEA R9,[RSP + 0x28]
CALL 0x001316cb
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x0012b511
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001196b0
LAB_0012b511:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012b52c
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001196b0
LAB_0012b52c:
LEA RAX,[RSP + 0x78]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012b547
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x001196b0
LAB_0012b547:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x0012b55e
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001196b0
LAB_0012b55e:
MOV R14,qword ptr [R14]
MOV RDX,qword ptr [RSP + 0x88]
LAB_0012b569:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x001293c0
LAB_0012b573:
LEA RAX,[0x1ecf88]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x20],R14
LEA RAX,[RSP + 0x98]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012b5a2
MOV RSI,qword ptr [RSP + 0x98]
INC RSI
CALL 0x001196b0
LAB_0012b5a2:
MOV RAX,RBX
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
exception *
_ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(exception *param_1,int param_2,position_t *param_3,string *param_4)
{
int8 uVar1;
long *local_d0 [2];
long local_c0 [2];
int1 *local_b0;
int8 local_a8;
int1 local_a0;
int7 uStack_9f;
long *local_90 [2];
long local_80 [2];
long *local_70 [2];
long local_60 [2];
long *local_50 [2];
long local_40 [2];
/* try { // try from 0012b480 to 0012b497 has its CatchHandler @ 0012b64c */
local_d0[0] = local_c0;
std::__cxx11::string::_M_construct<char_const*>(local_d0,"parse_error","");
/* try { // try from 0012b498 to 0012b4a8 has its CatchHandler @ 0012b630 */
nlohmann::json_abi_v3_11_3::detail::exception::name
((exception *)local_70,(string *)local_d0,param_2);
/* try { // try from 0012b4a9 to 0012b4b5 has its CatchHandler @ 0012b610 */
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string_abi_cxx11_
((parse_error *)local_90,param_3);
local_a8 = 0;
local_a0 = 0;
/* try { // try from 0012b4cc to 0012b4f9 has its CatchHandler @ 0012b5d9 */
local_b0 = &local_a0;
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,std::__cxx11::string,char_const(&)[12],std::__cxx11::string,char_const(&)[3],std::__cxx11::string,std::__cxx11::string_const&>
((detail *)local_50,(string *)local_70,"parse error",(string *)local_90,": ",
(string *)&local_b0,param_4);
if (local_b0 != &local_a0) {
operator_delete(local_b0,CONCAT71(uStack_9f,local_a0) + 1);
}
if (local_90[0] != local_80) {
operator_delete(local_90[0],local_80[0] + 1);
}
if (local_70[0] != local_60) {
operator_delete(local_70[0],local_60[0] + 1);
}
if (local_d0[0] != local_c0) {
operator_delete(local_d0[0],local_c0[0] + 1);
}
uVar1 = *(int8 *)param_3;
/* try { // try from 0012b569 to 0012b572 has its CatchHandler @ 0012b5b7 */
nlohmann::json_abi_v3_11_3::detail::exception::exception(param_1,param_2,(char *)local_50[0]);
*(int ***)param_1 = &PTR__exception_001ecf88;
*(int8 *)(param_1 + 0x20) = uVar1;
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return param_1;
}
|
|
6,411 | JS_MakeError | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_MakeError(JSContext *ctx, JSErrorEnum error_num,
const char *message, BOOL add_backtrace)
{
JSValue obj, msg;
if (error_num == JS_PLAIN_ERROR) {
obj = JS_NewError(ctx);
} else {
obj = JS_NewObjectProtoClass(ctx, ctx->native_error_proto[error_num],
JS_CLASS_ERROR);
}
if (JS_IsException(obj))
return JS_EXCEPTION;
msg = JS_NewString(ctx, message);
if (JS_IsException(msg))
msg = JS_NewString(ctx, "Invalid error message");
if (!JS_IsException(msg)) {
JS_DefinePropertyValue(ctx, obj, JS_ATOM_message, msg,
JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
}
if (add_backtrace)
build_backtrace(ctx, obj, JS_UNDEFINED, NULL, 0, 0, 0);
return obj;
} | O2 | c | JS_MakeError:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %rbx
cmpl $0x8, %esi
jne 0x3ae48
movq %rbx, %rdi
callq 0x1c4b7
jmp 0x3ae69
movl %esi, %eax
shlq $0x4, %rax
movq 0x98(%rbx,%rax), %rsi
movq 0xa0(%rbx,%rax), %rdx
pushq $0x3
popq %rcx
movq %rbx, %rdi
callq 0x1b069
movq %rax, %r14
movq %rdx, %r15
cmpl $0x6, %r15d
jne 0x3ae7e
pushq $0x6
popq %r15
xorl %r14d, %r14d
jmp 0x3aeee
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2c8c0
movq %rdx, %r9
cmpl $0x6, %r9d
jne 0x3aeaa
leaq 0x4b7a9(%rip), %rsi # 0x86642
movq %rbx, %rdi
callq 0x2c8c0
movq %rdx, %r9
cmpl $0x6, %r9d
je 0x3aec5
movl $0x3, (%rsp)
pushq $0x33
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %r8
callq 0x20872
testl %ebp, %ebp
je 0x3aeee
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0x3
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x285b2
movq %r14, %rax
movq %r15, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| JS_MakeError:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov ebp, ecx
mov r12, rdx
mov rbx, rdi
cmp esi, 8
jnz short loc_3AE48
mov rdi, rbx
call JS_NewError
jmp short loc_3AE69
loc_3AE48:
mov eax, esi
shl rax, 4
mov rsi, [rbx+rax+98h]
mov rdx, [rbx+rax+0A0h]
push 3
pop rcx
mov rdi, rbx
call JS_NewObjectProtoClass
loc_3AE69:
mov r14, rax
mov r15, rdx
cmp r15d, 6
jnz short loc_3AE7E
push 6
pop r15
xor r14d, r14d
jmp short loc_3AEEE
loc_3AE7E:
mov rdi, rbx
mov rsi, r12
call JS_NewString_0
mov r9, rdx
cmp r9d, 6
jnz short loc_3AEAA
lea rsi, aInvalidErrorMe; "Invalid error message"
mov rdi, rbx
call JS_NewString_0
mov r9, rdx
cmp r9d, 6
jz short loc_3AEC5
loc_3AEAA:
mov [rsp+48h+var_48], 3
push 33h ; '3'
pop rcx
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov r8, rax
call JS_DefinePropertyValue
loc_3AEC5:
test ebp, ebp
jz short loc_3AEEE
and [rsp+48h+var_38], 0
and [rsp+48h+var_40], 0
and [rsp+48h+var_48], 0
push 3
pop r8
mov rdi, rbx
mov rsi, r14
mov rdx, r15
xor ecx, ecx
xor r9d, r9d
call build_backtrace
loc_3AEEE:
mov rax, r14
mov rdx, r15
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long JS_MakeError(
long long a1,
unsigned int a2,
char *a3,
int a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
long long v14; // rax
long long v15; // rdx
long long v16; // r14
long long v17; // r15
_DWORD *v18; // rax
__m128 v19; // xmm4
__m128 v20; // xmm5
long long v21; // rdx
long long v22; // r9
long long v23; // rdx
if ( a2 == 8 )
v14 = JS_NewError(a1);
else
v14 = JS_NewObjectProtoClass(a1, *(_QWORD *)(a1 + 16LL * a2 + 152), *(_QWORD *)(a1 + 16LL * a2 + 160), 3u);
v16 = v14;
v17 = v15;
if ( (_DWORD)v15 == 6 )
return 0LL;
v18 = (_DWORD *)JS_NewString_0(a1, a3);
v22 = v21;
if ( (_DWORD)v21 != 6 || (v18 = (_DWORD *)JS_NewString_0(a1, "Invalid error message"), v22 = v23, (_DWORD)v23 != 6) )
JS_DefinePropertyValue(a1, v16, v17, 51LL, v18, v22, *(double *)a5.m128_u64, a6, a7, a8, v19, v20, a11, a12, 3);
if ( a4 )
build_backtrace(
a1,
v16,
v17,
0LL,
3LL,
0LL,
a5,
a6,
a7,
a8,
*(double *)v19.m128_u64,
*(double *)v20.m128_u64,
a11,
a12,
0,
0,
0);
return v16;
}
| JS_MakeError:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV EBP,ECX
MOV R12,RDX
MOV RBX,RDI
CMP ESI,0x8
JNZ 0x0013ae48
MOV RDI,RBX
CALL 0x0011c4b7
JMP 0x0013ae69
LAB_0013ae48:
MOV EAX,ESI
SHL RAX,0x4
MOV RSI,qword ptr [RBX + RAX*0x1 + 0x98]
MOV RDX,qword ptr [RBX + RAX*0x1 + 0xa0]
PUSH 0x3
POP RCX
MOV RDI,RBX
CALL 0x0011b069
LAB_0013ae69:
MOV R14,RAX
MOV R15,RDX
CMP R15D,0x6
JNZ 0x0013ae7e
PUSH 0x6
POP R15
XOR R14D,R14D
JMP 0x0013aeee
LAB_0013ae7e:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0012c8c0
MOV R9,RDX
CMP R9D,0x6
JNZ 0x0013aeaa
LEA RSI,[0x186642]
MOV RDI,RBX
CALL 0x0012c8c0
MOV R9,RDX
CMP R9D,0x6
JZ 0x0013aec5
LAB_0013aeaa:
MOV dword ptr [RSP],0x3
PUSH 0x33
POP RCX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV R8,RAX
CALL 0x00120872
LAB_0013aec5:
TEST EBP,EBP
JZ 0x0013aeee
AND dword ptr [RSP + 0x10],0x0
AND dword ptr [RSP + 0x8],0x0
AND dword ptr [RSP],0x0
PUSH 0x3
POP R8
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
XOR ECX,ECX
XOR R9D,R9D
CALL 0x001285b2
LAB_0013aeee:
MOV RAX,R14
MOV RDX,R15
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int1 [16] JS_MakeError(long param_1,uint param_2,int8 param_3,int param_4)
{
int1 auVar1 [16];
int1 auVar2 [16];
if (param_2 == 8) {
auVar1 = JS_NewError(param_1);
}
else {
auVar1 = JS_NewObjectProtoClass
(param_1,*(int8 *)(param_1 + 0x98 + (ulong)param_2 * 0x10),
*(int8 *)(param_1 + 0xa0 + (ulong)param_2 * 0x10),3);
}
if (auVar1._8_4_ != 6) {
auVar2 = JS_NewString(param_1,param_3);
if ((auVar2._8_4_ != 6) ||
(auVar2 = JS_NewString(param_1,"Invalid error message"), auVar2._8_4_ != 6)) {
JS_DefinePropertyValue(param_1,auVar1._0_8_,auVar1._8_8_,0x33,auVar2._0_8_,auVar2._8_8_,3);
}
if (param_4 != 0) {
build_backtrace(param_1,auVar1._0_8_,auVar1._8_8_,0,3,0,0,0,0);
}
return auVar1;
}
return ZEXT816(6) << 0x40;
}
|
|
6,412 | stbi__setup_jpeg(stbi__jpeg*) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static void stbi__setup_jpeg(stbi__jpeg *j)
{
j->idct_block_kernel = stbi__idct_block;
j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
#ifdef STBI_SSE2
if (stbi__sse2_available()) {
j->idct_block_kernel = stbi__idct_simd;
j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
}
#endif
#ifdef STBI_NEON
j->idct_block_kernel = stbi__idct_simd;
j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
#endif
} | O0 | c | stbi__setup_jpeg(stbi__jpeg*):
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
leaq 0x200(%rip), %rcx # 0x1f030
movq %rcx, 0x4870(%rax)
movq (%rsp), %rax
leaq 0x9ce(%rip), %rcx # 0x1f810
movq %rcx, 0x4878(%rax)
movq (%rsp), %rax
leaq 0xb6c(%rip), %rcx # 0x1f9c0
movq %rcx, 0x4880(%rax)
callq 0x1fb10
cmpl $0x0, %eax
je 0x1ee9b
movq (%rsp), %rax
leaq 0xcb0(%rip), %rcx # 0x1fb20
movq %rcx, 0x4870(%rax)
movq (%rsp), %rax
leaq 0x523e(%rip), %rcx # 0x240c0
movq %rcx, 0x4878(%rax)
movq (%rsp), %rax
leaq 0x628c(%rip), %rcx # 0x25120
movq %rcx, 0x4880(%rax)
popq %rax
retq
nopl (%rax)
| _ZL16stbi__setup_jpegP10stbi__jpeg:
push rax
mov [rsp+8+var_8], rdi
mov rax, [rsp+8+var_8]
lea rcx, _ZL16stbi__idct_blockPhiPs; stbi__idct_block(uchar *,int,short *)
mov [rax+4870h], rcx
mov rax, [rsp+8+var_8]
lea rcx, _ZL22stbi__YCbCr_to_RGB_rowPhPKhS1_S1_ii; stbi__YCbCr_to_RGB_row(uchar *,uchar const*,uchar const*,uchar const*,int,int)
mov [rax+4878h], rcx
mov rax, [rsp+8+var_8]
lea rcx, _ZL23stbi__resample_row_hv_2PhS_S_ii; stbi__resample_row_hv_2(uchar *,uchar *,uchar *,int,int)
mov [rax+4880h], rcx
call _ZL20stbi__sse2_availablev; stbi__sse2_available(void)
cmp eax, 0
jz short loc_1EE9B
mov rax, [rsp+8+var_8]
lea rcx, _ZL15stbi__idct_simdPhiPs; stbi__idct_simd(uchar *,int,short *)
mov [rax+4870h], rcx
mov rax, [rsp+8+var_8]
lea rcx, _ZL23stbi__YCbCr_to_RGB_simdPhPKhS1_S1_ii; stbi__YCbCr_to_RGB_simd(uchar *,uchar const*,uchar const*,uchar const*,int,int)
mov [rax+4878h], rcx
mov rax, [rsp+8+var_8]
lea rcx, _ZL28stbi__resample_row_hv_2_simdPhS_S_ii; stbi__resample_row_hv_2_simd(uchar *,uchar *,uchar *,int,int)
mov [rax+4880h], rcx
loc_1EE9B:
pop rax
retn
| _QWORD * stbi__setup_jpeg(_QWORD *a1)
{
a1[2318] = stbi__idct_block;
a1[2319] = stbi__YCbCr_to_RGB_row;
a1[2320] = stbi__resample_row_hv_2;
if ( (unsigned int)stbi__sse2_available() )
{
a1[2318] = stbi__idct_simd;
a1[2319] = stbi__YCbCr_to_RGB_simd;
a1[2320] = stbi__resample_row_hv_2_simd;
}
return a1;
}
| stbi__setup_jpeg:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RAX,qword ptr [RSP]
LEA RCX,[0x11f030]
MOV qword ptr [RAX + 0x4870],RCX
MOV RAX,qword ptr [RSP]
LEA RCX,[0x11f810]
MOV qword ptr [RAX + 0x4878],RCX
MOV RAX,qword ptr [RSP]
LEA RCX,[0x11f9c0]
MOV qword ptr [RAX + 0x4880],RCX
CALL 0x0011fb10
CMP EAX,0x0
JZ 0x0011ee9b
MOV RAX,qword ptr [RSP]
LEA RCX,[0x11fb20]
MOV qword ptr [RAX + 0x4870],RCX
MOV RAX,qword ptr [RSP]
LEA RCX,[0x1240c0]
MOV qword ptr [RAX + 0x4878],RCX
MOV RAX,qword ptr [RSP]
LEA RCX,[0x125120]
MOV qword ptr [RAX + 0x4880],RCX
LAB_0011ee9b:
POP RAX
RET
|
/* stbi__setup_jpeg(stbi__jpeg*) */
stbi__jpeg * stbi__setup_jpeg(stbi__jpeg *param_1)
{
int iVar1;
*(code **)(param_1 + 0x4870) = stbi__idct_block;
*(code **)(param_1 + 0x4878) = stbi__YCbCr_to_RGB_row;
*(code **)(param_1 + 0x4880) = stbi__resample_row_hv_2;
iVar1 = stbi__sse2_available();
if (iVar1 != 0) {
*(code **)(param_1 + 0x4870) = stbi__idct_simd;
*(code **)(param_1 + 0x4878) = stbi__YCbCr_to_RGB_simd;
*(code **)(param_1 + 0x4880) = stbi__resample_row_hv_2_simd;
}
return param_1;
}
|
|
6,413 | glfwSetTime | untodesu[P]riteg/build_O3/_deps/glfw-src/src/input.c | GLFWAPI void glfwSetTime(double time)
{
_GLFW_REQUIRE_INIT();
if (time != time || time < 0.0 || time > 18446744073.0)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", time);
return;
}
_glfw.timer.offset = _glfwPlatformGetTimerValue() -
(uint64_t) (time * _glfwPlatformGetTimerFrequency());
} | O3 | c | glfwSetTime:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8cdfc(%rip), %r14 # 0xa8638
cmpl $0x0, (%r14)
je 0x1b8c7
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1b8dc
ucomisd 0x6735c(%rip), %xmm0 # 0x82bb8
ja 0x1b8dc
movsd %xmm0, (%rsp)
callq 0x25e51
movq %rax, %rbx
callq 0x25e9d
movq %rax, %xmm0
punpckldq 0x67413(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x6741b(%rip), %xmm0 # 0x82ca0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd (%rsp), %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x67316(%rip), %xmm1 # 0x82bc0
cvttsd2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
subq %rdx, %rbx
movq %rbx, 0x1fe58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18e91
leaq 0x67b28(%rip), %rsi # 0x8340b
movl $0x10004, %edi # imm = 0x10004
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18e91
| glfwSetTime:
push r14
push rbx
push rax
lea r14, _glfw
cmp dword ptr [r14], 0
jz loc_1B8C7
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jb loc_1B8DC
ucomisd xmm0, cs:qword_82BB8
ja short loc_1B8DC
movsd [rsp+18h+var_18], xmm0
call _glfwPlatformGetTimerValue
mov rbx, rax
call _glfwPlatformGetTimerFrequency
movq xmm0, rax
punpckldq xmm0, cs:xmmword_82C90
subpd xmm0, cs:xmmword_82CA0
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
mulsd xmm1, [rsp+18h+var_18]
cvttsd2si rax, xmm1
mov rcx, rax
sar rcx, 3Fh
subsd xmm1, cs:qword_82BC0
cvttsd2si rdx, xmm1
and rdx, rcx
or rdx, rax
sub rbx, rdx
mov [r14+1FE58h], rbx
add rsp, 8
pop rbx
pop r14
retn
loc_1B8C7:
mov edi, offset loc_10001
xor esi, esi
xor eax, eax
add rsp, 8
pop rbx
pop r14
jmp _glfwInputError
loc_1B8DC:
lea rsi, aInvalidTimeF; "Invalid time %f"
mov edi, 10004h
mov al, 1
add rsp, 8
pop rbx
pop r14
jmp _glfwInputError
| unsigned long long glfwSetTime(long long a1, double a2)
{
long long TimerValue; // rbx
__m128d v3; // xmm0
unsigned long long result; // rax
if ( !glfw[0] )
return (unsigned long long)glfwInputError((unsigned int)&loc_10001, 0LL);
if ( a2 < 0.0 || a2 > 1.8446744073e10 )
return (unsigned long long)glfwInputError(0x10004u, (long long)"Invalid time %f", a2);
TimerValue = glfwPlatformGetTimerValue(a1);
v3 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32((__m128i)(unsigned long long)glfwPlatformGetTimerFrequency(), (__m128i)xmmword_82C90),
(__m128d)xmmword_82CA0);
result = (unsigned int)(int)((_mm_unpackhi_pd(v3, v3).m128d_f64[0] + v3.m128d_f64[0]) * a2);
*(_QWORD *)&glfw[32662] = TimerValue - result;
return result;
}
| glfwSetTime:
PUSH R14
PUSH RBX
PUSH RAX
LEA R14,[0x1a8638]
CMP dword ptr [R14],0x0
JZ 0x0011b8c7
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JC 0x0011b8dc
UCOMISD XMM0,qword ptr [0x00182bb8]
JA 0x0011b8dc
MOVSD qword ptr [RSP],XMM0
CALL 0x00125e51
MOV RBX,RAX
CALL 0x00125e9d
MOVQ XMM0,RAX
PUNPCKLDQ XMM0,xmmword ptr [0x00182c90]
SUBPD XMM0,xmmword ptr [0x00182ca0]
MOVAPD XMM1,XMM0
UNPCKHPD XMM1,XMM0
ADDSD XMM1,XMM0
MULSD XMM1,qword ptr [RSP]
CVTTSD2SI RAX,XMM1
MOV RCX,RAX
SAR RCX,0x3f
SUBSD XMM1,qword ptr [0x00182bc0]
CVTTSD2SI RDX,XMM1
AND RDX,RCX
OR RDX,RAX
SUB RBX,RDX
MOV qword ptr [R14 + 0x1fe58],RBX
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0011b8c7:
MOV EDI,0x10001
XOR ESI,ESI
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00118e91
LAB_0011b8dc:
LEA RSI,[0x18340b]
MOV EDI,0x10004
MOV AL,0x1
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00118e91
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void glfwSetTime(double param_1)
{
long lVar1;
int8 uVar2;
ulong uVar3;
int1 auVar4 [16];
if (_glfw == 0) {
_glfwInputError(0x10001,0);
return;
}
if ((0.0 <= param_1) && (param_1 <= _DAT_00182bb8)) {
lVar1 = _glfwPlatformGetTimerValue();
uVar2 = _glfwPlatformGetTimerFrequency();
auVar4._8_4_ = (int)((ulong)uVar2 >> 0x20);
auVar4._0_8_ = uVar2;
auVar4._12_4_ = DAT_00182c90._4_4_;
param_1 = ((auVar4._8_8_ - _UNK_00182ca8) +
((double)CONCAT44((int4)DAT_00182c90,(int)uVar2) - _DAT_00182ca0)) * param_1;
uVar3 = (ulong)param_1;
DAT_001c8490 = lVar1 - ((long)(param_1 - DAT_00182bc0) & (long)uVar3 >> 0x3f | uVar3);
return;
}
_glfwInputError(0x10004,"Invalid time %f");
return;
}
|
|
6,414 | nglog::VLOG2Initializer() | ng-log[P]ng-log/src/vlog_is_on.cc | static void VLOG2Initializer() {
// Can now parse --vmodule flag and initialize mapping of module-specific
// logging levels.
inited_vmodule = false;
const char* vmodule = FLAGS_vmodule.c_str();
const char* sep;
VModuleInfo* head = nullptr;
VModuleInfo* tail = nullptr;
while ((sep = strchr(vmodule, '=')) != nullptr) {
string pattern(vmodule, static_cast<size_t>(sep - vmodule));
int module_level;
if (sscanf(sep, "=%d", &module_level) == 1) {
auto* info = new VModuleInfo;
info->module_pattern = pattern;
info->vlog_level = module_level;
if (head) {
tail->next = info;
} else {
head = info;
}
tail = info;
}
// Skip past this entry
vmodule = strchr(sep, ',');
if (vmodule == nullptr) break;
vmodule++; // Skip past ","
}
if (head) { // Put them into the list at the head:
tail->next = vmodule_list;
vmodule_list = head;
}
inited_vmodule = true;
} | O0 | cpp | nglog::VLOG2Initializer():
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb $0x0, 0x344a6(%rip) # 0x81d18
leaq 0x22d1f(%rip), %rax # 0x70598
movq (%rax), %rdi
callq 0x92c0
movq %rax, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3d, %esi
callq 0x9250
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x4d9fa
movq -0x8(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x9d20
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x9850
jmp 0x4d8e8
leaq -0x41(%rbp), %rdi
callq 0x97c0
movq -0x10(%rbp), %rdi
leaq 0x2a6c(%rip), %rsi # 0x50368
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x96c0
cmpl $0x1, %eax
jne 0x4d9ac
movl $0x30, %edi
callq 0x9720
movq %rax, -0x88(%rbp)
jmp 0x4d923
movq -0x88(%rbp), %rdi
callq 0x4dad0
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9070
jmp 0x4d949
movl -0x58(%rbp), %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x20(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x4d99c
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x4d9a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x97c0
jmp 0x4da2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9eb8
jmp 0x4da2b
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x9250
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4d9ce
movl $0x3, -0x64(%rbp)
jmp 0x4d9e1
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9eb8
movl -0x64(%rbp), %eax
testl %eax, %eax
je 0x4d9f5
jmp 0x4d9f3
jmp 0x4d9fa
jmp 0x4d895
cmpq $0x0, -0x18(%rbp)
je 0x4da1b
movq 0x342e0(%rip), %rcx # 0x81ce8
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x342cd(%rip) # 0x81ce8
movb $0x1, 0x342f6(%rip) # 0x81d18
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x9d10
nopw %cs:(%rax,%rax)
| _ZN5nglogL16VLOG2InitializerEv:
push rbp
mov rbp, rsp
sub rsp, 90h
mov cs:_ZN5nglogL14inited_vmoduleE, 0; nglog::inited_vmodule
lea rax, _ZN3fLS13FLAGS_vmoduleB5cxx11E; fLS::FLAGS_vmodule
mov rdi, [rax]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov [rbp+var_8], rax
mov [rbp+var_18], 0
mov [rbp+var_20], 0
loc_4D895:
mov rdi, [rbp+var_8]
mov esi, 3Dh ; '='
call _strchr
mov [rbp+var_10], rax
cmp rax, 0
jz loc_4D9FA
mov rcx, [rbp+var_8]
mov [rbp+var_80], rcx
mov rax, [rbp+var_10]
sub rax, rcx
mov [rbp+var_78], rax
lea rdi, [rbp+var_41]
mov [rbp+var_70], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_78]
mov rcx, [rbp+var_70]
lea rdi, [rbp+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcmRKS3_; std::string::basic_string(char const*,ulong,std::allocator<char> const&)
jmp short $+2
loc_4D8E8:
lea rdi, [rbp+var_41]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rdi, [rbp+var_10]
lea rsi, aD_0; "=%d"
lea rdx, [rbp+var_58]
mov al, 0
call ___isoc99_sscanf
cmp eax, 1
jnz loc_4D9AC
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov [rbp+var_88], rax
jmp short $+2
loc_4D923:
mov rdi, [rbp+var_88]; this
call _ZN5nglog11VModuleInfoC2Ev; nglog::VModuleInfo::VModuleInfo(void)
mov rax, [rbp+var_88]
mov [rbp+var_60], rax
mov rdi, [rbp+var_60]
lea rsi, [rbp+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSERKS4_; std::string::operator=(std::string const&)
jmp short $+2
loc_4D949:
mov ecx, [rbp+var_58]
mov rax, [rbp+var_60]
mov [rax+20h], ecx
cmp [rbp+var_18], 0
jz short loc_4D99C
mov rcx, [rbp+var_60]
mov rax, [rbp+var_20]
mov [rax+28h], rcx
jmp short loc_4D9A4
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
lea rdi, [rbp+var_41]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_4DA2B
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
lea rdi, [rbp+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_4DA2B
loc_4D99C:
mov rax, [rbp+var_60]
mov [rbp+var_18], rax
loc_4D9A4:
mov rax, [rbp+var_60]
mov [rbp+var_20], rax
loc_4D9AC:
mov rdi, [rbp+var_10]
mov esi, 2Ch ; ','
call _strchr
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_4D9CE
mov [rbp+var_64], 3
jmp short loc_4D9E1
loc_4D9CE:
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
mov [rbp+var_64], 0
loc_4D9E1:
lea rdi, [rbp+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov eax, [rbp+var_64]
test eax, eax
jz short loc_4D9F5
jmp short $+2
loc_4D9F3:
jmp short loc_4D9FA
loc_4D9F5:
jmp loc_4D895
loc_4D9FA:
cmp [rbp+var_18], 0
jz short loc_4DA1B
mov rcx, cs:_ZN5nglogL12vmodule_listE; nglog::vmodule_list
mov rax, [rbp+var_20]
mov [rax+28h], rcx
mov rax, [rbp+var_18]
mov cs:_ZN5nglogL12vmodule_listE, rax; nglog::vmodule_list
loc_4DA1B:
mov cs:_ZN5nglogL14inited_vmoduleE, 1; nglog::inited_vmodule
add rsp, 90h
pop rbp
retn
loc_4DA2B:
mov rdi, [rbp+var_50]
call __Unwind_Resume
| long long nglog::VLOG2Initializer(nglog *this)
{
long long result; // rax
nglog::VModuleInfo *v2; // [rsp+8h] [rbp-88h]
long long v3; // [rsp+10h] [rbp-80h]
long long v4; // [rsp+18h] [rbp-78h]
unsigned int v5; // [rsp+2Ch] [rbp-64h]
int v6; // [rsp+38h] [rbp-58h] BYREF
char v7; // [rsp+4Fh] [rbp-41h] BYREF
_BYTE v8[32]; // [rsp+50h] [rbp-40h] BYREF
nglog::VModuleInfo *v9; // [rsp+70h] [rbp-20h]
long long v10; // [rsp+78h] [rbp-18h]
long long v11; // [rsp+80h] [rbp-10h]
long long v12; // [rsp+88h] [rbp-8h]
nglog::inited_vmodule = 0;
v12 = std::string::c_str(&fLS::FLAGS_vmodule_buf[abi:cxx11]);
v10 = 0LL;
v9 = 0LL;
do
{
result = strchr(v12, 61LL);
v11 = result;
if ( !result )
break;
v3 = v12;
v4 = v11 - v12;
std::allocator<char>::allocator();
std::string::basic_string(v8, v3, v4, &v7);
std::allocator<char>::~allocator(&v7);
if ( (unsigned int)__isoc99_sscanf(v11, "=%d", &v6) == 1 )
{
v2 = (nglog::VModuleInfo *)operator new(0x30uLL);
nglog::VModuleInfo::VModuleInfo(v2);
std::string::operator=(v2, v8);
*((_DWORD *)v2 + 8) = v6;
if ( v10 )
*((_QWORD *)v9 + 5) = v2;
else
v10 = (long long)v2;
v9 = v2;
}
v12 = strchr(v11, 44LL);
if ( v12 )
{
++v12;
v5 = 0;
}
else
{
v5 = 3;
}
std::string::~string(v8);
result = v5;
}
while ( !v5 );
if ( v10 )
{
*((_QWORD *)v9 + 5) = nglog::vmodule_list;
result = v10;
nglog::vmodule_list = v10;
}
nglog::inited_vmodule = 1;
return result;
}
| VLOG2Initializer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV byte ptr [0x00181d18],0x0
LEA RAX,[0x170598]
MOV RDI,qword ptr [RAX]
CALL 0x001092c0
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],0x0
MOV qword ptr [RBP + -0x20],0x0
LAB_0014d895:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x3d
CALL 0x00109250
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x0014d9fa
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x80],RCX
MOV RAX,qword ptr [RBP + -0x10]
SUB RAX,RCX
MOV qword ptr [RBP + -0x78],RAX
LEA RDI,[RBP + -0x41]
MOV qword ptr [RBP + -0x70],RDI
CALL 0x00109d20
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x70]
LAB_0014d8dd:
LEA RDI,[RBP + -0x40]
CALL 0x00109850
JMP 0x0014d8e8
LAB_0014d8e8:
LEA RDI,[RBP + -0x41]
CALL 0x001097c0
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x150368]
LEA RDX,[RBP + -0x58]
MOV AL,0x0
CALL 0x001096c0
CMP EAX,0x1
JNZ 0x0014d9ac
LAB_0014d910:
MOV EDI,0x30
CALL 0x00109720
MOV qword ptr [RBP + -0x88],RAX
JMP 0x0014d923
LAB_0014d923:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x0014dad0
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x60]
LEA RSI,[RBP + -0x40]
CALL 0x00109070
LAB_0014d947:
JMP 0x0014d949
LAB_0014d949:
MOV ECX,dword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX + 0x20],ECX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0014d99c
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x28],RCX
JMP 0x0014d9a4
LAB_0014d99c:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x18],RAX
LAB_0014d9a4:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x20],RAX
LAB_0014d9ac:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x2c
CALL 0x00109250
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0014d9ce
MOV dword ptr [RBP + -0x64],0x3
JMP 0x0014d9e1
LAB_0014d9ce:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x64],0x0
LAB_0014d9e1:
LEA RDI,[RBP + -0x40]
CALL 0x00109eb8
MOV EAX,dword ptr [RBP + -0x64]
TEST EAX,EAX
JZ 0x0014d9f5
JMP 0x0014d9f3
LAB_0014d9f3:
JMP 0x0014d9fa
LAB_0014d9f5:
JMP 0x0014d895
LAB_0014d9fa:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0014da1b
MOV RCX,qword ptr [0x00181ce8]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [0x00181ce8],RAX
LAB_0014da1b:
MOV byte ptr [0x00181d18],0x1
ADD RSP,0x90
POP RBP
RET
|
/* nglog::VLOG2Initializer() */
void nglog::VLOG2Initializer(void)
{
char *pcVar1;
VModuleInfo *pVVar2;
int iVar3;
ulong uVar4;
VModuleInfo *this;
int local_6c;
int4 local_60 [5];
allocator local_49;
string local_48 [32];
VModuleInfo *local_28;
VModuleInfo *local_20;
char *local_18;
char *local_10;
inited_vmodule = 0;
local_10 = (char *)std::__cxx11::string::c_str();
local_20 = (VModuleInfo *)0x0;
local_28 = (VModuleInfo *)0x0;
do {
local_18 = strchr(local_10,0x3d);
pcVar1 = local_10;
if (local_18 == (char *)0x0) break;
uVar4 = (long)local_18 - (long)local_10;
std::allocator<char>::allocator();
/* try { // try from 0014d8dd to 0014d8e5 has its CatchHandler @ 0014d968 */
std::__cxx11::string::string(local_48,pcVar1,uVar4,&local_49);
std::allocator<char>::~allocator((allocator<char> *)&local_49);
iVar3 = __isoc99_sscanf(local_18,&DAT_00150368,local_60);
this = local_28;
pVVar2 = local_20;
if (iVar3 == 1) {
/* try { // try from 0014d910 to 0014d946 has its CatchHandler @ 0014d982 */
this = (VModuleInfo *)operator_new(0x30);
VModuleInfo::VModuleInfo(this);
std::__cxx11::string::operator=((string *)this,local_48);
*(int4 *)(this + 0x20) = local_60[0];
pVVar2 = this;
if (local_20 != (VModuleInfo *)0x0) {
*(VModuleInfo **)(local_28 + 0x28) = this;
pVVar2 = local_20;
}
}
local_20 = pVVar2;
local_28 = this;
local_10 = strchr(local_18,0x2c);
if (local_10 == (char *)0x0) {
local_6c = 3;
local_10 = (char *)0x0;
}
else {
local_10 = local_10 + 1;
local_6c = 0;
}
std::__cxx11::string::~string(local_48);
} while (local_6c == 0);
if (local_20 != (VModuleInfo *)0x0) {
*(VModuleInfo **)(local_28 + 0x28) = vmodule_list;
vmodule_list = local_20;
}
inited_vmodule = 1;
return;
}
|
|
6,415 | my_xml_parse | eloqsql/strings/xml.c | int my_xml_parse(MY_XML_PARSER *p,const char *str, size_t len)
{
my_xml_attr_rewind(p);
p->beg=str;
p->cur=str;
p->end=str+len;
while ( p->cur < p->end )
{
MY_XML_ATTR a;
if (p->cur[0] == '<')
{
int lex;
int question=0;
int exclam=0;
lex=my_xml_scan(p,&a);
if (MY_XML_COMMENT == lex)
continue;
if (lex == MY_XML_CDATA)
{
a.beg+= 9;
a.end-= 3;
my_xml_value(p, a.beg, (size_t) (a.end-a.beg));
continue;
}
lex=my_xml_scan(p,&a);
if (MY_XML_SLASH == lex)
{
if (MY_XML_IDENT != (lex=my_xml_scan(p,&a)))
{
sprintf(p->errstr,"%s unexpected (ident wanted)",lex2str(lex));
return MY_XML_ERROR;
}
if (MY_XML_OK != my_xml_leave(p,a.beg,(size_t) (a.end-a.beg)))
return MY_XML_ERROR;
lex=my_xml_scan(p,&a);
goto gt;
}
if (MY_XML_EXCLAM == lex)
{
lex=my_xml_scan(p,&a);
exclam=1;
}
else if (MY_XML_QUESTION == lex)
{
lex=my_xml_scan(p,&a);
question=1;
}
if (MY_XML_IDENT == lex)
{
p->current_node_type= MY_XML_NODE_TAG;
if (MY_XML_OK != my_xml_enter(p,a.beg,(size_t) (a.end-a.beg)))
return MY_XML_ERROR;
}
else
{
sprintf(p->errstr,"%s unexpected (ident or '/' wanted)",
lex2str(lex));
return MY_XML_ERROR;
}
while ((MY_XML_IDENT == (lex=my_xml_scan(p,&a))) ||
((MY_XML_STRING == lex && exclam)))
{
MY_XML_ATTR b;
if (MY_XML_EQ == (lex=my_xml_scan(p,&b)))
{
lex=my_xml_scan(p,&b);
if ( (lex == MY_XML_IDENT) || (lex == MY_XML_STRING) )
{
p->current_node_type= MY_XML_NODE_ATTR;
if ((MY_XML_OK != my_xml_enter(p,a.beg,(size_t) (a.end-a.beg))) ||
(MY_XML_OK != my_xml_value(p,b.beg,(size_t) (b.end-b.beg))) ||
(MY_XML_OK != my_xml_leave(p,a.beg,(size_t) (a.end-a.beg))))
return MY_XML_ERROR;
}
else
{
sprintf(p->errstr,"%s unexpected (ident or string wanted)",
lex2str(lex));
return MY_XML_ERROR;
}
}
else if (MY_XML_IDENT == lex)
{
p->current_node_type= MY_XML_NODE_ATTR;
if ((MY_XML_OK != my_xml_enter(p,a.beg,(size_t) (a.end-a.beg))) ||
(MY_XML_OK != my_xml_leave(p,a.beg,(size_t) (a.end-a.beg))))
return MY_XML_ERROR;
}
else if ((MY_XML_STRING == lex) && exclam)
{
/*
We are in <!DOCTYPE>, e.g.
<!DOCTYPE name SYSTEM "SystemLiteral">
<!DOCTYPE name PUBLIC "PublidLiteral" "SystemLiteral">
Just skip "SystemLiteral" and "PublicidLiteral"
*/
}
else
break;
}
if (lex == MY_XML_SLASH)
{
if (MY_XML_OK != my_xml_leave(p,NULL,0))
return MY_XML_ERROR;
lex=my_xml_scan(p,&a);
}
gt:
if (question)
{
if (lex != MY_XML_QUESTION)
{
sprintf(p->errstr,"%s unexpected ('?' wanted)",lex2str(lex));
return MY_XML_ERROR;
}
if (MY_XML_OK != my_xml_leave(p,NULL,0))
return MY_XML_ERROR;
lex=my_xml_scan(p,&a);
}
if (exclam)
{
if (MY_XML_OK != my_xml_leave(p,NULL,0))
return MY_XML_ERROR;
}
if (lex != MY_XML_GT)
{
sprintf(p->errstr,"%s unexpected ('>' wanted)",lex2str(lex));
return MY_XML_ERROR;
}
}
else
{
a.beg=p->cur;
for ( ; (p->cur < p->end) && (p->cur[0] != '<') ; p->cur++);
a.end=p->cur;
if (!(p->flags & MY_XML_FLAG_SKIP_TEXT_NORMALIZATION))
my_xml_norm_text(&a);
if (a.beg != a.end)
{
my_xml_value(p,a.beg,(size_t) (a.end-a.beg));
}
}
}
if (p->attr.start[0])
{
sprintf(p->errstr,"unexpected END-OF-INPUT");
return MY_XML_ERROR;
}
return MY_XML_OK;
} | O3 | c | my_xml_parse:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x118(%rdi), %rcx
movq %rcx, 0x120(%rdi)
movq %rsi, 0x128(%rdi)
movq %rsi, 0x130(%rdi)
leaq (%rsi,%rdx), %rax
movq %rax, 0x138(%rdi)
testq %rdx, %rdx
jle 0x8fb7d
leaq -0x40(%rbp), %r15
cmpb $0x3c, (%rsi)
jne 0x8f8bf
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8fc47
cmpl $0x43, %eax
je 0x8fb5f
cmpl $0x44, %eax
jne 0x8f924
movq 0x150(%rbx), %rax
testq %rax, %rax
je 0x8fb5f
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x9, %rsi
subq %rsi, %rdx
addq $-0x3, %rdx
jmp 0x8f91a
movq %rsi, -0x40(%rbp)
movq %rsi, %rdx
cmpq %rax, %rsi
jae 0x8f8e5
subq %rsi, %rax
movq %rsi, %rdx
cmpb $0x3c, (%rdx)
je 0x8f8e5
incq %rdx
movq %rdx, 0x130(%rbx)
decq %rax
jne 0x8f8d1
movq %rdx, -0x38(%rbp)
testb $0x2, (%rbx)
jne 0x8f8fe
movq %r15, %rdi
callq 0x9027f
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
cmpq %rdx, %rsi
je 0x8fb5f
movq 0x150(%rbx), %rax
testq %rax, %rax
je 0x8fb5f
subq %rsi, %rdx
movq %rbx, %rdi
callq *%rax
jmp 0x8fb5f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8fc47
cmpl $0x2f, %eax
jne 0x8f976
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8fc47
cmpl $0x49, %eax
jne 0x8fbdd
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x8ff45
testl %eax, %eax
jne 0x8fc2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8fc47
movl %eax, %r13d
jmp 0x8fb59
movl %eax, %r14d
cmpl $0x21, %eax
sete %r12b
cmpl $0x3f, %eax
je 0x8f98b
cmpl $0x21, %r14d
jne 0x8f998
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8fc47
jmp 0x8f99e
movb $0x1, %r12b
movl %r14d, %eax
cmpl $0x49, %eax
jne 0x8fbc9
movl $0x0, 0x4(%rbx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x90108
testl %eax, %eax
jne 0x8fc2f
movb %r12b, -0x29(%rbp)
movl %r14d, %r12d
xorl $0x21, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8fc47
movl %eax, %r13d
xorl $0x53, %eax
orl %r12d, %eax
sete %al
cmpl $0x49, %r13d
je 0x8f9f9
testb %al, %al
je 0x8fae2
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x8fc47
cmpl $0x49, %eax
je 0x8fa87
movl %eax, %r13d
cmpl $0x3d, %eax
jne 0x8fac6
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x8fc47
cmpl $0x53, %eax
je 0x8fa30
cmpl $0x49, %eax
jne 0x8fbf1
movl $0x1, 0x4(%rbx)
movq -0x40(%rbp), %r13
movq -0x38(%rbp), %r15
subq %r13, %r15
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x90108
testl %eax, %eax
jne 0x8fc2f
movq 0x150(%rbx), %rax
testq %rax, %rax
je 0x8fa7c
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
jne 0x8fc2f
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
jmp 0x8fab8
movl $0x1, 0x4(%rbx)
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r13
subq %r15, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x90108
testl %eax, %eax
jne 0x8fc2f
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x8ff45
testl %eax, %eax
je 0x8fad2
jmp 0x8fc2f
cmpl $0x21, %r14d
jne 0x8fade
cmpl $0x53, %r13d
jne 0x8fade
movq %rbx, %rdi
leaq -0x40(%rbp), %r15
jmp 0x8f9d7
leaq -0x40(%rbp), %r15
cmpl $0x2f, %r13d
movb -0x29(%rbp), %r12b
jne 0x8fb0e
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8ff45
testl %eax, %eax
jne 0x8fc2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8fc47
movl %eax, %r13d
testb %r12b, %r12b
jne 0x8fb3f
cmpl $0x3f, %r13d
jne 0x8fc05
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8ff45
testl %eax, %eax
jne 0x8fc2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8fc47
movl %eax, %r13d
cmpl $0x21, %r14d
jne 0x8fb59
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8ff45
testl %eax, %eax
jne 0x8fc2f
cmpl $0x3e, %r13d
jne 0x8fbb4
movq 0x130(%rbx), %rsi
movq 0x138(%rbx), %rax
cmpq %rax, %rsi
jb 0x8f878
movq 0x118(%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x8fbac
addq $0x8, %rbx
leaq 0x76e7(%rip), %rcx # 0x97274
movl $0x1, %r14d
movl $0x80, %edx
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x28210
jmp 0x8fc35
xorl %r14d, %r14d
jmp 0x8fc35
addq $0x8, %rbx
movl %r13d, %edi
callq 0x8feaa
leaq 0x7692(%rip), %rcx # 0x97259
jmp 0x8fc18
addq $0x8, %rbx
movl %eax, %edi
callq 0x8feaa
leaq 0x7618(%rip), %rcx # 0x971f3
jmp 0x8fc18
addq $0x8, %rbx
movl %eax, %edi
callq 0x8feaa
leaq 0x75e7(%rip), %rcx # 0x971d6
jmp 0x8fc18
addq $0x8, %rbx
movl %eax, %edi
callq 0x8feaa
leaq 0x7614(%rip), %rcx # 0x97217
jmp 0x8fc18
addq $0x8, %rbx
movl %r13d, %edi
callq 0x8feaa
leaq 0x7626(%rip), %rcx # 0x9723e
movl $0x80, %edx
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %r8
xorl %eax, %eax
callq 0x28210
movl $0x1, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_xml_parse:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
mov rcx, [rdi+118h]
mov [rdi+120h], rcx
mov [rdi+128h], rsi
mov [rdi+130h], rsi
lea rax, [rsi+rdx]
mov [rdi+138h], rax
test rdx, rdx
jle loc_8FB7D
lea r15, [rbp+var_40]
loc_8F878:
cmp byte ptr [rsi], 3Ch ; '<'
jnz short loc_8F8BF
mov rdi, rbx
mov rsi, r15
call my_xml_scan
cmp eax, 43h ; 'C'
jz loc_8FB5F
cmp eax, 44h ; 'D'
jnz loc_8F924
mov rax, [rbx+150h]
test rax, rax
jz loc_8FB5F
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
add rsi, 9
sub rdx, rsi
add rdx, 0FFFFFFFFFFFFFFFDh
jmp short loc_8F91A
loc_8F8BF:
mov [rbp+var_40], rsi
mov rdx, rsi
cmp rsi, rax
jnb short loc_8F8E5
sub rax, rsi
mov rdx, rsi
loc_8F8D1:
cmp byte ptr [rdx], 3Ch ; '<'
jz short loc_8F8E5
inc rdx
mov [rbx+130h], rdx
dec rax
jnz short loc_8F8D1
loc_8F8E5:
mov [rbp+var_38], rdx
test byte ptr [rbx], 2
jnz short loc_8F8FE
mov rdi, r15
call my_xml_norm_text
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
loc_8F8FE:
cmp rsi, rdx
jz loc_8FB5F
mov rax, [rbx+150h]
test rax, rax
jz loc_8FB5F
sub rdx, rsi
loc_8F91A:
mov rdi, rbx
call rax
jmp loc_8FB5F
loc_8F924:
mov rdi, rbx
mov rsi, r15
call my_xml_scan
cmp eax, 2Fh ; '/'
jnz short loc_8F976
mov rdi, rbx
mov rsi, r15
call my_xml_scan
cmp eax, 49h ; 'I'
jnz loc_8FBDD
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
sub rdx, rsi
mov rdi, rbx
call my_xml_leave
test eax, eax
jnz loc_8FC2F
mov rdi, rbx
mov rsi, r15
call my_xml_scan
mov r13d, eax
jmp loc_8FB59
loc_8F976:
mov r14d, eax
cmp eax, 21h ; '!'
setz r12b
cmp eax, 3Fh ; '?'
jz short loc_8F98B
cmp r14d, 21h ; '!'
jnz short loc_8F998
loc_8F98B:
mov rdi, rbx
mov rsi, r15
call my_xml_scan
jmp short loc_8F99E
loc_8F998:
mov r12b, 1
mov eax, r14d
loc_8F99E:
cmp eax, 49h ; 'I'
jnz loc_8FBC9
mov dword ptr [rbx+4], 0
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
sub rdx, rsi
mov rdi, rbx
call my_xml_enter
test eax, eax
jnz loc_8FC2F
mov [rbp+var_29], r12b
mov r12d, r14d
xor r12d, 21h
mov rdi, rbx
loc_8F9D7:
mov rsi, r15
call my_xml_scan
mov r13d, eax
xor eax, 53h
or eax, r12d
setz al
cmp r13d, 49h ; 'I'
jz short loc_8F9F9
test al, al
jz loc_8FAE2
loc_8F9F9:
mov rdi, rbx
lea rsi, [rbp+var_50]
call my_xml_scan
cmp eax, 49h ; 'I'
jz short loc_8FA87
mov r13d, eax
cmp eax, 3Dh ; '='
jnz loc_8FAC6
mov rdi, rbx
lea rsi, [rbp+var_50]
call my_xml_scan
cmp eax, 53h ; 'S'
jz short loc_8FA30
cmp eax, 49h ; 'I'
jnz loc_8FBF1
loc_8FA30:
mov dword ptr [rbx+4], 1
mov r13, [rbp+var_40]
mov r15, [rbp+var_38]
sub r15, r13
mov rdi, rbx
mov rsi, r13
mov rdx, r15
call my_xml_enter
test eax, eax
jnz loc_8FC2F
mov rax, [rbx+150h]
test rax, rax
jz short loc_8FA7C
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_48]
sub rdx, rsi
mov rdi, rbx
call rax
test eax, eax
jnz loc_8FC2F
loc_8FA7C:
mov rdi, rbx
mov rsi, r13
mov rdx, r15
jmp short loc_8FAB8
loc_8FA87:
mov dword ptr [rbx+4], 1
mov r15, [rbp+var_40]
mov r13, [rbp+var_38]
sub r13, r15
mov rdi, rbx
mov rsi, r15
mov rdx, r13
call my_xml_enter
test eax, eax
jnz loc_8FC2F
mov rdi, rbx
mov rsi, r15
mov rdx, r13
loc_8FAB8:
call my_xml_leave
test eax, eax
jz short loc_8FAD2
jmp loc_8FC2F
loc_8FAC6:
cmp r14d, 21h ; '!'
jnz short loc_8FADE
cmp r13d, 53h ; 'S'
jnz short loc_8FADE
loc_8FAD2:
mov rdi, rbx
lea r15, [rbp+var_40]
jmp loc_8F9D7
loc_8FADE:
lea r15, [rbp+var_40]
loc_8FAE2:
cmp r13d, 2Fh ; '/'
mov r12b, [rbp+var_29]
jnz short loc_8FB0E
mov rdi, rbx
xor esi, esi
xor edx, edx
call my_xml_leave
test eax, eax
jnz loc_8FC2F
mov rdi, rbx
mov rsi, r15
call my_xml_scan
mov r13d, eax
loc_8FB0E:
test r12b, r12b
jnz short loc_8FB3F
cmp r13d, 3Fh ; '?'
jnz loc_8FC05
mov rdi, rbx
xor esi, esi
xor edx, edx
call my_xml_leave
test eax, eax
jnz loc_8FC2F
mov rdi, rbx
mov rsi, r15
call my_xml_scan
mov r13d, eax
loc_8FB3F:
cmp r14d, 21h ; '!'
jnz short loc_8FB59
mov rdi, rbx
xor esi, esi
xor edx, edx
call my_xml_leave
test eax, eax
jnz loc_8FC2F
loc_8FB59:
cmp r13d, 3Eh ; '>'
jnz short loc_8FBB4
loc_8FB5F:
mov rsi, [rbx+130h]
mov rax, [rbx+138h]
cmp rsi, rax
jb loc_8F878
mov rcx, [rbx+118h]
loc_8FB7D:
cmp byte ptr [rcx], 0
jz short loc_8FBAC
add rbx, 8
lea rcx, aUnexpectedEndO; "unexpected END-OF-INPUT"
mov r14d, 1
mov edx, 80h
mov rdi, rbx
mov esi, 1
xor eax, eax
call ___sprintf_chk
jmp loc_8FC35
loc_8FBAC:
xor r14d, r14d
jmp loc_8FC35
loc_8FBB4:
add rbx, 8
mov edi, r13d
call lex2str
lea rcx, aSUnexpectedWan; "%s unexpected ('>' wanted)"
jmp short loc_8FC18
loc_8FBC9:
add rbx, 8
mov edi, eax
call lex2str
lea rcx, aSUnexpectedIde; "%s unexpected (ident or '/' wanted)"
jmp short loc_8FC18
loc_8FBDD:
add rbx, 8
mov edi, eax
call lex2str
lea rcx, aSUnexpectedIde_0; "%s unexpected (ident wanted)"
jmp short loc_8FC18
loc_8FBF1:
add rbx, 8
mov edi, eax
call lex2str
lea rcx, aSUnexpectedIde_1; "%s unexpected (ident or string wanted)"
jmp short loc_8FC18
loc_8FC05:
add rbx, 8
mov edi, r13d
call lex2str
lea rcx, aSUnexpectedWan_0; "%s unexpected ('?' wanted)"
loc_8FC18:
mov edx, 80h
mov rdi, rbx
mov esi, 1
mov r8, rax
xor eax, eax
call ___sprintf_chk
loc_8FC2F:
mov r14d, 1
loc_8FC35:
mov eax, r14d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_xml_parse(long long a1, _BYTE *a2, long long a3)
{
_BYTE *v4; // rcx
_BYTE *v5; // rax
int v6; // eax
void ( *v7)(long long, _BYTE *, long long); // rax
long long v8; // rdx
_BYTE *v9; // rdx
long long v10; // rax
unsigned int v11; // eax
unsigned int v12; // eax
unsigned int v13; // r13d
unsigned int v14; // r14d
bool v15; // r12
long long i; // rdi
unsigned int v17; // eax
unsigned int v18; // eax
_BYTE *v19; // r13
long long v20; // r15
unsigned int ( *v21)(long long, _QWORD, _QWORD); // rax
long long v22; // rdi
_BYTE *v23; // rsi
long long v24; // rdx
_BYTE *v25; // r15
long long v26; // r13
bool v27; // r12
unsigned int v28; // r14d
long long v29; // rax
long long v30; // rax
long long v31; // rax
long long v32; // rax
long long v33; // rax
_QWORD v35[2]; // [rsp+0h] [rbp-50h] BYREF
_BYTE *v36; // [rsp+10h] [rbp-40h] BYREF
_BYTE *v37; // [rsp+18h] [rbp-38h]
bool v38; // [rsp+27h] [rbp-29h]
v4 = *(_BYTE **)(a1 + 280);
*(_QWORD *)(a1 + 288) = v4;
*(_QWORD *)(a1 + 296) = a2;
*(_QWORD *)(a1 + 304) = a2;
v5 = &a2[a3];
*(_QWORD *)(a1 + 312) = &a2[a3];
if ( a3 <= 0 )
goto LABEL_57;
while ( *a2 != 60 )
{
v36 = a2;
v9 = a2;
if ( a2 < v5 )
{
v10 = v5 - a2;
v9 = a2;
do
{
if ( *v9 == 60 )
break;
*(_QWORD *)(a1 + 304) = ++v9;
--v10;
}
while ( v10 );
}
v37 = v9;
if ( (*(_BYTE *)a1 & 2) == 0 )
{
my_xml_norm_text(&v36);
a2 = v36;
v9 = v37;
}
if ( a2 != v9 )
{
v7 = *(void ( **)(long long, _BYTE *, long long))(a1 + 336);
if ( v7 )
{
v8 = v9 - a2;
LABEL_16:
v7(a1, a2, v8);
}
}
LABEL_55:
a2 = *(_BYTE **)(a1 + 304);
v5 = *(_BYTE **)(a1 + 312);
if ( a2 >= v5 )
{
v4 = *(_BYTE **)(a1 + 280);
LABEL_57:
if ( *v4 )
{
v28 = 1;
__sprintf_chk(a1 + 8, 1LL, 128LL, "unexpected END-OF-INPUT");
}
else
{
return 0;
}
return v28;
}
}
v6 = my_xml_scan(a1, &v36);
if ( v6 == 67 )
goto LABEL_55;
if ( v6 == 68 )
{
v7 = *(void ( **)(long long, _BYTE *, long long))(a1 + 336);
if ( !v7 )
goto LABEL_55;
a2 = v36 + 9;
v8 = v37 - (v36 + 9) - 3;
goto LABEL_16;
}
v11 = my_xml_scan(a1, &v36);
if ( v11 == 47 )
{
v12 = my_xml_scan(a1, &v36);
if ( v12 == 73 )
{
if ( !(unsigned int)my_xml_leave(a1, v36, v37 - v36) )
{
v13 = my_xml_scan(a1, &v36);
goto LABEL_54;
}
}
else
{
v31 = lex2str(v12);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected (ident wanted)", v31);
}
return 1;
}
v14 = v11;
v15 = v11 == 33;
if ( v11 == 63 || v11 == 33 )
v11 = my_xml_scan(a1, &v36);
else
v15 = 1;
if ( v11 != 73 )
{
v30 = lex2str(v11);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected (ident or '/' wanted)", v30);
return 1;
}
*(_DWORD *)(a1 + 4) = 0;
if ( (unsigned int)my_xml_enter(a1, v36, v37 - v36) )
return 1;
v38 = v15;
for ( i = a1; ; i = a1 )
{
v13 = my_xml_scan(i, &v36);
if ( v13 != 73 )
{
if ( v14 ^ 0x21 | v13 ^ 0x53 )
break;
}
v17 = my_xml_scan(a1, v35);
if ( v17 == 73 )
{
*(_DWORD *)(a1 + 4) = 1;
v25 = v36;
v26 = v37 - v36;
if ( (unsigned int)my_xml_enter(a1, v36, v37 - v36) )
return 1;
v22 = a1;
v23 = v25;
v24 = v26;
LABEL_40:
if ( (unsigned int)my_xml_leave(v22, v23, v24) )
return 1;
continue;
}
v13 = v17;
if ( v17 == 61 )
{
v18 = my_xml_scan(a1, v35);
if ( v18 != 83 && v18 != 73 )
{
v32 = lex2str(v18);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected (ident or string wanted)", v32);
return 1;
}
*(_DWORD *)(a1 + 4) = 1;
v19 = v36;
v20 = v37 - v36;
if ( (unsigned int)my_xml_enter(a1, v36, v37 - v36) )
return 1;
v21 = *(unsigned int ( **)(long long, _QWORD, _QWORD))(a1 + 336);
if ( v21 )
{
if ( v21(a1, v35[0], v35[1] - v35[0]) )
return 1;
}
v22 = a1;
v23 = v19;
v24 = v20;
goto LABEL_40;
}
if ( v14 != 33 || v17 != 83 )
break;
}
v27 = v38;
if ( v13 == 47 )
{
if ( (unsigned int)my_xml_leave(a1, 0LL, 0LL) )
return 1;
v13 = my_xml_scan(a1, &v36);
}
if ( v27 )
goto LABEL_52;
if ( v13 == 63 )
{
if ( (unsigned int)my_xml_leave(a1, 0LL, 0LL) )
return 1;
v13 = my_xml_scan(a1, &v36);
LABEL_52:
if ( v14 != 33 || !(unsigned int)my_xml_leave(a1, 0LL, 0LL) )
{
LABEL_54:
if ( v13 == 62 )
goto LABEL_55;
v29 = lex2str(v13);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected ('>' wanted)", v29);
}
}
else
{
v33 = lex2str(v13);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected ('?' wanted)", v33);
}
return 1;
}
| my_xml_parse:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RCX,qword ptr [RDI + 0x118]
MOV qword ptr [RDI + 0x120],RCX
MOV qword ptr [RDI + 0x128],RSI
MOV qword ptr [RDI + 0x130],RSI
LEA RAX,[RSI + RDX*0x1]
MOV qword ptr [RDI + 0x138],RAX
TEST RDX,RDX
JLE 0x0018fb7d
LEA R15,[RBP + -0x40]
LAB_0018f878:
CMP byte ptr [RSI],0x3c
JNZ 0x0018f8bf
MOV RDI,RBX
MOV RSI,R15
CALL 0x0018fc47
CMP EAX,0x43
JZ 0x0018fb5f
CMP EAX,0x44
JNZ 0x0018f924
MOV RAX,qword ptr [RBX + 0x150]
TEST RAX,RAX
JZ 0x0018fb5f
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
ADD RSI,0x9
SUB RDX,RSI
ADD RDX,-0x3
JMP 0x0018f91a
LAB_0018f8bf:
MOV qword ptr [RBP + -0x40],RSI
MOV RDX,RSI
CMP RSI,RAX
JNC 0x0018f8e5
SUB RAX,RSI
MOV RDX,RSI
LAB_0018f8d1:
CMP byte ptr [RDX],0x3c
JZ 0x0018f8e5
INC RDX
MOV qword ptr [RBX + 0x130],RDX
DEC RAX
JNZ 0x0018f8d1
LAB_0018f8e5:
MOV qword ptr [RBP + -0x38],RDX
TEST byte ptr [RBX],0x2
JNZ 0x0018f8fe
MOV RDI,R15
CALL 0x0019027f
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
LAB_0018f8fe:
CMP RSI,RDX
JZ 0x0018fb5f
MOV RAX,qword ptr [RBX + 0x150]
TEST RAX,RAX
JZ 0x0018fb5f
SUB RDX,RSI
LAB_0018f91a:
MOV RDI,RBX
CALL RAX
JMP 0x0018fb5f
LAB_0018f924:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0018fc47
CMP EAX,0x2f
JNZ 0x0018f976
MOV RDI,RBX
MOV RSI,R15
CALL 0x0018fc47
CMP EAX,0x49
JNZ 0x0018fbdd
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,RSI
MOV RDI,RBX
CALL 0x0018ff45
TEST EAX,EAX
JNZ 0x0018fc2f
MOV RDI,RBX
MOV RSI,R15
CALL 0x0018fc47
MOV R13D,EAX
JMP 0x0018fb59
LAB_0018f976:
MOV R14D,EAX
CMP EAX,0x21
SETZ R12B
CMP EAX,0x3f
JZ 0x0018f98b
CMP R14D,0x21
JNZ 0x0018f998
LAB_0018f98b:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0018fc47
JMP 0x0018f99e
LAB_0018f998:
MOV R12B,0x1
MOV EAX,R14D
LAB_0018f99e:
CMP EAX,0x49
JNZ 0x0018fbc9
MOV dword ptr [RBX + 0x4],0x0
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,RSI
MOV RDI,RBX
CALL 0x00190108
TEST EAX,EAX
JNZ 0x0018fc2f
MOV byte ptr [RBP + -0x29],R12B
MOV R12D,R14D
XOR R12D,0x21
MOV RDI,RBX
LAB_0018f9d7:
MOV RSI,R15
CALL 0x0018fc47
MOV R13D,EAX
XOR EAX,0x53
OR EAX,R12D
SETZ AL
CMP R13D,0x49
JZ 0x0018f9f9
TEST AL,AL
JZ 0x0018fae2
LAB_0018f9f9:
MOV RDI,RBX
LEA RSI,[RBP + -0x50]
CALL 0x0018fc47
CMP EAX,0x49
JZ 0x0018fa87
MOV R13D,EAX
CMP EAX,0x3d
JNZ 0x0018fac6
MOV RDI,RBX
LEA RSI,[RBP + -0x50]
CALL 0x0018fc47
CMP EAX,0x53
JZ 0x0018fa30
CMP EAX,0x49
JNZ 0x0018fbf1
LAB_0018fa30:
MOV dword ptr [RBX + 0x4],0x1
MOV R13,qword ptr [RBP + -0x40]
MOV R15,qword ptr [RBP + -0x38]
SUB R15,R13
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R15
CALL 0x00190108
TEST EAX,EAX
JNZ 0x0018fc2f
MOV RAX,qword ptr [RBX + 0x150]
TEST RAX,RAX
JZ 0x0018fa7c
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
SUB RDX,RSI
MOV RDI,RBX
CALL RAX
TEST EAX,EAX
JNZ 0x0018fc2f
LAB_0018fa7c:
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R15
JMP 0x0018fab8
LAB_0018fa87:
MOV dword ptr [RBX + 0x4],0x1
MOV R15,qword ptr [RBP + -0x40]
MOV R13,qword ptr [RBP + -0x38]
SUB R13,R15
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
CALL 0x00190108
TEST EAX,EAX
JNZ 0x0018fc2f
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
LAB_0018fab8:
CALL 0x0018ff45
TEST EAX,EAX
JZ 0x0018fad2
JMP 0x0018fc2f
LAB_0018fac6:
CMP R14D,0x21
JNZ 0x0018fade
CMP R13D,0x53
JNZ 0x0018fade
LAB_0018fad2:
MOV RDI,RBX
LEA R15,[RBP + -0x40]
JMP 0x0018f9d7
LAB_0018fade:
LEA R15,[RBP + -0x40]
LAB_0018fae2:
CMP R13D,0x2f
MOV R12B,byte ptr [RBP + -0x29]
JNZ 0x0018fb0e
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0018ff45
TEST EAX,EAX
JNZ 0x0018fc2f
MOV RDI,RBX
MOV RSI,R15
CALL 0x0018fc47
MOV R13D,EAX
LAB_0018fb0e:
TEST R12B,R12B
JNZ 0x0018fb3f
CMP R13D,0x3f
JNZ 0x0018fc05
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0018ff45
TEST EAX,EAX
JNZ 0x0018fc2f
MOV RDI,RBX
MOV RSI,R15
CALL 0x0018fc47
MOV R13D,EAX
LAB_0018fb3f:
CMP R14D,0x21
JNZ 0x0018fb59
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0018ff45
TEST EAX,EAX
JNZ 0x0018fc2f
LAB_0018fb59:
CMP R13D,0x3e
JNZ 0x0018fbb4
LAB_0018fb5f:
MOV RSI,qword ptr [RBX + 0x130]
MOV RAX,qword ptr [RBX + 0x138]
CMP RSI,RAX
JC 0x0018f878
MOV RCX,qword ptr [RBX + 0x118]
LAB_0018fb7d:
CMP byte ptr [RCX],0x0
JZ 0x0018fbac
ADD RBX,0x8
LEA RCX,[0x197274]
MOV R14D,0x1
MOV EDX,0x80
MOV RDI,RBX
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00128210
JMP 0x0018fc35
LAB_0018fbac:
XOR R14D,R14D
JMP 0x0018fc35
LAB_0018fbb4:
ADD RBX,0x8
MOV EDI,R13D
CALL 0x0018feaa
LEA RCX,[0x197259]
JMP 0x0018fc18
LAB_0018fbc9:
ADD RBX,0x8
MOV EDI,EAX
CALL 0x0018feaa
LEA RCX,[0x1971f3]
JMP 0x0018fc18
LAB_0018fbdd:
ADD RBX,0x8
MOV EDI,EAX
CALL 0x0018feaa
LEA RCX,[0x1971d6]
JMP 0x0018fc18
LAB_0018fbf1:
ADD RBX,0x8
MOV EDI,EAX
CALL 0x0018feaa
LEA RCX,[0x197217]
JMP 0x0018fc18
LAB_0018fc05:
ADD RBX,0x8
MOV EDI,R13D
CALL 0x0018feaa
LEA RCX,[0x19723e]
LAB_0018fc18:
MOV EDX,0x80
MOV RDI,RBX
MOV ESI,0x1
MOV R8,RAX
XOR EAX,EAX
CALL 0x00128210
LAB_0018fc2f:
MOV R14D,0x1
LAB_0018fc35:
MOV EAX,R14D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Type propagation algorithm not settling */
bool my_xml_parse(byte *param_1,char *param_2,long param_3)
{
char cVar1;
int iVar2;
int iVar3;
code *pcVar4;
int8 uVar5;
char *pcVar6;
char *pcVar7;
long lVar8;
bool bVar9;
long local_58;
long local_50;
char *local_48;
char *local_40;
char local_31;
pcVar7 = *(char **)(param_1 + 0x118);
*(char **)(param_1 + 0x120) = pcVar7;
*(char **)(param_1 + 0x128) = param_2;
*(char **)(param_1 + 0x130) = param_2;
pcVar6 = param_2 + param_3;
*(char **)(param_1 + 0x138) = pcVar6;
if (0 < param_3) {
do {
if (*param_2 == '<') {
iVar2 = my_xml_scan(param_1,&local_48);
if (iVar2 != 0x43) {
if (iVar2 == 0x44) {
pcVar4 = *(code **)(param_1 + 0x150);
if (pcVar4 != (code *)0x0) {
pcVar7 = local_40 + (-3 - (long)(local_48 + 9));
pcVar6 = local_48 + 9;
goto LAB_0018f91a;
}
}
else {
iVar2 = my_xml_scan(param_1,&local_48);
if (iVar2 != 0x2f) {
bVar9 = iVar2 == 0x21;
if ((iVar2 == 0x3f) || (iVar2 == 0x21)) {
iVar3 = my_xml_scan(param_1,&local_48);
}
else {
bVar9 = true;
iVar3 = iVar2;
}
if (iVar3 == 0x49) {
param_1[4] = 0;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
iVar3 = my_xml_enter(param_1,local_48,(long)local_40 - (long)local_48);
local_31 = bVar9;
do {
if (iVar3 != 0) {
return true;
}
LAB_0018f9d7:
iVar3 = my_xml_scan(param_1,&local_48);
if ((iVar3 != 0x49) && (iVar3 != 0x53 || iVar2 != 0x21)) goto LAB_0018fae2;
iVar3 = my_xml_scan(param_1,&local_58);
pcVar6 = local_48;
if (iVar3 == 0x49) {
param_1[4] = 1;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
lVar8 = (long)local_40 - (long)local_48;
iVar3 = my_xml_enter(param_1,local_48,lVar8);
goto joined_r0x0018faa9;
}
if (iVar3 != 0x3d) goto LAB_0018fac6;
iVar3 = my_xml_scan(param_1,&local_58);
pcVar6 = local_48;
if ((iVar3 != 0x53) && (iVar3 != 0x49)) {
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (ident or string wanted)";
goto LAB_0018fc18;
}
param_1[4] = 1;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
lVar8 = (long)local_40 - (long)local_48;
iVar3 = my_xml_enter(param_1,local_48,lVar8);
if (iVar3 != 0) {
return true;
}
if (*(code **)(param_1 + 0x150) != (code *)0x0) {
iVar3 = (**(code **)(param_1 + 0x150))(param_1,local_58,local_50 - local_58);
joined_r0x0018faa9:
if (iVar3 != 0) {
return true;
}
}
iVar3 = my_xml_leave(param_1,pcVar6,lVar8);
} while( true );
}
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (ident or \'/\' wanted)";
LAB_0018fc18:
__sprintf_chk(param_1 + 8,1,0x80,pcVar6,uVar5);
return true;
}
iVar2 = my_xml_scan(param_1,&local_48);
if (iVar2 != 0x49) {
uVar5 = lex2str(iVar2);
pcVar6 = "%s unexpected (ident wanted)";
goto LAB_0018fc18;
}
iVar2 = my_xml_leave(param_1,local_48,(long)local_40 - (long)local_48);
if (iVar2 != 0) {
return true;
}
iVar3 = my_xml_scan(param_1,&local_48);
LAB_0018fb59:
if (iVar3 != 0x3e) {
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (\'>\' wanted)";
goto LAB_0018fc18;
}
}
}
}
else {
local_40 = param_2;
if (param_2 < pcVar6) {
lVar8 = (long)pcVar6 - (long)param_2;
do {
if (*local_40 == '<') break;
local_40 = local_40 + 1;
*(char **)(param_1 + 0x130) = local_40;
lVar8 = lVar8 + -1;
} while (lVar8 != 0);
}
local_48 = param_2;
if ((*param_1 & 2) == 0) {
my_xml_norm_text(&local_48);
}
if ((local_48 != local_40) && (pcVar4 = *(code **)(param_1 + 0x150), pcVar4 != (code *)0x0))
{
pcVar7 = local_40 + -(long)local_48;
pcVar6 = local_48;
LAB_0018f91a:
(*pcVar4)(param_1,pcVar6,pcVar7);
}
}
param_2 = *(char **)(param_1 + 0x130);
pcVar6 = *(char **)(param_1 + 0x138);
} while (param_2 < pcVar6);
pcVar7 = *(char **)(param_1 + 0x118);
}
cVar1 = *pcVar7;
if (cVar1 != '\0') {
__sprintf_chk(param_1 + 8,1,0x80,"unexpected END-OF-INPUT");
}
return cVar1 != '\0';
LAB_0018fac6:
if ((iVar2 != 0x21) || (iVar3 != 0x53)) {
LAB_0018fae2:
cVar1 = local_31;
if (iVar3 == 0x2f) {
iVar3 = my_xml_leave(param_1,0,0);
if (iVar3 != 0) {
return true;
}
iVar3 = my_xml_scan(param_1,&local_48);
}
if (cVar1 == '\0') {
if (iVar3 != 0x3f) {
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (\'?\' wanted)";
goto LAB_0018fc18;
}
iVar3 = my_xml_leave(param_1,0,0);
if (iVar3 != 0) {
return true;
}
iVar3 = my_xml_scan(param_1,&local_48);
}
if ((iVar2 == 0x21) && (iVar2 = my_xml_leave(param_1,0,0), iVar2 != 0)) {
return true;
}
goto LAB_0018fb59;
}
goto LAB_0018f9d7;
}
|
|
6,416 | test_conc179 | eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c | static int test_conc179(MYSQL *mysql)
{
MYSQL_STMT *stmt;
int rc;
const char *stmtstr= "select 1 as ' '";
stmt= mysql_stmt_init(mysql);
rc= mysql_stmt_prepare(stmt, SL(stmtstr));
check_stmt_rc(rc, stmt);
if (mysql_get_server_version(mysql) >= 100100)
{
FAIL_IF(mysql_warning_count(mysql) < 1, "expected 1 or more warnings");
FAIL_IF(mysql_stmt_warning_count(stmt) < 1, "expected 1 or more warnings");
}
mysql_stmt_close(stmt);
rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
check_mysql_rc(rc, mysql);
return OK;
} | O0 | c | test_conc179:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x4cbfb(%rip), %rax # 0x6727e
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44950
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x141a0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x45070
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1a6f8
movq -0x18(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x4aeb7(%rip), %rdi # 0x65590
leaq 0x4b98d(%rip), %rdx # 0x6606d
movl $0x10dd, %ecx # imm = 0x10DD
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x1a7fc
jmp 0x1a6fa
movq -0x10(%rbp), %rdi
callq 0x3afb0
cmpq $0x18704, %rax # imm = 0x18704
jb 0x1a788
jmp 0x1a70d
movq -0x10(%rbp), %rdi
callq 0x3c670
cmpl $0x1, %eax
jae 0x1a748
leaq 0x4ae6e(%rip), %rdi # 0x65590
leaq 0x4cb65(%rip), %rsi # 0x6728e
leaq 0x4b93d(%rip), %rdx # 0x6606d
movl $0x10e1, %ecx # imm = 0x10E1
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x1a7fc
jmp 0x1a74a
jmp 0x1a74c
movq -0x18(%rbp), %rdi
callq 0x45050
cmpl $0x1, %eax
jge 0x1a784
leaq 0x4ae2f(%rip), %rdi # 0x65590
leaq 0x4cb26(%rip), %rsi # 0x6728e
leaq 0x4b8fe(%rip), %rdx # 0x6606d
movl $0x10e2, %ecx # imm = 0x10E2
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x1a7fc
jmp 0x1a786
jmp 0x1a788
movq -0x18(%rbp), %rdi
callq 0x43eb0
movq -0x10(%rbp), %rdi
leaq 0x4be9a(%rip), %rsi # 0x66636
callq 0x38a70
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1a7f3
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %rdx
movl %eax, %ecx
leaq 0x4aeff(%rip), %rdi # 0x656d5
leaq 0x4b890(%rip), %r8 # 0x6606d
movl $0x10e7, %r9d # imm = 0x10E7
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x1a7fc
jmp 0x1a7f5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| test_conc179:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
lea rax, aSelect1As; "select 1 as ' '"
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
call mysql_stmt_init
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rdi, [rbp+var_28]
call _strlen
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
mov rdx, rax
call mysql_stmt_prepare
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_1A6F8
mov rdi, [rbp+var_18]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 10DDh
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_1A7FC
loc_1A6F8:
jmp short $+2
loc_1A6FA:
mov rdi, [rbp+var_10]
call mysql_get_server_version
cmp rax, 18704h
jb short loc_1A788
jmp short $+2
loc_1A70D:
mov rdi, [rbp+var_10]
call mysql_warning_count
cmp eax, 1
jnb short loc_1A748
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aExpected1OrMor; "expected 1 or more warnings"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 10E1h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_1A7FC
loc_1A748:
jmp short $+2
loc_1A74A:
jmp short $+2
loc_1A74C:
mov rdi, [rbp+var_18]
call mysql_stmt_warning_count
cmp eax, 1
jge short loc_1A784
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aExpected1OrMor; "expected 1 or more warnings"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 10E2h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_1A7FC
loc_1A784:
jmp short $+2
loc_1A786:
jmp short $+2
loc_1A788:
mov rdi, [rbp+var_18]
call mysql_stmt_close
mov rdi, [rbp+var_10]
lea rsi, aDropTableIfExi_0; "DROP TABLE IF EXISTS t1"
call mysql_query
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_1A7F3
mov eax, [rbp+var_1C]
mov [rbp+var_44], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_44]
mov rdx, [rbp+var_40]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 10E7h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_1A7FC
loc_1A7F3:
jmp short $+2
loc_1A7F5:
mov [rbp+var_4], 0
loc_1A7FC:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long test_conc179(long long a1)
{
long long v1; // rax
int v2; // eax
int v3; // r8d
int v4; // r9d
int v5; // r8d
int v6; // r9d
int v7; // r8d
int v8; // r9d
int v9; // eax
int v11; // [rsp+10h] [rbp-40h]
int v12; // [rsp+34h] [rbp-1Ch]
long long v13; // [rsp+38h] [rbp-18h]
v13 = mysql_stmt_init(a1);
v1 = strlen("select 1 as ' '");
if ( (unsigned int)mysql_stmt_prepare(v13, "select 1 as ' '", v1) )
{
v2 = mysql_stmt_error(v13);
diag(
(unsigned int)"Error: %s (%s: %d)",
v2,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4317,
v3,
v4);
return 1;
}
else
{
if ( (unsigned long long)mysql_get_server_version(a1) >= 0x18704 )
{
if ( !(unsigned int)mysql_warning_count(a1) )
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"expected 1 or more warnings",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4321,
v5,
v6);
return 1;
}
if ( (int)mysql_stmt_warning_count(v13) < 1 )
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"expected 1 or more warnings",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4322,
v7,
v8);
return 1;
}
}
mysql_stmt_close(v13);
v12 = mysql_query(a1, "DROP TABLE IF EXISTS t1");
if ( v12 )
{
v11 = mysql_error(a1);
v9 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v12,
v11,
v9,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4327);
return 1;
}
else
{
return 0;
}
}
}
| test_conc179:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0x16727e]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00144950
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,RAX
CALL 0x00145070
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0011a6f8
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x10dd
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0011a7fc
LAB_0011a6f8:
JMP 0x0011a6fa
LAB_0011a6fa:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013afb0
CMP RAX,0x18704
JC 0x0011a788
JMP 0x0011a70d
LAB_0011a70d:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c670
CMP EAX,0x1
JNC 0x0011a748
LEA RDI,[0x165590]
LEA RSI,[0x16728e]
LEA RDX,[0x16606d]
MOV ECX,0x10e1
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0011a7fc
LAB_0011a748:
JMP 0x0011a74a
LAB_0011a74a:
JMP 0x0011a74c
LAB_0011a74c:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00145050
CMP EAX,0x1
JGE 0x0011a784
LEA RDI,[0x165590]
LEA RSI,[0x16728e]
LEA RDX,[0x16606d]
MOV ECX,0x10e2
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0011a7fc
LAB_0011a784:
JMP 0x0011a786
LAB_0011a786:
JMP 0x0011a788
LAB_0011a788:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00143eb0
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x166636]
CALL 0x00138a70
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0011a7f3
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x44],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0x44]
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0x10e7
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0011a7fc
LAB_0011a7f3:
JMP 0x0011a7f5
LAB_0011a7f5:
MOV dword ptr [RBP + -0x4],0x0
LAB_0011a7fc:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
bool test_conc179(int8 param_1)
{
int iVar1;
int4 uVar2;
int8 uVar3;
size_t sVar4;
ulong uVar5;
uVar3 = mysql_stmt_init(param_1);
sVar4 = strlen("select 1 as \' \'");
iVar1 = mysql_stmt_prepare(uVar3,"select 1 as \' \'",sVar4);
if (iVar1 != 0) {
uVar3 = mysql_stmt_error(uVar3);
diag("Error: %s (%s: %d)",uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0x10dd)
;
return true;
}
uVar5 = mysql_get_server_version(param_1);
if (0x18703 < uVar5) {
iVar1 = mysql_warning_count(param_1);
if (iVar1 == 0) {
diag("Error: %s (%s: %d)","expected 1 or more warnings",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0x10e1);
return true;
}
iVar1 = mysql_stmt_warning_count(uVar3);
if (iVar1 < 1) {
diag("Error: %s (%s: %d)","expected 1 or more warnings",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0x10e2);
return true;
}
}
mysql_stmt_close(uVar3);
iVar1 = mysql_query(param_1,"DROP TABLE IF EXISTS t1");
if (iVar1 != 0) {
uVar3 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar3,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0x10e7)
;
}
return iVar1 != 0;
}
|
|
6,417 | mjGlad_load_GL_VERSION_1_3 | aimrt_mujoco_sim/_deps/mujoco-src/src/render/glad/glad.c | static void mjGlad_load_GL_VERSION_1_3(GLADloadproc load) {
if(!mjGLAD_GL_VERSION_1_3) return;
mjGlad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture");
mjGlad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage");
mjGlad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D");
mjGlad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D");
mjGlad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D");
mjGlad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D");
mjGlad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D");
mjGlad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D");
mjGlad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage");
mjGlad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)load("glClientActiveTexture");
mjGlad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)load("glMultiTexCoord1d");
mjGlad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)load("glMultiTexCoord1dv");
mjGlad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)load("glMultiTexCoord1f");
mjGlad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)load("glMultiTexCoord1fv");
mjGlad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)load("glMultiTexCoord1i");
mjGlad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)load("glMultiTexCoord1iv");
mjGlad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)load("glMultiTexCoord1s");
mjGlad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)load("glMultiTexCoord1sv");
mjGlad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)load("glMultiTexCoord2d");
mjGlad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)load("glMultiTexCoord2dv");
mjGlad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)load("glMultiTexCoord2f");
mjGlad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)load("glMultiTexCoord2fv");
mjGlad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)load("glMultiTexCoord2i");
mjGlad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)load("glMultiTexCoord2iv");
mjGlad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)load("glMultiTexCoord2s");
mjGlad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)load("glMultiTexCoord2sv");
mjGlad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)load("glMultiTexCoord3d");
mjGlad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)load("glMultiTexCoord3dv");
mjGlad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)load("glMultiTexCoord3f");
mjGlad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)load("glMultiTexCoord3fv");
mjGlad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)load("glMultiTexCoord3i");
mjGlad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)load("glMultiTexCoord3iv");
mjGlad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)load("glMultiTexCoord3s");
mjGlad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)load("glMultiTexCoord3sv");
mjGlad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)load("glMultiTexCoord4d");
mjGlad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)load("glMultiTexCoord4dv");
mjGlad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)load("glMultiTexCoord4f");
mjGlad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)load("glMultiTexCoord4fv");
mjGlad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)load("glMultiTexCoord4i");
mjGlad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)load("glMultiTexCoord4iv");
mjGlad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)load("glMultiTexCoord4s");
mjGlad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)load("glMultiTexCoord4sv");
mjGlad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)load("glLoadTransposeMatrixf");
mjGlad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)load("glLoadTransposeMatrixd");
mjGlad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)load("glMultTransposeMatrixf");
mjGlad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)load("glMultTransposeMatrixd");
} | O0 | c | mjGlad_load_GL_VERSION_1_3:
pushq %rax
movq %rdi, (%rsp)
cmpl $0x0, 0x198bcc(%rip) # 0x60fb88
jne 0x476fc3
jmp 0x4772d1
leaq 0xba9f1(%rip), %rdi # 0x5319bb
callq *(%rsp)
movq %rax, 0x198bcc(%rip) # 0x60fba0
leaq 0xba9f0(%rip), %rdi # 0x5319cb
callq *(%rsp)
movq %rax, 0x1995f3(%rip) # 0x6105d8
leaq 0xba9f0(%rip), %rdi # 0x5319dc
callq *(%rsp)
movq %rax, 0x198d9a(%rip) # 0x60fd90
leaq 0xba9f6(%rip), %rdi # 0x5319f3
callq *(%rsp)
movq %rax, 0x198d81(%rip) # 0x60fd88
leaq 0xba9fc(%rip), %rdi # 0x531a0a
callq *(%rsp)
movq %rax, 0x198d68(%rip) # 0x60fd80
leaq 0xbaa02(%rip), %rdi # 0x531a21
callq *(%rsp)
movq %rax, 0x198d7f(%rip) # 0x60fda8
leaq 0xbaa0b(%rip), %rdi # 0x531a3b
callq *(%rsp)
movq %rax, 0x198d66(%rip) # 0x60fda0
leaq 0xbaa14(%rip), %rdi # 0x531a55
callq *(%rsp)
movq %rax, 0x198d4d(%rip) # 0x60fd98
leaq 0xbaa1d(%rip), %rdi # 0x531a6f
callq *(%rsp)
movq %rax, 0x198f54(%rip) # 0x60ffb0
leaq 0xbaa24(%rip), %rdi # 0x531a87
callq *(%rsp)
movq %rax, 0x198beb(%rip) # 0x60fc58
leaq 0xbaa29(%rip), %rdi # 0x531a9d
callq *(%rsp)
movq %rax, 0x1991fa(%rip) # 0x610278
leaq 0xbaa2a(%rip), %rdi # 0x531aaf
callq *(%rsp)
movq %rax, 0x1991f1(%rip) # 0x610280
leaq 0xbaa2c(%rip), %rdi # 0x531ac2
callq *(%rsp)
movq %rax, 0x1991e8(%rip) # 0x610288
leaq 0xbaa2d(%rip), %rdi # 0x531ad4
callq *(%rsp)
movq %rax, 0x1991df(%rip) # 0x610290
leaq 0xbaa2f(%rip), %rdi # 0x531ae7
callq *(%rsp)
movq %rax, 0x1991d6(%rip) # 0x610298
leaq 0xbaa30(%rip), %rdi # 0x531af9
callq *(%rsp)
movq %rax, 0x1991cd(%rip) # 0x6102a0
leaq 0xbaa32(%rip), %rdi # 0x531b0c
callq *(%rsp)
movq %rax, 0x1991c4(%rip) # 0x6102a8
leaq 0xbaa33(%rip), %rdi # 0x531b1e
callq *(%rsp)
movq %rax, 0x1991bb(%rip) # 0x6102b0
leaq 0xbaa35(%rip), %rdi # 0x531b31
callq *(%rsp)
movq %rax, 0x1991b2(%rip) # 0x6102b8
leaq 0xbaa36(%rip), %rdi # 0x531b43
callq *(%rsp)
movq %rax, 0x1991a9(%rip) # 0x6102c0
leaq 0xbaa38(%rip), %rdi # 0x531b56
callq *(%rsp)
movq %rax, 0x1991a0(%rip) # 0x6102c8
leaq 0xbaa39(%rip), %rdi # 0x531b68
callq *(%rsp)
movq %rax, 0x199197(%rip) # 0x6102d0
leaq 0xbaa3b(%rip), %rdi # 0x531b7b
callq *(%rsp)
movq %rax, 0x19918e(%rip) # 0x6102d8
leaq 0xbaa3c(%rip), %rdi # 0x531b8d
callq *(%rsp)
movq %rax, 0x199185(%rip) # 0x6102e0
leaq 0xbaa3e(%rip), %rdi # 0x531ba0
callq *(%rsp)
movq %rax, 0x19917c(%rip) # 0x6102e8
leaq 0xbaa3f(%rip), %rdi # 0x531bb2
callq *(%rsp)
movq %rax, 0x199173(%rip) # 0x6102f0
leaq 0xbaa41(%rip), %rdi # 0x531bc5
callq *(%rsp)
movq %rax, 0x19916a(%rip) # 0x6102f8
leaq 0xbaa42(%rip), %rdi # 0x531bd7
callq *(%rsp)
movq %rax, 0x199161(%rip) # 0x610300
leaq 0xbaa44(%rip), %rdi # 0x531bea
callq *(%rsp)
movq %rax, 0x199158(%rip) # 0x610308
leaq 0xbaa45(%rip), %rdi # 0x531bfc
callq *(%rsp)
movq %rax, 0x19914f(%rip) # 0x610310
leaq 0xbaa47(%rip), %rdi # 0x531c0f
callq *(%rsp)
movq %rax, 0x199146(%rip) # 0x610318
leaq 0xbaa48(%rip), %rdi # 0x531c21
callq *(%rsp)
movq %rax, 0x19913d(%rip) # 0x610320
leaq 0xbaa4a(%rip), %rdi # 0x531c34
callq *(%rsp)
movq %rax, 0x199134(%rip) # 0x610328
leaq 0xbaa4b(%rip), %rdi # 0x531c46
callq *(%rsp)
movq %rax, 0x19912b(%rip) # 0x610330
leaq 0xbaa4d(%rip), %rdi # 0x531c59
callq *(%rsp)
movq %rax, 0x199122(%rip) # 0x610338
leaq 0xbaa4e(%rip), %rdi # 0x531c6b
callq *(%rsp)
movq %rax, 0x199119(%rip) # 0x610340
leaq 0xbaa50(%rip), %rdi # 0x531c7e
callq *(%rsp)
movq %rax, 0x199110(%rip) # 0x610348
leaq 0xbaa51(%rip), %rdi # 0x531c90
callq *(%rsp)
movq %rax, 0x199107(%rip) # 0x610350
leaq 0xbaa53(%rip), %rdi # 0x531ca3
callq *(%rsp)
movq %rax, 0x1990fe(%rip) # 0x610358
leaq 0xbaa54(%rip), %rdi # 0x531cb5
callq *(%rsp)
movq %rax, 0x1990f5(%rip) # 0x610360
leaq 0xbaa56(%rip), %rdi # 0x531cc8
callq *(%rsp)
movq %rax, 0x1990ec(%rip) # 0x610368
leaq 0xbaa57(%rip), %rdi # 0x531cda
callq *(%rsp)
movq %rax, 0x1990e3(%rip) # 0x610370
leaq 0xbaa59(%rip), %rdi # 0x531ced
callq *(%rsp)
movq %rax, 0x198f2a(%rip) # 0x6101c8
leaq 0xbaa5f(%rip), %rdi # 0x531d04
callq *(%rsp)
movq %rax, 0x198f11(%rip) # 0x6101c0
leaq 0xbaa65(%rip), %rdi # 0x531d1b
callq *(%rsp)
movq %rax, 0x198fa0(%rip) # 0x610260
leaq 0xbaa6b(%rip), %rdi # 0x531d32
callq *(%rsp)
movq %rax, 0x198f87(%rip) # 0x610258
popq %rax
retq
nopw %cs:(%rax,%rax)
| mjGlad_load_GL_VERSION_1_3:
push rax
mov [rsp+8+var_8], rdi
cmp cs:mjGLAD_GL_VERSION_1_3, 0
jnz short loc_476FC3
jmp loc_4772D1
loc_476FC3:
lea rdi, aGlactivetextur; "glActiveTexture"
call [rsp+8+var_8]
mov cs:mjGlad_glActiveTexture, rax
lea rdi, aGlsamplecovera; "glSampleCoverage"
call [rsp+8+var_8]
mov cs:mjGlad_glSampleCoverage, rax
lea rdi, aGlcompressedte; "glCompressedTexImage3D"
call [rsp+8+var_8]
mov cs:mjGlad_glCompressedTexImage3D, rax
lea rdi, aGlcompressedte_0; "glCompressedTexImage2D"
call [rsp+8+var_8]
mov cs:mjGlad_glCompressedTexImage2D, rax
lea rdi, aGlcompressedte_1; "glCompressedTexImage1D"
call [rsp+8+var_8]
mov cs:mjGlad_glCompressedTexImage1D, rax
lea rdi, aGlcompressedte_2; "glCompressedTexSubImage3D"
call [rsp+8+var_8]
mov cs:mjGlad_glCompressedTexSubImage3D, rax
lea rdi, aGlcompressedte_3; "glCompressedTexSubImage2D"
call [rsp+8+var_8]
mov cs:mjGlad_glCompressedTexSubImage2D, rax
lea rdi, aGlcompressedte_4; "glCompressedTexSubImage1D"
call [rsp+8+var_8]
mov cs:mjGlad_glCompressedTexSubImage1D, rax
lea rdi, aGlgetcompresse; "glGetCompressedTexImage"
call [rsp+8+var_8]
mov cs:mjGlad_glGetCompressedTexImage, rax
lea rdi, aGlclientactive; "glClientActiveTexture"
call [rsp+8+var_8]
mov cs:mjGlad_glClientActiveTexture, rax
lea rdi, aGlmultitexcoor; "glMultiTexCoord1d"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord1d, rax
lea rdi, aGlmultitexcoor_0; "glMultiTexCoord1dv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord1dv, rax
lea rdi, aGlmultitexcoor_1; "glMultiTexCoord1f"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord1f, rax
lea rdi, aGlmultitexcoor_2; "glMultiTexCoord1fv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord1fv, rax
lea rdi, aGlmultitexcoor_3; "glMultiTexCoord1i"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord1i, rax
lea rdi, aGlmultitexcoor_4; "glMultiTexCoord1iv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord1iv, rax
lea rdi, aGlmultitexcoor_5; "glMultiTexCoord1s"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord1s, rax
lea rdi, aGlmultitexcoor_6; "glMultiTexCoord1sv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord1sv, rax
lea rdi, aGlmultitexcoor_7; "glMultiTexCoord2d"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord2d, rax
lea rdi, aGlmultitexcoor_8; "glMultiTexCoord2dv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord2dv, rax
lea rdi, aGlmultitexcoor_9; "glMultiTexCoord2f"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord2f, rax
lea rdi, aGlmultitexcoor_10; "glMultiTexCoord2fv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord2fv, rax
lea rdi, aGlmultitexcoor_11; "glMultiTexCoord2i"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord2i, rax
lea rdi, aGlmultitexcoor_12; "glMultiTexCoord2iv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord2iv, rax
lea rdi, aGlmultitexcoor_13; "glMultiTexCoord2s"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord2s, rax
lea rdi, aGlmultitexcoor_14; "glMultiTexCoord2sv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord2sv, rax
lea rdi, aGlmultitexcoor_15; "glMultiTexCoord3d"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord3d, rax
lea rdi, aGlmultitexcoor_16; "glMultiTexCoord3dv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord3dv, rax
lea rdi, aGlmultitexcoor_17; "glMultiTexCoord3f"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord3f, rax
lea rdi, aGlmultitexcoor_18; "glMultiTexCoord3fv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord3fv, rax
lea rdi, aGlmultitexcoor_19; "glMultiTexCoord3i"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord3i, rax
lea rdi, aGlmultitexcoor_20; "glMultiTexCoord3iv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord3iv, rax
lea rdi, aGlmultitexcoor_21; "glMultiTexCoord3s"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord3s, rax
lea rdi, aGlmultitexcoor_22; "glMultiTexCoord3sv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord3sv, rax
lea rdi, aGlmultitexcoor_23; "glMultiTexCoord4d"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord4d, rax
lea rdi, aGlmultitexcoor_24; "glMultiTexCoord4dv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord4dv, rax
lea rdi, aGlmultitexcoor_25; "glMultiTexCoord4f"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord4f, rax
lea rdi, aGlmultitexcoor_26; "glMultiTexCoord4fv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord4fv, rax
lea rdi, aGlmultitexcoor_27; "glMultiTexCoord4i"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord4i, rax
lea rdi, aGlmultitexcoor_28; "glMultiTexCoord4iv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord4iv, rax
lea rdi, aGlmultitexcoor_29; "glMultiTexCoord4s"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord4s, rax
lea rdi, aGlmultitexcoor_30; "glMultiTexCoord4sv"
call [rsp+8+var_8]
mov cs:mjGlad_glMultiTexCoord4sv, rax
lea rdi, aGlloadtranspos; "glLoadTransposeMatrixf"
call [rsp+8+var_8]
mov cs:mjGlad_glLoadTransposeMatrixf, rax
lea rdi, aGlloadtranspos_0; "glLoadTransposeMatrixd"
call [rsp+8+var_8]
mov cs:mjGlad_glLoadTransposeMatrixd, rax
lea rdi, aGlmulttranspos; "glMultTransposeMatrixf"
call [rsp+8+var_8]
mov cs:mjGlad_glMultTransposeMatrixf, rax
lea rdi, aGlmulttranspos_0; "glMultTransposeMatrixd"
call [rsp+8+var_8]
mov cs:mjGlad_glMultTransposeMatrixd, rax
loc_4772D1:
pop rax
retn
| long long ( * mjGlad_load_GL_VERSION_1_3(long long ( *a1)(const char *)))(const char *)
{
if ( mjGLAD_GL_VERSION_1_3 )
{
mjGlad_glActiveTexture = a1("glActiveTexture");
mjGlad_glSampleCoverage = a1("glSampleCoverage");
mjGlad_glCompressedTexImage3D = a1("glCompressedTexImage3D");
mjGlad_glCompressedTexImage2D = a1("glCompressedTexImage2D");
mjGlad_glCompressedTexImage1D = a1("glCompressedTexImage1D");
mjGlad_glCompressedTexSubImage3D = a1("glCompressedTexSubImage3D");
mjGlad_glCompressedTexSubImage2D = a1("glCompressedTexSubImage2D");
mjGlad_glCompressedTexSubImage1D = a1("glCompressedTexSubImage1D");
mjGlad_glGetCompressedTexImage = a1("glGetCompressedTexImage");
mjGlad_glClientActiveTexture = a1("glClientActiveTexture");
mjGlad_glMultiTexCoord1d = a1("glMultiTexCoord1d");
mjGlad_glMultiTexCoord1dv = a1("glMultiTexCoord1dv");
mjGlad_glMultiTexCoord1f = a1("glMultiTexCoord1f");
mjGlad_glMultiTexCoord1fv = a1("glMultiTexCoord1fv");
mjGlad_glMultiTexCoord1i = a1("glMultiTexCoord1i");
mjGlad_glMultiTexCoord1iv = a1("glMultiTexCoord1iv");
mjGlad_glMultiTexCoord1s = a1("glMultiTexCoord1s");
mjGlad_glMultiTexCoord1sv = a1("glMultiTexCoord1sv");
mjGlad_glMultiTexCoord2d = a1("glMultiTexCoord2d");
mjGlad_glMultiTexCoord2dv = a1("glMultiTexCoord2dv");
mjGlad_glMultiTexCoord2f = a1("glMultiTexCoord2f");
mjGlad_glMultiTexCoord2fv = a1("glMultiTexCoord2fv");
mjGlad_glMultiTexCoord2i = a1("glMultiTexCoord2i");
mjGlad_glMultiTexCoord2iv = a1("glMultiTexCoord2iv");
mjGlad_glMultiTexCoord2s = a1("glMultiTexCoord2s");
mjGlad_glMultiTexCoord2sv = a1("glMultiTexCoord2sv");
mjGlad_glMultiTexCoord3d = a1("glMultiTexCoord3d");
mjGlad_glMultiTexCoord3dv = a1("glMultiTexCoord3dv");
mjGlad_glMultiTexCoord3f = a1("glMultiTexCoord3f");
mjGlad_glMultiTexCoord3fv = a1("glMultiTexCoord3fv");
mjGlad_glMultiTexCoord3i = a1("glMultiTexCoord3i");
mjGlad_glMultiTexCoord3iv = a1("glMultiTexCoord3iv");
mjGlad_glMultiTexCoord3s = a1("glMultiTexCoord3s");
mjGlad_glMultiTexCoord3sv = a1("glMultiTexCoord3sv");
mjGlad_glMultiTexCoord4d = a1("glMultiTexCoord4d");
mjGlad_glMultiTexCoord4dv = a1("glMultiTexCoord4dv");
mjGlad_glMultiTexCoord4f = a1("glMultiTexCoord4f");
mjGlad_glMultiTexCoord4fv = a1("glMultiTexCoord4fv");
mjGlad_glMultiTexCoord4i = a1("glMultiTexCoord4i");
mjGlad_glMultiTexCoord4iv = a1("glMultiTexCoord4iv");
mjGlad_glMultiTexCoord4s = a1("glMultiTexCoord4s");
mjGlad_glMultiTexCoord4sv = a1("glMultiTexCoord4sv");
mjGlad_glLoadTransposeMatrixf = a1("glLoadTransposeMatrixf");
mjGlad_glLoadTransposeMatrixd = a1("glLoadTransposeMatrixd");
mjGlad_glMultTransposeMatrixf = a1("glMultTransposeMatrixf");
mjGlad_glMultTransposeMatrixd = a1("glMultTransposeMatrixd");
}
return a1;
}
| _S_do_relocate:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP],RCX
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP]
CALL 0x0014cec0
ADD RSP,0x28
RET
|
/* std::vector<unsigned int, std::allocator<unsigned int> >::_S_do_relocate(unsigned int*, unsigned
int*, unsigned int*, std::allocator<unsigned int>&, std::integral_constant<bool, true>) */
void std::vector<unsigned_int,std::allocator<unsigned_int>>::_S_do_relocate
(uint *param_1,uint *param_2,uint *param_3,allocator *param_4)
{
__relocate_a<unsigned_int*,unsigned_int*,std::allocator<unsigned_int>>
(param_1,param_2,param_3,param_4);
return;
}
|
|
6,418 | minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!object) throw std::runtime_error("CallExpr.object is null");
auto obj = object->evaluate(context);
if (!obj.is_callable()) {
throw std::runtime_error("Object is not callable: " + obj.dump(2));
}
auto vargs = args.evaluate(context);
return obj.call(context, vargs);
} | O2 | cpp | minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r15
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x6f650
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x6371a
cmpq $0x0, 0x30(%r12)
je 0x6f680
addq $0x30, %r15
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6d3c0
leaq 0x50(%rsp), %rsi
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6e13c
movq %rsp, %rdi
callq 0x6e220
leaq 0x50(%rsp), %rdi
callq 0x639aa
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x46d72(%rip), %rsi # 0xb63d4
movq %rax, %rdi
callq 0x24320
movq 0x9197f(%rip), %rsi # 0x100ff0
movq 0x918d8(%rip), %rdx # 0x100f50
movq %rbx, %rdi
callq 0x24ef0
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
pushq $0x2
popq %rdx
xorl %ecx, %ecx
callq 0x63b98
leaq 0x46fc9(%rip), %rsi # 0xb666f
movq %rsp, %rdi
leaq 0x30(%rsp), %rdx
callq 0x592be
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x24e20
xorl %ebp, %ebp
movq 0x91926(%rip), %rsi # 0x100ff0
movq 0x9187f(%rip), %rdx # 0x100f50
movq %rbx, %rdi
callq 0x24ef0
movq %rax, %r14
movq %rsp, %rdi
callq 0x251d8
jmp 0x6f6ec
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x251d8
testb %bpl, %bpl
jne 0x6f700
jmp 0x6f727
movq %rax, %r14
movq %rbx, %rdi
callq 0x24680
jmp 0x6f727
movq %rax, %r14
movq %rbx, %rdi
callq 0x24680
jmp 0x6f731
movq %rax, %r14
movq %rsp, %rdi
callq 0x6e220
jmp 0x6f727
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x639aa
movq %r14, %rdi
callq 0x24f80
nop
| _ZNK5minja8CallExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 0A0h
mov r15, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz short loc_6F650
mov r14, rdx
mov rbx, rdi
lea r12, [rsp+0C8h+var_78]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
cmp qword ptr [r12+30h], 0
jz short loc_6F680
add r15, 30h ; '0'
mov rdi, rsp
mov rsi, r15
mov rdx, r14
call _ZNK5minja19ArgumentsExpression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)
lea rsi, [rsp+0C8h+var_78]
mov rcx, rsp
mov rdi, rbx
mov rdx, r14
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
mov rdi, rsp; this
call _ZN5minja14ArgumentsValueD2Ev; minja::ArgumentsValue::~ArgumentsValue()
lea rdi, [rsp+0C8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, rbx
add rsp, 0A0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_6F650:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMethodcallexpr+6; char *
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_6F680:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0C8h+var_98]
lea rsi, [rsp+0C8h+var_78]
push 2
pop rdx
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aObjectIsNotCal; "Object is not callable: "
mov rdi, rsp
lea rdx, [rsp+0C8h+var_98]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6F6EC
mov r14, rax
mov bpl, 1
loc_6F6EC:
lea rdi, [rsp+0C8h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_6F700
jmp short loc_6F727
mov r14, rax
loc_6F700:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_6F727
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_6F731
mov r14, rax
mov rdi, rsp; this
call _ZN5minja14ArgumentsValueD2Ev; minja::ArgumentsValue::~ArgumentsValue()
jmp short loc_6F727
mov r14, rax
loc_6F727:
lea rdi, [rsp+0C8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_6F731:
mov rdi, r14
call __Unwind_Resume
| long long minja::CallExpr::do_evaluate(long long a1, long long a2)
{
void (***v3)(void); // rsi
std::runtime_error *exception; // rbx
void *v6; // rbx
_OWORD v7[3]; // [rsp+0h] [rbp-C8h] BYREF
_BYTE v8[32]; // [rsp+30h] [rbp-98h] BYREF
_BYTE v9[48]; // [rsp+50h] [rbp-78h] BYREF
long long v10; // [rsp+80h] [rbp-48h]
v3 = *(void (****)(void))(a2 + 32);
if ( !v3 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "CallExpr.object is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v9, v3);
if ( !v10 )
{
v6 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v8, (long long)v9, 2u, 0);
std::operator+<char>((long long)v7, (long long)"Object is not callable: ", (long long)v8);
std::runtime_error::runtime_error(v6, v7);
__cxa_throw(
v6,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::ArgumentsExpression::evaluate(v7, (void (*****)(void))(a2 + 48));
minja::Value::call(a1, (long long)v9);
minja::ArgumentsValue::~ArgumentsValue((minja::ArgumentsValue *)v7);
minja::Value::~Value((minja::Value *)v9);
return a1;
}
| do_evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV R15,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x0016f650
MOV R14,RDX
MOV RBX,RDI
LEA R12,[RSP + 0x50]
MOV RDI,R12
CALL 0x0016371a
CMP qword ptr [R12 + 0x30],0x0
JZ 0x0016f680
ADD R15,0x30
LAB_0016f60a:
MOV RDI,RSP
MOV RSI,R15
MOV RDX,R14
CALL 0x0016d3c0
LAB_0016f618:
LEA RSI,[RSP + 0x50]
MOV RCX,RSP
MOV RDI,RBX
MOV RDX,R14
CALL 0x0016e13c
LAB_0016f62b:
MOV RDI,RSP
CALL 0x0016e220
LEA RDI,[RSP + 0x50]
CALL 0x001639aa
MOV RAX,RBX
ADD RSP,0xa0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0016f650:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_0016f65b:
LEA RSI,[0x1b63d4]
MOV RDI,RAX
CALL 0x00124320
LAB_0016f66a:
MOV RSI,qword ptr [0x00200ff0]
MOV RDX,qword ptr [0x00200f50]
MOV RDI,RBX
CALL 0x00124ef0
LAB_0016f680:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_0016f68b:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x50]
PUSH 0x2
POP RDX
XOR ECX,ECX
CALL 0x00163b98
LAB_0016f69f:
LEA RSI,[0x1b666f]
MOV RDI,RSP
LEA RDX,[RSP + 0x30]
CALL 0x001592be
MOV BPL,0x1
LAB_0016f6b6:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00124e20
XOR EBP,EBP
MOV RSI,qword ptr [0x00200ff0]
MOV RDX,qword ptr [0x00200f50]
MOV RDI,RBX
CALL 0x00124ef0
|
/* minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
CallExpr * __thiscall minja::CallExpr::do_evaluate(CallExpr *this,shared_ptr *param_1)
{
runtime_error *prVar1;
ArgumentsExpression aAStack_c8 [48];
int1 local_98 [32];
Expression local_78 [48];
long local_48;
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016f65b to 0016f669 has its CatchHandler @ 0016f70a */
std::runtime_error::runtime_error(prVar1,"CallExpr.object is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_00200ff0,PTR__runtime_error_00200f50);
}
Expression::evaluate(local_78,*(shared_ptr **)(param_1 + 0x20));
if (local_48 != 0) {
/* try { // try from 0016f60a to 0016f617 has its CatchHandler @ 0016f724 */
ArgumentsExpression::evaluate(aAStack_c8,param_1 + 0x30);
/* try { // try from 0016f618 to 0016f62a has its CatchHandler @ 0016f717 */
Value::call(this,(ArgumentsValue *)local_78);
ArgumentsValue::~ArgumentsValue((ArgumentsValue *)aAStack_c8);
Value::~Value((Value *)local_78);
return this;
}
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016f68b to 0016f69e has its CatchHandler @ 0016f6fd */
Value::dump_abi_cxx11_((int)local_98,SUB81(local_78,0));
/* try { // try from 0016f69f to 0016f6b2 has its CatchHandler @ 0016f6e6 */
std::operator+((char *)aAStack_c8,(string *)"Object is not callable: ");
/* try { // try from 0016f6b6 to 0016f6d8 has its CatchHandler @ 0016f6d9 */
std::runtime_error::runtime_error(prVar1,(string *)aAStack_c8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_00200ff0,PTR__runtime_error_00200f50);
}
|
|
6,419 | pagecache_delete_by_link | eloqsql/storage/maria/ma_pagecache.c | my_bool pagecache_delete_by_link(PAGECACHE *pagecache,
PAGECACHE_BLOCK_LINK *block,
enum pagecache_page_lock lock,
my_bool flush)
{
my_bool error= 0;
enum pagecache_page_pin pin= PAGECACHE_PIN_LEFT_PINNED;
DBUG_ENTER("pagecache_delete_by_link");
DBUG_PRINT("enter", ("fd: %d block %p %s %s",
block->hash_link->file.file,
block,
page_cache_page_lock_str[lock],
page_cache_page_pin_str[pin]));
DBUG_ASSERT(lock == PAGECACHE_LOCK_WRITE ||
lock == PAGECACHE_LOCK_LEFT_WRITELOCKED);
DBUG_ASSERT(block->pins != 0); /* should be pinned */
if (pagecache->can_be_used)
{
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
if (!pagecache->can_be_used)
goto end;
/*
This block should be pinned (i.e. has not zero request counter) =>
Such block can't be chosen for eviction.
*/
DBUG_ASSERT((block->status &
(PCBLOCK_IN_SWITCH | PCBLOCK_REASSIGNED)) == 0);
/* This lock is deleted in pagecache_delete_internal() called below */
inc_counter_for_resize_op(pagecache);
/*
make_lock_and_pin() can't fail here, because we are keeping pin on the
block and it can't be evicted (which is cause of lock fail and retry)
*/
if (make_lock_and_pin(pagecache, block, lock, pin, FALSE))
DBUG_ASSERT(0);
/*
get_present_hash_link() side effect emulation before call
pagecache_delete_internal()
*/
block->hash_link->requests++;
error= pagecache_delete_internal(pagecache, block, block->hash_link,
flush);
end:
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
}
DBUG_RETURN(error);
} | O3 | c | pagecache_delete_by_link:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, 0x1aa(%rdi)
je 0x3309c
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r14
leaq 0xc8(%rdi), %rbx
cmpq $0x0, 0x108(%rdi)
jne 0x330ca
movq %rbx, %rdi
callq 0x29220
cmpb $0x0, 0x1aa(%r14)
je 0x330a1
incq 0x68(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl %r13d, %edx
xorl %ecx, %ecx
callq 0x31b53
movq 0x20(%r15), %rax
incl 0x68(%rax)
movq 0x20(%r15), %rdx
movsbl %r12b, %ecx
movq %r14, %rdi
movq %r15, %rsi
callq 0x330f5
movl %eax, %r15d
jmp 0x330a4
xorl %r15d, %r15d
jmp 0x330b8
xorl %r15d, %r15d
movq 0x108(%r14), %rdi
testq %rdi, %rdi
jne 0x330e3
movq %rbx, %rdi
callq 0x291e0
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa61da(%rip), %rsi # 0xd92ab
movq %rbx, %rdi
movl $0x1002, %edx # imm = 0x1002
callq 0x2eb8f
jmp 0x3305f
leaq 0x352f26(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x330b0
| pagecache_delete_by_link:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
cmp byte ptr [rdi+1AAh], 0
jz short loc_3309C
mov r12d, ecx
mov r13d, edx
mov r15, rsi
mov r14, rdi
lea rbx, [rdi+0C8h]
cmp qword ptr [rdi+108h], 0
jnz short loc_330CA
mov rdi, rbx
call _pthread_mutex_lock
loc_3305F:
cmp byte ptr [r14+1AAh], 0
jz short loc_330A1
inc qword ptr [r14+68h]
mov rdi, r14
mov rsi, r15
mov edx, r13d
xor ecx, ecx
call make_lock_and_pin
mov rax, [r15+20h]
inc dword ptr [rax+68h]
mov rdx, [r15+20h]
movsx ecx, r12b
mov rdi, r14
mov rsi, r15
call pagecache_delete_internal
mov r15d, eax
jmp short loc_330A4
loc_3309C:
xor r15d, r15d
jmp short loc_330B8
loc_330A1:
xor r15d, r15d
loc_330A4:
mov rdi, [r14+108h]
test rdi, rdi
jnz short loc_330E3
loc_330B0:
mov rdi, rbx
call _pthread_mutex_unlock
loc_330B8:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_330CA:
lea rsi, aWorkspaceLlm4b_25; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 1002h
call psi_mutex_lock
jmp loc_3305F
loc_330E3:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_330B0
| long long pagecache_delete_by_link(long long a1, long long a2, int a3, char a4)
{
long long v6; // rbx
unsigned int v7; // r15d
long long v8; // rdi
if ( *(_BYTE *)(a1 + 426) )
{
v6 = a1 + 200;
if ( *(_QWORD *)(a1 + 264) )
psi_mutex_lock(
a1 + 200,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x1002u);
else
pthread_mutex_lock(a1 + 200);
if ( *(_BYTE *)(a1 + 426) )
{
++*(_QWORD *)(a1 + 104);
make_lock_and_pin(a1, a2, a3, 0);
++*(_DWORD *)(*(_QWORD *)(a2 + 32) + 104LL);
v7 = pagecache_delete_internal(a1, a2, *(_QWORD *)(a2 + 32), (unsigned int)a4);
}
else
{
v7 = 0;
}
v8 = *(_QWORD *)(a1 + 264);
if ( v8 )
((void ( *)(long long))PSI_server[44])(v8);
pthread_mutex_unlock(v6);
}
else
{
return 0;
}
return v7;
}
| pagecache_delete_by_link:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
CMP byte ptr [RDI + 0x1aa],0x0
JZ 0x0013309c
MOV R12D,ECX
MOV R13D,EDX
MOV R15,RSI
MOV R14,RDI
LEA RBX,[RDI + 0xc8]
CMP qword ptr [RDI + 0x108],0x0
JNZ 0x001330ca
MOV RDI,RBX
CALL 0x00129220
LAB_0013305f:
CMP byte ptr [R14 + 0x1aa],0x0
JZ 0x001330a1
INC qword ptr [R14 + 0x68]
MOV RDI,R14
MOV RSI,R15
MOV EDX,R13D
XOR ECX,ECX
CALL 0x00131b53
MOV RAX,qword ptr [R15 + 0x20]
INC dword ptr [RAX + 0x68]
MOV RDX,qword ptr [R15 + 0x20]
MOVSX ECX,R12B
MOV RDI,R14
MOV RSI,R15
CALL 0x001330f5
MOV R15D,EAX
JMP 0x001330a4
LAB_0013309c:
XOR R15D,R15D
JMP 0x001330b8
LAB_001330a1:
XOR R15D,R15D
LAB_001330a4:
MOV RDI,qword ptr [R14 + 0x108]
TEST RDI,RDI
JNZ 0x001330e3
LAB_001330b0:
MOV RDI,RBX
CALL 0x001291e0
LAB_001330b8:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001330ca:
LEA RSI,[0x1d92ab]
MOV RDI,RBX
MOV EDX,0x1002
CALL 0x0012eb8f
JMP 0x0013305f
LAB_001330e3:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001330b0
|
int4 pagecache_delete_by_link(long param_1,long param_2,int4 param_3,char param_4)
{
int *piVar1;
pthread_mutex_t *__mutex;
int4 uVar2;
if (*(char *)(param_1 + 0x1aa) == '\0') {
uVar2 = 0;
}
else {
__mutex = (pthread_mutex_t *)(param_1 + 200);
if (*(long *)(param_1 + 0x108) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c"
,0x1002);
}
if (*(char *)(param_1 + 0x1aa) == '\0') {
uVar2 = 0;
}
else {
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + 1;
make_lock_and_pin(param_1,param_2,param_3,0);
piVar1 = (int *)(*(long *)(param_2 + 0x20) + 0x68);
*piVar1 = *piVar1 + 1;
uVar2 = pagecache_delete_internal
(param_1,param_2,*(int8 *)(param_2 + 0x20),(int)param_4);
}
if (*(long *)(param_1 + 0x108) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
}
return uVar2;
}
|
|
6,420 | testing::TestResult::GetTestProperty(int) const | giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc | const TestProperty& TestResult::GetTestProperty(int i) const {
if (i < 0 || i >= test_property_count()) internal::posix::Abort();
return test_properties_.at(static_cast<size_t>(i));
} | O3 | cpp | testing::TestResult::GetTestProperty(int) const:
pushq %rax
testl %esi, %esi
js 0x1f87f
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rdx
subq %rax, %rdx
movq %rdx, %rcx
shrq $0x6, %rcx
cmpl %esi, %ecx
jle 0x1f87f
movl %esi, %esi
sarq $0x6, %rdx
cmpq %rsi, %rdx
jbe 0x1f884
shlq $0x6, %rsi
addq %rsi, %rax
popq %rcx
retq
callq 0x321ea
leaq 0x24f10(%rip), %rdi # 0x4479b
xorl %eax, %eax
callq 0x8860
| _ZNK7testing10TestResult15GetTestPropertyEi:
push rax
test esi, esi
js short loc_1F87F
mov rax, [rdi+50h]
mov rdx, [rdi+58h]
sub rdx, rax
mov rcx, rdx
shr rcx, 6
cmp ecx, esi
jle short loc_1F87F
mov esi, esi
sar rdx, 6
cmp rdx, rsi
jbe short loc_1F884
shl rsi, 6
add rax, rsi
pop rcx
retn
loc_1F87F:
call _ZN7testing8internal5posix5AbortEv; testing::internal::posix::Abort(void)
loc_1F884:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
| long long testing::TestResult::GetTestProperty(testing::TestResult *this, int a2)
{
long long v2; // rax
unsigned long long v3; // rdx
if ( a2 < 0 || (v2 = *((_QWORD *)this + 10), (int)((unsigned long long)(*((_QWORD *)this + 11) - v2) >> 6) <= a2) )
testing::internal::posix::Abort(this);
v3 = (*((_QWORD *)this + 11) - v2) >> 6;
if ( v3 <= (unsigned int)a2 )
std::__throw_out_of_range_fmt(
"vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",
(unsigned int)a2,
v3);
return ((unsigned long long)(unsigned int)a2 << 6) + v2;
}
| GetTestProperty:
PUSH RAX
TEST ESI,ESI
JS 0x0011f87f
MOV RAX,qword ptr [RDI + 0x50]
MOV RDX,qword ptr [RDI + 0x58]
SUB RDX,RAX
MOV RCX,RDX
SHR RCX,0x6
CMP ECX,ESI
JLE 0x0011f87f
MOV ESI,ESI
SAR RDX,0x6
CMP RDX,RSI
JBE 0x0011f884
SHL RSI,0x6
ADD RAX,RSI
POP RCX
RET
LAB_0011f87f:
CALL 0x001321ea
LAB_0011f884:
LEA RDI,[0x14479b]
XOR EAX,EAX
CALL 0x00108860
|
/* testing::TestResult::GetTestProperty(int) const */
ulong __thiscall testing::TestResult::GetTestProperty(TestResult *this,int param_1)
{
ulong uVar1;
char *pcVar2;
if (-1 < param_1) {
uVar1 = *(long *)(this + 0x58) - *(long *)(this + 0x50);
if (param_1 < (int)(uVar1 >> 6)) {
if ((ulong)(uint)param_1 < (ulong)((long)uVar1 >> 6)) {
return *(long *)(this + 0x50) + (ulong)(uint)param_1 * 0x40;
}
goto LAB_0011f884;
}
}
internal::posix::Abort();
LAB_0011f884:
pcVar2 = "vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)";
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)");
return (ulong)(*(long *)(pcVar2 + 0x58) - *(long *)(pcVar2 + 0x50)) >> 6;
}
|
|
6,421 | free_full_pages | eloqsql/storage/maria/ma_blockrec.c | static my_bool free_full_pages(MARIA_HA *info, MARIA_ROW *row)
{
uchar log_data[FILEID_STORE_SIZE + PAGERANGE_STORE_SIZE];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
LSN lsn;
size_t extents_length;
uchar *extents= row->extents;
DBUG_ENTER("free_full_pages");
if (info->s->now_transactional)
{
/* Compact events by removing filler and tail events */
uchar *new_block= 0;
uchar *end, *to, *compact_extent_info;
my_bool res, buff_alloced;
uint extents_count;
alloc_on_stack(*info->stack_end_ptr, compact_extent_info, buff_alloced,
row->extents_count * ROW_EXTENT_SIZE);
if (!compact_extent_info)
DBUG_RETURN(1);
to= compact_extent_info;
for (end= extents + row->extents_count * ROW_EXTENT_SIZE ;
extents < end ;
extents+= ROW_EXTENT_SIZE)
{
uint page_count= uint2korr(extents + ROW_EXTENT_PAGE_SIZE);
page_count&= ~START_EXTENT_BIT;
if (! (page_count & TAIL_BIT) && page_count != 0)
{
/* Found correct extent */
if (!new_block)
new_block= extents; /* First extent in range */
continue;
}
/* Found extent to remove, copy everything found so far */
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
new_block= 0;
}
}
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
}
if (!unlikely(extents_length= (uint) (to - compact_extent_info)))
{
/*
No ranges. This happens in the rear case when we have a allocated
place for a blob on a tail page but it did fit into the main page.
*/
stack_alloc_free(compact_extent_info, buff_alloced);
DBUG_RETURN(0);
}
extents_count= (uint) (extents_length / ROW_EXTENT_SIZE);
pagerange_store(log_data + FILEID_STORE_SIZE, extents_count);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= compact_extent_info;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= extents_length;
res= translog_write_record(&lsn, LOGREC_REDO_FREE_BLOCKS, info->trn,
info,
(translog_size_t) (sizeof(log_data) +
extents_length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL);
stack_alloc_free(compact_extent_info, buff_alloced);
if (res)
DBUG_RETURN(1);
}
DBUG_RETURN(_ma_bitmap_free_full_pages(info, row->extents,
row->extents_count));
} | O0 | c | free_full_pages:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x5363e
movq $0x0, -0x80(%rbp)
movq -0x20(%rbp), %rax
imull $0x7, 0xac(%rax), %eax
movl %eax, %eax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
leaq -0xa8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
cmpq -0xa8(%rbp), %rax
jbe 0x533ba
movq -0xb0(%rbp), %rcx
subq -0xa8(%rbp), %rcx
movl $0x10000, %eax # imm = 0x10000
cmpq %rcx, %rax
jb 0x53386
movq -0xb0(%rbp), %rcx
subq -0xa8(%rbp), %rcx
movl $0x8000, %eax # imm = 0x8000
cmpq %rcx, %rax
jae 0x533ba
movl $0x1000, %eax # imm = 0x1000
cmpq -0xa8(%rbp), %rax
ja 0x533ba
movb $0x0, -0x9a(%rbp)
movq -0x20(%rbp), %rax
movl 0xac(%rax), %ecx
movl %ecx, %eax
shll $0x3, %eax
subl %ecx, %eax
movl %eax, %ecx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x98(%rbp)
jmp 0x533e3
movb $0x1, -0x9a(%rbp)
movq -0x20(%rbp), %rax
imull $0x7, 0xac(%rax), %eax
movl %eax, %eax
movl %eax, %esi
xorl %edi, %edi
movl $0x10010, %edx # imm = 0x10010
callq 0xf9ff0
movq %rax, -0x98(%rbp)
jmp 0x533e5
cmpq $0x0, -0x98(%rbp)
jne 0x533fa
jmp 0x533f1
movb $0x1, -0xd(%rbp)
jmp 0x5365e
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x78(%rbp), %rax
movq -0x20(%rbp), %rcx
imull $0x7, 0xac(%rcx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x88(%rbp), %rax
jae 0x534dd
movq -0x78(%rbp), %rax
movzwl 0x5(%rax), %eax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
andl $0xffffbfff, %eax # imm = 0xFFFFBFFF
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0x5347d
cmpl $0x0, -0xb4(%rbp)
je 0x5347d
cmpq $0x0, -0x80(%rbp)
jne 0x5347b
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x534cc
cmpq $0x0, -0x80(%rbp)
je 0x534ca
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xc0(%rbp)
movq -0x90(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0xc0(%rbp), %rdx
callq 0x2a0c0
movq -0xc0(%rbp), %rax
addq -0x90(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x0, -0x80(%rbp)
jmp 0x534cc
movq -0x78(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x78(%rbp)
jmp 0x53423
cmpq $0x0, -0x80(%rbp)
je 0x53522
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xc8(%rbp)
movq -0x90(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x2a0c0
movq -0xc8(%rbp), %rax
addq -0x90(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq -0x98(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x53569
movq -0x98(%rbp), %rdi
movsbl -0x9a(%rbp), %esi
callq 0x550b0
movb $0x0, -0xd(%rbp)
jmp 0x5365e
movq -0x70(%rbp), %rax
movl $0x7, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0xa0(%rbp)
leaq -0xc(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xd0(%rbp)
movl -0xa0(%rbp), %eax
movw %ax, %cx
movq -0xd0(%rbp), %rax
movw %cx, (%rax)
leaq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x4, -0x38(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
movq -0x70(%rbp), %rax
addq $0x4, %rax
movl %eax, %r8d
leaq -0x60(%rbp), %r10
leaq -0xc(%rbp), %rax
leaq -0x68(%rbp), %rdi
movl $0x8, %esi
movl $0x4, %r9d
xorl %r11d, %r11d
subq $0x20, %rsp
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x8bc40
addq $0x20, %rsp
movb %al, -0x99(%rbp)
movq -0x98(%rbp), %rdi
movsbl -0x9a(%rbp), %esi
callq 0x550b0
cmpb $0x0, -0x99(%rbp)
je 0x5363c
jmp 0x53636
movb $0x1, -0xd(%rbp)
jmp 0x5365e
jmp 0x5363e
jmp 0x53640
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rax
movl 0xac(%rax), %edx
callq 0x608a0
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
movb %al, -0xd1(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x53684
movb -0xd1(%rbp), %al
movq %rbp, %rsp
popq %rbp
retq
callq 0x2a260
nopl (%rax)
| free_full_pages:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov [rbp+var_78], rax
mov rax, [rbp+var_18]
mov rax, [rax]
cmp byte ptr [rax+7E7h], 0
jz loc_5363E
mov [rbp+var_80], 0
mov rax, [rbp+var_20]
imul eax, [rax+0ACh], 7
mov eax, eax
mov [rbp+var_A8], rax
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov rax, [rax]
lea rcx, [rbp+var_A8]
sub rax, rcx
mov [rbp+var_B0], rax
mov rax, [rbp+var_B0]
cmp rax, [rbp+var_A8]
jbe short loc_533BA
mov rcx, [rbp+var_B0]
sub rcx, [rbp+var_A8]
mov eax, 10000h
cmp rax, rcx
jb short loc_53386
mov rcx, [rbp+var_B0]
sub rcx, [rbp+var_A8]
mov eax, 8000h
cmp rax, rcx
jnb short loc_533BA
mov eax, 1000h
cmp rax, [rbp+var_A8]
ja short loc_533BA
loc_53386:
mov [rbp+var_9A], 0
mov rax, [rbp+var_20]
mov ecx, [rax+0ACh]
mov eax, ecx
shl eax, 3
sub eax, ecx
mov ecx, eax
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_98], rax
jmp short loc_533E3
loc_533BA:
mov [rbp+var_9A], 1
mov rax, [rbp+var_20]
imul eax, [rax+0ACh], 7
mov eax, eax
mov esi, eax
xor edi, edi
mov edx, 10010h
call my_malloc
mov [rbp+var_98], rax
loc_533E3:
jmp short $+2
loc_533E5:
cmp [rbp+var_98], 0
jnz short loc_533FA
jmp short $+2
loc_533F1:
mov [rbp+var_D], 1
jmp loc_5365E
loc_533FA:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
mov rax, [rbp+var_78]
mov rcx, [rbp+var_20]
imul ecx, [rcx+0ACh], 7
mov ecx, ecx
add rax, rcx
mov [rbp+var_88], rax
loc_53423:
mov rax, [rbp+var_78]
cmp rax, [rbp+var_88]
jnb loc_534DD
mov rax, [rbp+var_78]
movzx eax, word ptr [rax+5]
mov [rbp+var_B4], eax
mov eax, [rbp+var_B4]
and eax, 0FFFFBFFFh
mov [rbp+var_B4], eax
mov eax, [rbp+var_B4]
and eax, 8000h
cmp eax, 0
jnz short loc_5347D
cmp [rbp+var_B4], 0
jz short loc_5347D
cmp [rbp+var_80], 0
jnz short loc_5347B
mov rax, [rbp+var_78]
mov [rbp+var_80], rax
loc_5347B:
jmp short loc_534CC
loc_5347D:
cmp [rbp+var_80], 0
jz short loc_534CA
mov rax, [rbp+var_78]
mov rcx, [rbp+var_80]
sub rax, rcx
mov [rbp+var_C0], rax
mov rdi, [rbp+var_90]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_C0]
call _memcpy
mov rax, [rbp+var_C0]
add rax, [rbp+var_90]
mov [rbp+var_90], rax
mov [rbp+var_80], 0
loc_534CA:
jmp short $+2
loc_534CC:
mov rax, [rbp+var_78]
add rax, 7
mov [rbp+var_78], rax
jmp loc_53423
loc_534DD:
cmp [rbp+var_80], 0
jz short loc_53522
mov rax, [rbp+var_78]
mov rcx, [rbp+var_80]
sub rax, rcx
mov [rbp+var_C8], rax
mov rdi, [rbp+var_90]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_C8]
call _memcpy
mov rax, [rbp+var_C8]
add rax, [rbp+var_90]
mov [rbp+var_90], rax
loc_53522:
mov rax, [rbp+var_90]
mov rcx, [rbp+var_98]
sub rax, rcx
mov eax, eax
mov [rbp+var_70], rax
cmp rax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jnz short loc_53569
mov rdi, [rbp+var_98]
movsx esi, [rbp+var_9A]
call stack_alloc_free_1
mov [rbp+var_D], 0
jmp loc_5365E
loc_53569:
mov rax, [rbp+var_70]
mov ecx, 7
xor edx, edx
div rcx
mov [rbp+var_A0], eax
lea rax, [rbp+var_C]
add rax, 2
mov [rbp+var_D0], rax
mov eax, [rbp+var_A0]
mov cx, ax
mov rax, [rbp+var_D0]
mov [rax], cx
lea rax, [rbp+var_C]
mov [rbp+var_40], rax
mov [rbp+var_38], 4
mov rax, [rbp+var_98]
mov [rbp+var_30], rax
mov rax, [rbp+var_70]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rdx, [rax+8]
mov rcx, [rbp+var_18]
mov rax, [rbp+var_70]
add rax, 4
mov r8d, eax
lea r10, [rbp+var_60]
lea rax, [rbp+var_C]
lea rdi, [rbp+var_68]
mov esi, 8
mov r9d, 4
xor r11d, r11d
sub rsp, 20h
mov [rsp+100h+var_100], r10
mov [rsp+100h+var_F8], rax
mov [rsp+100h+var_F0], 0
call translog_write_record
add rsp, 20h
mov [rbp+var_99], al
mov rdi, [rbp+var_98]
movsx esi, [rbp+var_9A]
call stack_alloc_free_1
cmp [rbp+var_99], 0
jz short loc_5363C
jmp short $+2
loc_53636:
mov [rbp+var_D], 1
jmp short loc_5365E
loc_5363C:
jmp short $+2
loc_5363E:
jmp short $+2
loc_53640:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov rsi, [rax+10h]
mov rax, [rbp+var_20]
mov edx, [rax+0ACh]
call _ma_bitmap_free_full_pages
mov [rbp+var_D], al
loc_5365E:
mov al, [rbp+var_D]
mov [rbp+var_D1], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_53684
mov al, [rbp+var_D1]
mov rsp, rbp
pop rbp
retn
loc_53684:
call ___stack_chk_fail
| char free_full_pages(long long a1, long long a2)
{
_QWORD v3[3]; // [rsp+20h] [rbp-E0h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-C8h]
unsigned long long v5; // [rsp+40h] [rbp-C0h]
int v6; // [rsp+4Ch] [rbp-B4h]
unsigned long long v7; // [rsp+50h] [rbp-B0h]
unsigned long long v8; // [rsp+58h] [rbp-A8h] BYREF
int v9; // [rsp+60h] [rbp-A0h]
char v10; // [rsp+66h] [rbp-9Ah]
char v11; // [rsp+67h] [rbp-99h]
char *v12; // [rsp+68h] [rbp-98h]
char *v13; // [rsp+70h] [rbp-90h]
unsigned long long v14; // [rsp+78h] [rbp-88h]
unsigned long long v15; // [rsp+80h] [rbp-80h]
unsigned long long v16; // [rsp+88h] [rbp-78h]
unsigned long long v17; // [rsp+90h] [rbp-70h]
char v18; // [rsp+98h] [rbp-68h] BYREF
_BYTE v19[32]; // [rsp+A0h] [rbp-60h] BYREF
_BYTE *v20; // [rsp+C0h] [rbp-40h]
long long v21; // [rsp+C8h] [rbp-38h]
char *v22; // [rsp+D0h] [rbp-30h]
unsigned long long v23; // [rsp+D8h] [rbp-28h]
long long v24; // [rsp+E0h] [rbp-20h]
long long v25; // [rsp+E8h] [rbp-18h]
_BYTE v27[2]; // [rsp+F4h] [rbp-Ch] BYREF
__int16 v28; // [rsp+F6h] [rbp-Ah] BYREF
unsigned long long v29; // [rsp+F8h] [rbp-8h]
v29 = __readfsqword(0x28u);
v25 = a1;
v24 = a2;
v16 = *(_QWORD *)(a2 + 16);
if ( !*(_BYTE *)(*(_QWORD *)a1 + 2023LL) )
return ma_bitmap_free_full_pages(v25, *(_QWORD *)(v24 + 16), *(unsigned int *)(v24 + 172));
v15 = 0LL;
v8 = (unsigned int)(7 * *(_DWORD *)(v24 + 172));
v7 = **(_QWORD **)(v25 + 120) - (_QWORD)&v8;
if ( v7 <= v8 || v7 - v8 <= 0x10000 && (v7 - v8 <= 0x8000 || v8 < 0x1000) )
{
v10 = 1;
v12 = (char *)my_malloc(0LL, (unsigned int)(7 * *(_DWORD *)(v24 + 172)), 65552LL);
}
else
{
v10 = 0;
v12 = (char *)v3 - (((unsigned int)(7 * *(_DWORD *)(v24 + 172)) + 15LL) & 0xFFFFFFFFFFFFFFF0LL);
}
if ( v12 )
{
v13 = v12;
v14 = (unsigned int)(7 * *(_DWORD *)(v24 + 172)) + v16;
while ( v16 < v14 )
{
v6 = *(unsigned __int16 *)(v16 + 5);
v6 &= ~0x4000u;
if ( (v6 & 0x8000) != 0 || !v6 )
{
if ( v15 )
{
v5 = v16 - v15;
memcpy(v13, v15, v16 - v15);
v13 += v5;
v15 = 0LL;
}
}
else if ( !v15 )
{
v15 = v16;
}
v16 += 7LL;
}
if ( v15 )
{
v4 = v16 - v15;
memcpy(v13, v15, v16 - v15);
v13 += v4;
}
v17 = (unsigned int)((_DWORD)v13 - (_DWORD)v12);
if ( (_DWORD)v13 == (_DWORD)v12 )
{
stack_alloc_free_1(v12, (unsigned int)v10);
return 0;
}
v9 = v17 / 7;
v3[2] = &v28;
v28 = v17 / 7;
v20 = v27;
v21 = 4LL;
v22 = v12;
v23 = v17;
v11 = translog_write_record(
(unsigned int)&v18,
8,
*(_QWORD *)(v25 + 8),
v25,
(int)v17 + 4,
4,
(long long)v19,
(long long)v27,
0LL);
stack_alloc_free_1(v12, (unsigned int)v10);
if ( v11 )
return 1;
return ma_bitmap_free_full_pages(v25, *(_QWORD *)(v24 + 16), *(unsigned int *)(v24 + 172));
}
return 1;
}
| free_full_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x0015363e
MOV qword ptr [RBP + -0x80],0x0
MOV RAX,qword ptr [RBP + -0x20]
IMUL EAX,dword ptr [RAX + 0xac],0x7
MOV EAX,EAX
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX]
LEA RCX,[RBP + -0xa8]
SUB RAX,RCX
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0xb0]
CMP RAX,qword ptr [RBP + -0xa8]
JBE 0x001533ba
MOV RCX,qword ptr [RBP + -0xb0]
SUB RCX,qword ptr [RBP + -0xa8]
MOV EAX,0x10000
CMP RAX,RCX
JC 0x00153386
MOV RCX,qword ptr [RBP + -0xb0]
SUB RCX,qword ptr [RBP + -0xa8]
MOV EAX,0x8000
CMP RAX,RCX
JNC 0x001533ba
MOV EAX,0x1000
CMP RAX,qword ptr [RBP + -0xa8]
JA 0x001533ba
LAB_00153386:
MOV byte ptr [RBP + -0x9a],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0xac]
MOV EAX,ECX
SHL EAX,0x3
SUB EAX,ECX
MOV ECX,EAX
ADD RCX,0xf
AND RCX,-0x10
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001533e3
LAB_001533ba:
MOV byte ptr [RBP + -0x9a],0x1
MOV RAX,qword ptr [RBP + -0x20]
IMUL EAX,dword ptr [RAX + 0xac],0x7
MOV EAX,EAX
MOV ESI,EAX
XOR EDI,EDI
MOV EDX,0x10010
CALL 0x001f9ff0
MOV qword ptr [RBP + -0x98],RAX
LAB_001533e3:
JMP 0x001533e5
LAB_001533e5:
CMP qword ptr [RBP + -0x98],0x0
JNZ 0x001533fa
JMP 0x001533f1
LAB_001533f1:
MOV byte ptr [RBP + -0xd],0x1
JMP 0x0015365e
LAB_001533fa:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x20]
IMUL ECX,dword ptr [RCX + 0xac],0x7
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x88],RAX
LAB_00153423:
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RBP + -0x88]
JNC 0x001534dd
MOV RAX,qword ptr [RBP + -0x78]
MOVZX EAX,word ptr [RAX + 0x5]
MOV dword ptr [RBP + -0xb4],EAX
MOV EAX,dword ptr [RBP + -0xb4]
AND EAX,0xffffbfff
MOV dword ptr [RBP + -0xb4],EAX
MOV EAX,dword ptr [RBP + -0xb4]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x0015347d
CMP dword ptr [RBP + -0xb4],0x0
JZ 0x0015347d
CMP qword ptr [RBP + -0x80],0x0
JNZ 0x0015347b
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x80],RAX
LAB_0015347b:
JMP 0x001534cc
LAB_0015347d:
CMP qword ptr [RBP + -0x80],0x0
JZ 0x001534ca
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x80]
SUB RAX,RCX
MOV qword ptr [RBP + -0xc0],RAX
MOV RDI,qword ptr [RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0xc0]
CALL 0x0012a0c0
MOV RAX,qword ptr [RBP + -0xc0]
ADD RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x90],RAX
MOV qword ptr [RBP + -0x80],0x0
LAB_001534ca:
JMP 0x001534cc
LAB_001534cc:
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x7
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00153423
LAB_001534dd:
CMP qword ptr [RBP + -0x80],0x0
JZ 0x00153522
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x80]
SUB RAX,RCX
MOV qword ptr [RBP + -0xc8],RAX
MOV RDI,qword ptr [RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0xc8]
CALL 0x0012a0c0
MOV RAX,qword ptr [RBP + -0xc8]
ADD RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x90],RAX
LAB_00153522:
MOV RAX,qword ptr [RBP + -0x90]
MOV RCX,qword ptr [RBP + -0x98]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x70],RAX
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JNZ 0x00153569
MOV RDI,qword ptr [RBP + -0x98]
MOVSX ESI,byte ptr [RBP + -0x9a]
CALL 0x001550b0
MOV byte ptr [RBP + -0xd],0x0
JMP 0x0015365e
LAB_00153569:
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,0x7
XOR EDX,EDX
DIV RCX
MOV dword ptr [RBP + -0xa0],EAX
LEA RAX,[RBP + -0xc]
ADD RAX,0x2
MOV qword ptr [RBP + -0xd0],RAX
MOV EAX,dword ptr [RBP + -0xa0]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0xd0]
MOV word ptr [RAX],CX
LEA RAX,[RBP + -0xc]
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x38],0x4
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0x4
MOV R8D,EAX
LEA R10,[RBP + -0x60]
LEA RAX,[RBP + -0xc]
LEA RDI,[RBP + -0x68]
MOV ESI,0x8
MOV R9D,0x4
XOR R11D,R11D
SUB RSP,0x20
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x0018bc40
ADD RSP,0x20
MOV byte ptr [RBP + -0x99],AL
MOV RDI,qword ptr [RBP + -0x98]
MOVSX ESI,byte ptr [RBP + -0x9a]
CALL 0x001550b0
CMP byte ptr [RBP + -0x99],0x0
JZ 0x0015363c
JMP 0x00153636
LAB_00153636:
MOV byte ptr [RBP + -0xd],0x1
JMP 0x0015365e
LAB_0015363c:
JMP 0x0015363e
LAB_0015363e:
JMP 0x00153640
LAB_00153640:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0xac]
CALL 0x001608a0
MOV byte ptr [RBP + -0xd],AL
LAB_0015365e:
MOV AL,byte ptr [RBP + -0xd]
MOV byte ptr [RBP + -0xd1],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00153684
MOV AL,byte ptr [RBP + -0xd1]
MOV RSP,RBP
POP RBP
RET
LAB_00153684:
CALL 0x0012a260
|
int8 free_full_pages(long *param_1,long param_2)
{
ushort uVar1;
int4 uVar2;
long lVar3;
int8 uVar4;
int1 auVar5 [16];
int1 *puVar6;
void *__src;
long *plVar7;
uint uVar8;
size_t sVar9;
int1 *puVar10;
int iVar11;
long in_FS_OFFSET;
int1 auStack_e8 [15];
int1 local_d9;
int2 *local_d8;
size_t local_d0;
size_t local_c8;
uint local_bc;
ulong local_b8;
ulong local_b0;
int4 local_a8;
char local_a2;
char local_a1;
int1 *local_a0;
int1 *local_98;
void *local_90;
void *local_88;
void *local_80;
ulong local_78;
int1 local_70 [8];
int1 local_68 [32];
int1 *local_48;
int8 local_40;
int1 *local_38;
ulong local_30;
long local_28;
long *local_20;
int1 local_15;
int1 local_14 [2];
int2 local_12;
long local_10;
puVar10 = auStack_e8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = *(void **)(param_2 + 0x10);
local_28 = param_2;
local_20 = param_1;
if (*(char *)(*param_1 + 0x7e7) != '\0') {
local_88 = (void *)0x0;
local_b0 = (ulong)(uint)(*(int *)(param_2 + 0xac) * 7);
local_b8 = *(long *)param_1[0xf] - (long)&local_b0;
if ((local_b0 < local_b8) &&
((0x10000 < local_b8 - local_b0 || ((0x8000 < local_b8 - local_b0 && (0xfff < local_b0))))))
{
local_a2 = '\0';
local_a0 = auStack_e8 +
-((ulong)(uint)(*(int *)(param_2 + 0xac) * 7) + 0xf & 0xfffffffffffffff0);
puVar10 = local_a0;
}
else {
local_a2 = '\x01';
local_a0 = (int1 *)my_malloc(0,*(int *)(param_2 + 0xac) * 7,0x10010);
puVar10 = auStack_e8;
}
if (local_a0 == (int1 *)0x0) {
local_15 = 1;
goto LAB_0015365e;
}
local_98 = local_a0;
local_90 = (void *)((long)local_80 + (ulong)(uint)(*(int *)(local_28 + 0xac) * 7));
for (; __src = local_88, puVar6 = local_98, local_80 < local_90;
local_80 = (void *)((long)local_80 + 7)) {
uVar1 = *(ushort *)((long)local_80 + 5);
local_bc = uVar1 & 0xffffbfff;
if (((uVar1 & 0x8000) == 0) && ((uVar1 & 0xbfff) != 0)) {
if (local_88 == (void *)0x0) {
local_88 = local_80;
}
}
else if (local_88 != (void *)0x0) {
sVar9 = (long)local_80 - (long)local_88;
local_c8 = sVar9;
*(int8 *)(puVar10 + -8) = 0x1534ad;
memcpy(puVar6,__src,sVar9);
local_98 = local_98 + local_c8;
local_88 = (void *)0x0;
}
}
if (local_88 != (void *)0x0) {
sVar9 = (long)local_80 - (long)local_88;
local_d0 = sVar9;
*(int8 *)(puVar10 + -8) = 0x15350d;
memcpy(puVar6,__src,sVar9);
local_98 = local_98 + local_d0;
}
plVar7 = local_20;
puVar6 = local_a0;
uVar8 = (int)local_98 - (int)local_a0;
local_78 = CONCAT44(0,uVar8);
if (local_78 == 0) {
iVar11 = (int)local_a2;
*(int8 *)(puVar10 + -8) = 0x153560;
stack_alloc_free(puVar6,iVar11);
local_15 = 0;
goto LAB_0015365e;
}
auVar5._8_8_ = 0;
auVar5._0_8_ = local_78;
local_a8 = SUB164(auVar5 / ZEXT816(7),0);
local_d8 = &local_12;
local_12 = SUB162(auVar5 / ZEXT816(7),0);
local_48 = local_14;
local_40 = 4;
local_38 = local_a0;
lVar3 = local_20[1];
local_30 = local_78;
*(int1 **)(puVar10 + -0x20) = local_68;
*(int1 **)(puVar10 + -0x18) = local_14;
*(int8 *)(puVar10 + -0x10) = 0;
*(int8 *)(puVar10 + -0x28) = 0x15360e;
local_a1 = translog_write_record(local_70,8,lVar3,plVar7,uVar8 + 4,4);
puVar6 = local_a0;
iVar11 = (int)local_a2;
*(int8 *)(puVar10 + -8) = 0x15362b;
stack_alloc_free(puVar6,iVar11);
if (local_a1 != '\0') {
local_15 = 1;
goto LAB_0015365e;
}
}
plVar7 = local_20;
uVar4 = *(int8 *)(local_28 + 0x10);
uVar2 = *(int4 *)(local_28 + 0xac);
*(int8 *)(puVar10 + -8) = 0x15365b;
local_15 = _ma_bitmap_free_full_pages(plVar7,uVar4,uVar2);
LAB_0015365e:
local_d9 = local_15;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar10 + -8) = 0x153689;
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_15);
}
|
|
6,422 | my_mb_wc_filename | eloqsql/strings/ctype-utf8.c | static int
my_mb_wc_filename(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int byte1, byte2;
if (s >= e)
return MY_CS_TOOSMALL;
if (*s < 128 && filename_safe_char[*s])
{
*pwc= *s;
return 1;
}
if (*s != MY_FILENAME_ESCAPE)
return MY_CS_ILSEQ;
if (s + 3 > e)
return MY_CS_TOOSMALL3;
byte1= s[1];
if (byte1 == 0)
return MY_CS_ILSEQ; /* avoid possible out-of-bounds read */
byte2= s[2];
if (byte1 >= 0x30 && byte1 <= 0x7F &&
byte2 >= 0x30 && byte2 <= 0x7F)
{
int code= (byte1 - 0x30) * 80 + byte2 - 0x30;
if (code < 5994 && touni[code])
{
*pwc= touni[code];
return 3;
}
if (byte1 == '@' && byte2 == '@')
{
*pwc= 0;
return 3;
}
}
if (s + 4 > e)
return MY_CS_TOOSMALL4;
if ((byte1= hexlo(byte1)) >= 0 &&
(byte2= hexlo(byte2)) >= 0)
{
int byte3= hexlo(s[3]);
int byte4= hexlo(s[3] ? s[4] : 0);
if (byte3 >=0 && byte4 >=0)
{
*pwc= (byte1 << 12) + (byte2 << 8) + (byte3 << 4) + byte4;
return 5;
}
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_filename:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x5a15e
movsbq (%rdx), %r8
testq %r8, %r8
js 0x5a15c
leaq 0x28291a(%rip), %rdi # 0x2dc980
movl $0x1, %eax
cmpb $0x0, (%r8,%rdi)
je 0x5a07a
movq %r8, (%rsi)
jmp 0x5a15e
cmpb $0x40, %r8b
jne 0x5a15c
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0x5a15e
movzbl 0x1(%rdx), %r10d
testl %r10d, %r10d
je 0x5a15c
movb 0x2(%rdx), %al
movzbl %al, %r9d
cmpb $0x30, %r10b
setge %al
cmpb $0x30, %r9b
setge %r8b
andb %al, %r8b
cmpb $0x1, %r8b
jne 0x5a115
leal (%r10,%r10,4), %eax
shll $0x4, %eax
addl %r9d, %eax
addl $0xfffff100, %eax # imm = 0xFFFFF100
cmpl $0x1799, %eax # imm = 0x1799
jg 0x5a0f7
addl $-0x30, %eax
leaq 0x28291d(%rip), %r8 # 0x2dca00
movzwl (%r8,%rax,2), %r8d
testq %r8, %r8
je 0x5a0f7
movl $0x3, %eax
jmp 0x5a072
movl %r10d, %eax
xorb $0x40, %al
movl %r9d, %r8d
xorb $0x40, %r8b
orb %al, %r8b
jne 0x5a115
movl $0x3, %eax
xorl %r8d, %r8d
jmp 0x5a072
addq $0x4, %rdx
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %rdx
ja 0x5a15e
movl %r10d, %eax
leaq 0x2857b3(%rip), %r10 # 0x2df8e0
movzbl (%rax,%r10), %ecx
testb %cl, %cl
js 0x5a15c
movl %r9d, %eax
movzbl (%rax,%r10), %r9d
movl $0x0, %eax
testb %r9b, %r9b
js 0x5a15e
movzbl (%rdi), %edi
xorl %eax, %eax
movzbl (%rdi,%r10), %r8d
testq %rdi, %rdi
je 0x5a160
movzbl (%rdx), %edx
jmp 0x5a162
xorl %eax, %eax
popq %rbp
retq
xorl %edx, %edx
testb %r8b, %r8b
js 0x5a15e
movb (%rdx,%r10), %dl
testb %dl, %dl
js 0x5a15e
movzbl %dl, %eax
shll $0xc, %ecx
shll $0x8, %r9d
shll $0x4, %r8d
addq %rcx, %r8
addq %r9, %r8
addq %rax, %r8
movl $0x5, %eax
jmp 0x5a072
| my_mb_wc_filename:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_5A15E
movsx r8, byte ptr [rdx]
test r8, r8
js loc_5A15C
lea rdi, filename_safe_char
mov eax, 1
cmp byte ptr [r8+rdi], 0
jz short loc_5A07A
loc_5A072:
mov [rsi], r8
jmp loc_5A15E
loc_5A07A:
cmp r8b, 40h ; '@'
jnz loc_5A15C
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_5A15E
movzx r10d, byte ptr [rdx+1]
test r10d, r10d
jz loc_5A15C
mov al, [rdx+2]
movzx r9d, al
cmp r10b, 30h ; '0'
setnl al
cmp r9b, 30h ; '0'
setnl r8b
and r8b, al
cmp r8b, 1
jnz short loc_5A115
lea eax, [r10+r10*4]
shl eax, 4
add eax, r9d
add eax, 0FFFFF100h
cmp eax, 1799h
jg short loc_5A0F7
add eax, 0FFFFFFD0h
lea r8, touni
movzx r8d, word ptr [r8+rax*2]
test r8, r8
jz short loc_5A0F7
mov eax, 3
jmp loc_5A072
loc_5A0F7:
mov eax, r10d
xor al, 40h
mov r8d, r9d
xor r8b, 40h
or r8b, al
jnz short loc_5A115
mov eax, 3
xor r8d, r8d
jmp loc_5A072
loc_5A115:
add rdx, 4
mov eax, 0FFFFFF98h
cmp rdx, rcx
ja short loc_5A15E
mov eax, r10d
lea r10, hexlo_hex_lo_digit
movzx ecx, byte ptr [rax+r10]
test cl, cl
js short loc_5A15C
mov eax, r9d
movzx r9d, byte ptr [rax+r10]
mov eax, 0
test r9b, r9b
js short loc_5A15E
movzx edi, byte ptr [rdi]
xor eax, eax
movzx r8d, byte ptr [rdi+r10]
test rdi, rdi
jz short loc_5A160
movzx edx, byte ptr [rdx]
jmp short loc_5A162
loc_5A15C:
xor eax, eax
loc_5A15E:
pop rbp
retn
loc_5A160:
xor edx, edx
loc_5A162:
test r8b, r8b
js short loc_5A15E
mov dl, [rdx+r10]
test dl, dl
js short loc_5A15E
movzx eax, dl
shl ecx, 0Ch
shl r9d, 8
shl r8d, 4
add r8, rcx
add r8, r9
add r8, rax
mov eax, 5
jmp loc_5A072
| long long my_mb_wc_filename(long long a1, signed long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
signed long long v5; // r8
unsigned __int8 *v6; // rdi
int v7; // r10d
int v8; // r9d
long long v9; // rax
unsigned __int8 *v10; // rdx
int v11; // ecx
int v12; // r9d
long long v13; // rdi
int v14; // r8d
long long v15; // rdx
char v16; // dl
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
v5 = *a3;
if ( v5 < 0 )
return 0LL;
result = 1LL;
if ( filename_safe_char[v5] )
{
LABEL_4:
*a2 = v5;
return result;
}
if ( (_BYTE)v5 != 64 )
return 0LL;
v6 = (unsigned __int8 *)(a3 + 3);
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) > a4 )
return result;
v7 = (unsigned __int8)a3[1];
if ( !a3[1] )
return 0LL;
v8 = (unsigned __int8)a3[2];
if ( (char)v7 >= 48 && (char)v8 >= 48 )
{
if ( v8 + 80 * v7 - 3840 <= 6041 )
{
v9 = (unsigned int)(v8 + 80 * v7 - 3888);
v5 = touni[v9];
if ( touni[v9] )
{
result = 3LL;
goto LABEL_4;
}
}
if ( !((unsigned __int8)v7 ^ 0x40 | (unsigned __int8)v8 ^ 0x40) )
{
result = 3LL;
v5 = 0LL;
goto LABEL_4;
}
}
v10 = (unsigned __int8 *)(a3 + 4);
result = 4294967192LL;
if ( (unsigned long long)v10 <= a4 )
{
v11 = hexlo_hex_lo_digit[v7];
if ( (v11 & 0x80u) == 0 )
{
v12 = hexlo_hex_lo_digit[v8];
result = 0LL;
if ( (v12 & 0x80u) == 0 )
{
v13 = *v6;
result = 0LL;
v14 = hexlo_hex_lo_digit[v13];
v15 = v13 ? *v10 : 0LL;
if ( (v14 & 0x80u) == 0 )
{
v16 = hexlo_hex_lo_digit[v15];
if ( v16 >= 0 )
{
v5 = (unsigned __int8)v16
+ (unsigned int)(v12 << 8)
+ (unsigned int)(v11 << 12)
+ (unsigned long long)(unsigned int)(16 * v14);
result = 5LL;
goto LABEL_4;
}
}
}
return result;
}
return 0LL;
}
return result;
}
| my_mb_wc_filename:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0015a15e
MOVSX R8,byte ptr [RDX]
TEST R8,R8
JS 0x0015a15c
LEA RDI,[0x3dc980]
MOV EAX,0x1
CMP byte ptr [R8 + RDI*0x1],0x0
JZ 0x0015a07a
LAB_0015a072:
MOV qword ptr [RSI],R8
JMP 0x0015a15e
LAB_0015a07a:
CMP R8B,0x40
JNZ 0x0015a15c
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x0015a15e
MOVZX R10D,byte ptr [RDX + 0x1]
TEST R10D,R10D
JZ 0x0015a15c
MOV AL,byte ptr [RDX + 0x2]
MOVZX R9D,AL
CMP R10B,0x30
SETGE AL
CMP R9B,0x30
SETGE R8B
AND R8B,AL
CMP R8B,0x1
JNZ 0x0015a115
LEA EAX,[R10 + R10*0x4]
SHL EAX,0x4
ADD EAX,R9D
ADD EAX,0xfffff100
CMP EAX,0x1799
JG 0x0015a0f7
ADD EAX,-0x30
LEA R8,[0x3dca00]
MOVZX R8D,word ptr [R8 + RAX*0x2]
TEST R8,R8
JZ 0x0015a0f7
MOV EAX,0x3
JMP 0x0015a072
LAB_0015a0f7:
MOV EAX,R10D
XOR AL,0x40
MOV R8D,R9D
XOR R8B,0x40
OR R8B,AL
JNZ 0x0015a115
MOV EAX,0x3
XOR R8D,R8D
JMP 0x0015a072
LAB_0015a115:
ADD RDX,0x4
MOV EAX,0xffffff98
CMP RDX,RCX
JA 0x0015a15e
MOV EAX,R10D
LEA R10,[0x3df8e0]
MOVZX ECX,byte ptr [RAX + R10*0x1]
TEST CL,CL
JS 0x0015a15c
MOV EAX,R9D
MOVZX R9D,byte ptr [RAX + R10*0x1]
MOV EAX,0x0
TEST R9B,R9B
JS 0x0015a15e
MOVZX EDI,byte ptr [RDI]
XOR EAX,EAX
MOVZX R8D,byte ptr [RDI + R10*0x1]
TEST RDI,RDI
JZ 0x0015a160
MOVZX EDX,byte ptr [RDX]
JMP 0x0015a162
LAB_0015a15c:
XOR EAX,EAX
LAB_0015a15e:
POP RBP
RET
LAB_0015a160:
XOR EDX,EDX
LAB_0015a162:
TEST R8B,R8B
JS 0x0015a15e
MOV DL,byte ptr [RDX + R10*0x1]
TEST DL,DL
JS 0x0015a15e
MOVZX EAX,DL
SHL ECX,0xc
SHL R9D,0x8
SHL R8D,0x4
ADD R8,RCX
ADD R8,R9
ADD R8,RAX
MOV EAX,0x5
JMP 0x0015a072
|
int8 my_mb_wc_filename(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
int iVar3;
int8 uVar4;
ulong uVar5;
ulong uVar6;
if (param_4 <= param_3) {
return 0xffffff9b;
}
uVar6 = (ulong)(char)*param_3;
if ((long)uVar6 < 0) {
return 0;
}
uVar4 = 1;
if (filename_safe_char[uVar6] != '\0') goto LAB_0015a072;
if (*param_3 == 0x40) {
if (param_4 < param_3 + 3) {
return 0xffffff99;
}
bVar2 = param_3[1];
if (bVar2 == 0) {
return 0;
}
bVar1 = param_3[2];
if ('/' < (char)bVar1 && '/' < (char)bVar2) {
iVar3 = ((uint)bVar2 + (uint)bVar2 * 4) * 0x10 + (uint)bVar1;
if ((iVar3 + -0xf00 < 0x179a) &&
(uVar6 = (ulong)*(ushort *)(touni + (ulong)(iVar3 - 0xf30) * 2), uVar6 != 0)) {
uVar4 = 3;
goto LAB_0015a072;
}
if (bVar1 == 0x40 && bVar2 == 0x40) {
uVar4 = 3;
uVar6 = 0;
goto LAB_0015a072;
}
}
if (param_4 < param_3 + 4) {
return 0xffffff98;
}
if (-1 < (char)hexlo_hex_lo_digit[bVar2]) {
if ((char)hexlo_hex_lo_digit[bVar1] < '\0') {
return 0;
}
uVar6 = (ulong)param_3[3];
if (uVar6 == 0) {
uVar5 = 0;
}
else {
uVar5 = (ulong)param_3[4];
}
if ((char)hexlo_hex_lo_digit[uVar6] < '\0') {
return 0;
}
if ((char)hexlo_hex_lo_digit[uVar5] < '\0') {
return 0;
}
uVar6 = (ulong)(byte)hexlo_hex_lo_digit[uVar6] * 0x10 +
(ulong)(byte)hexlo_hex_lo_digit[bVar2] * 0x1000 +
(ulong)(byte)hexlo_hex_lo_digit[bVar1] * 0x100 +
(ulong)(byte)hexlo_hex_lo_digit[uVar5];
uVar4 = 5;
LAB_0015a072:
*param_2 = uVar6;
return uVar4;
}
}
return 0;
}
|
|
6,423 | Item_func_abs::int_op() | eloqsql/sql/item_func.cc | longlong Item_func_abs::int_op()
{
longlong value= args[0]->val_int();
if ((null_value= args[0]->null_value))
return 0;
if (unsigned_flag)
return value;
/* -LONGLONG_MIN = LONGLONG_MAX + 1 => outside of signed longlong range */
if (value == LONGLONG_MIN)
return raise_integer_overflow();
return (value >= 0) ? value : -value;
} | O0 | cpp | Item_func_abs::int_op():
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x70(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xf0(%rax)
movq -0x20(%rbp), %rcx
movq %rax, -0x18(%rbp)
movq 0x70(%rcx), %rax
movq (%rax), %rax
movb 0x64(%rax), %al
movb %al, %dl
andb $0x1, %dl
movb %dl, 0x64(%rcx)
testb $0x1, %al
jne 0x95a224
jmp 0x95a22e
movq $0x0, -0x8(%rbp)
jmp 0x95a284
movq -0x20(%rbp), %rax
testb $0x1, 0xe(%rax)
je 0x95a242
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x95a284
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x18(%rbp)
jne 0x95a261
movq -0x20(%rbp), %rdi
callq 0x96a080
movq %rax, -0x8(%rbp)
jmp 0x95a284
cmpq $0x0, -0x18(%rbp)
jl 0x95a272
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x95a27c
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| _ZN13Item_func_abs6int_opEv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov rax, [rax+70h]
mov rdi, [rax]
mov rax, [rdi]
call qword ptr [rax+0F0h]
mov rcx, [rbp+var_20]
mov [rbp+var_18], rax
mov rax, [rcx+70h]
mov rax, [rax]
mov al, [rax+64h]
mov dl, al
and dl, 1
mov [rcx+64h], dl
test al, 1
jnz short loc_95A224
jmp short loc_95A22E
loc_95A224:
mov [rbp+var_8], 0
jmp short loc_95A284
loc_95A22E:
mov rax, [rbp+var_20]
test byte ptr [rax+0Eh], 1
jz short loc_95A242
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
jmp short loc_95A284
loc_95A242:
mov rax, 8000000000000000h
cmp [rbp+var_18], rax
jnz short loc_95A261
mov rdi, [rbp+var_20]; this
call _ZN9Item_func22raise_integer_overflowEv; Item_func::raise_integer_overflow(void)
mov [rbp+var_8], rax
jmp short loc_95A284
loc_95A261:
cmp [rbp+var_18], 0
jl short loc_95A272
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
jmp short loc_95A27C
loc_95A272:
xor eax, eax
sub rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_95A27C:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_95A284:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long Item_func_abs::int_op(Item_func_abs *this)
{
char v1; // dl
long long v4; // [rsp+18h] [rbp-18h]
v4 = (*(long long ( **)(_QWORD))(***((_QWORD ***)this + 14) + 240LL))(**((_QWORD **)this + 14));
v1 = *(_BYTE *)(**((_QWORD **)this + 14) + 100LL) & 1;
*((_BYTE *)this + 100) = v1;
if ( v1 )
return 0LL;
if ( (*((_BYTE *)this + 14) & 1) != 0 )
return v4;
if ( v4 == 0x8000000000000000LL )
return Item_func::raise_integer_overflow(this);
if ( v4 < 0 )
return -v4;
else
return v4;
}
| Item_func_password:
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 dword ptr [RBP + -0x1c],ECX
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RDI
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0095fd20
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[0x14730c0]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x1c]
MOV dword ptr [RAX + 0xf4],ECX
MOV byte ptr [RAX + 0xf8],0x0
ADD RSP,0x30
POP RBP
RET
|
/* Item_func_password::Item_func_password(THD*, Item*, Item_func_password::PW_Alg) */
void __thiscall
Item_func_password::Item_func_password
(Item_func_password *this,THD *param_1,Item *param_2,int4 param_4)
{
Item_str_ascii_checksum_func::Item_str_ascii_checksum_func
((Item_str_ascii_checksum_func *)this,param_1,param_2);
*(int ***)this = &PTR__Item_func_password_014730d0;
*(int4 *)(this + 0xf4) = param_4;
this[0xf8] = (Item_func_password)0x0;
return;
}
|
|
6,424 | my_strnncollsp_nchars_generic | eloqsql/strings/ctype.c | int my_strnncollsp_nchars_generic(CHARSET_INFO *cs,
const uchar *str1, size_t len1,
const uchar *str2, size_t len2,
size_t nchars)
{
int error;
len1= my_well_formed_length(cs, (const char *) str1,
(const char *) str1 + len1,
nchars, &error);
len2= my_well_formed_length(cs, (const char *) str2,
(const char *) str2 + len2,
nchars, &error);
DBUG_ASSERT((cs->state & MY_CS_NOPAD) == 0);
return cs->coll->strnncollsp(cs, str1, len1, str2, len2);
} | O0 | c | my_strnncollsp_nchars_generic:
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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq 0x6f460
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq 0x6f460
movq %rax, -0x28(%rbp)
jmp 0x6f434
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nop
| my_strnncollsp_nchars_generic:
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 [rbp+var_28], r8
mov [rbp+var_30], r9
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_18]
mov rcx, [rbp+var_30]
lea r8, [rbp+var_34]
call my_well_formed_length
mov [rbp+var_18], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_20]
add rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
lea r8, [rbp+var_34]
call my_well_formed_length
mov [rbp+var_28], rax
jmp short $+2
loc_6F434:
mov rax, [rbp+var_8]
mov rax, [rax+0C0h]
mov rax, [rax+10h]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call rax
add rsp, 40h
pop rbp
retn
| long long my_strnncollsp_nchars_generic(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6)
{
_BYTE v7[4]; // [rsp+Ch] [rbp-34h] BYREF
long long v8; // [rsp+10h] [rbp-30h]
long long v9; // [rsp+18h] [rbp-28h]
long long v10; // [rsp+20h] [rbp-20h]
long long v11; // [rsp+28h] [rbp-18h]
long long v12; // [rsp+30h] [rbp-10h]
long long v13; // [rsp+38h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
v8 = a6;
v11 = my_well_formed_length(a1, a2, a3 + a2, a6, v7);
v9 = my_well_formed_length(v13, v10, v9 + v10, v8, v7);
return (*(long long ( **)(long long, long long, long long, long long, long long))(*(_QWORD *)(v13 + 192) + 16LL))(
v13,
v12,
v11,
v10,
v9);
}
| my_strnncollsp_nchars_generic:
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 qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
LEA R8,[RBP + -0x34]
CALL 0x0016f460
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
LEA R8,[RBP + -0x34]
CALL 0x0016f460
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0016f434
LAB_0016f434:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL RAX
ADD RSP,0x40
POP RBP
RET
|
void my_strnncollsp_nchars_generic
(long param_1,long param_2,long param_3,long param_4,long param_5,int8 param_6)
{
int1 local_3c [4];
int8 local_38;
long local_30;
long local_28;
long local_20;
long local_18;
long local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_20 = my_well_formed_length(param_1,param_2,param_2 + param_3,param_6,local_3c);
local_30 = my_well_formed_length(local_10,local_28,local_28 + local_30,local_38,local_3c);
(**(code **)(*(long *)(local_10 + 0xc0) + 0x10))(local_10,local_18,local_20,local_28,local_30);
return;
}
|
|
6,425 | ma_apply_redo_insert_row_head_or_tail | eloqsql/storage/maria/ma_blockrec.c | uint _ma_apply_redo_insert_row_head_or_tail(MARIA_HA *info, LSN lsn,
uint page_type,
my_bool new_page,
const uchar *header,
const uchar *data,
size_t data_length)
{
MARIA_SHARE *share= info->s;
pgcache_page_no_t page;
uint rownr, empty_space;
uint block_size= share->block_size;
uint rec_offset;
uchar *buff, *dir;
uint result;
MARIA_PINNED_PAGE page_link;
enum pagecache_page_lock lock_method;
enum pagecache_page_pin pin_method;
my_off_t end_of_page;
uint error;
DBUG_ENTER("_ma_apply_redo_insert_row_head_or_tail");
page= page_korr(header);
rownr= dirpos_korr(header + PAGE_STORE_SIZE);
DBUG_PRINT("enter", ("rowid: %lu page: %lu rownr: %u data_length: %u",
(ulong) ma_recordpos(page, rownr),
(ulong) page, rownr, (uint) data_length));
share->state.changed|= (STATE_CHANGED | STATE_NOT_ZEROFILLED |
STATE_NOT_MOVABLE);
end_of_page= (page + 1) * share->block_size;
if (end_of_page > share->state.state.data_file_length)
{
DBUG_PRINT("info", ("Enlarging data file from %lu to %lu",
(ulong) share->state.state.data_file_length,
(ulong) end_of_page));
/*
New page at end of file. Note that the test above is also positive if
data_file_length is not a multiple of block_size (system crashed while
writing the last page): in this case we just extend the last page and
fill it entirely with zeroes, then the REDO will put correct data on
it.
*/
lock_method= PAGECACHE_LOCK_WRITE;
pin_method= PAGECACHE_PIN;
DBUG_ASSERT(rownr == 0 && new_page);
if (rownr != 0 || !new_page)
goto crashed_file;
buff= info->keyread_buff;
info->keyread_buff_used= 1;
make_empty_page(info, buff, page_type, 1);
empty_space= (block_size - PAGE_OVERHEAD_SIZE(share));
rec_offset= PAGE_HEADER_SIZE(share);
dir= buff+ block_size - PAGE_SUFFIX_SIZE - DIR_ENTRY_SIZE;
}
else
{
lock_method= PAGECACHE_LOCK_LEFT_WRITELOCKED;
pin_method= PAGECACHE_PIN_LEFT_PINNED;
share->pagecache->readwrite_flags&= ~MY_WME;
share->silence_encryption_errors= 1;
buff= pagecache_read(share->pagecache, &info->dfile,
page, 0, 0,
PAGECACHE_PLAIN_PAGE, PAGECACHE_LOCK_WRITE,
&page_link.link);
share->pagecache->readwrite_flags= share->pagecache->org_readwrite_flags;
share->silence_encryption_errors= 0;
if (!buff)
{
/* Skip errors when reading outside of file and uninitialized pages */
if (!new_page || (my_errno != HA_ERR_FILE_TOO_SHORT &&
my_errno != HA_ERR_WRONG_CRC &&
my_errno != HA_ERR_DECRYPTION_FAILED))
{
DBUG_PRINT("error", ("Error %d when reading page", (int) my_errno));
goto err;
}
/* Create new page */
buff= pagecache_block_link_to_buffer(page_link.link);
buff[PAGE_TYPE_OFFSET]= UNALLOCATED_PAGE;
}
else if (lsn_korr(buff) >= lsn) /* Test if already applied */
{
check_skipped_lsn(info, lsn_korr(buff), 1, page);
/* Fix bitmap, just in case */
empty_space= uint2korr(buff + EMPTY_SPACE_OFFSET);
if (!enough_free_entries_on_page(share, buff))
empty_space= 0; /* Page is full */
if (_ma_bitmap_set(info, page, page_type == HEAD_PAGE, empty_space))
goto err;
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
DBUG_RETURN(0);
}
if (((uint) (buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) != page_type))
{
/*
This is a page that has been freed before and now should be
changed to new type.
*/
if (!new_page)
{
DBUG_PRINT("error",
("Found page of wrong type: %u, should have been %u",
(uint) (buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK),
page_type));
goto crashed_file;
}
make_empty_page(info, buff, page_type, 0);
empty_space= block_size - PAGE_HEADER_SIZE(share) - PAGE_SUFFIX_SIZE;
(void) extend_directory(info, buff, block_size, 0, rownr, &empty_space,
page_type == HEAD_PAGE);
rec_offset= PAGE_HEADER_SIZE(share);
dir= dir_entry_pos(buff, block_size, rownr);
empty_space+= uint2korr(dir+2);
}
else
{
uint max_entry= (uint) buff[DIR_COUNT_OFFSET];
uint length;
DBUG_ASSERT(!new_page);
dir= dir_entry_pos(buff, block_size, rownr);
empty_space= uint2korr(buff + EMPTY_SPACE_OFFSET);
if (max_entry <= rownr)
{
/* Add directory entry first in directory and data last on page */
if (extend_directory(info, buff, block_size, max_entry, rownr,
&empty_space, page_type == HEAD_PAGE))
goto crashed_file;
}
if (extend_area_on_page(info, buff, dir, rownr,
(uint) data_length, &empty_space,
&rec_offset, &length, page_type == HEAD_PAGE))
goto crashed_file;
}
}
/* Copy data */
int2store(dir+2, data_length);
memcpy(buff + rec_offset, data, data_length);
empty_space-= (uint) data_length;
int2store(buff + EMPTY_SPACE_OFFSET, empty_space);
/* Fix bitmap */
if (!enough_free_entries_on_page(share, buff))
empty_space= 0; /* Page is full */
if (_ma_bitmap_set(info, page, page_type == HEAD_PAGE, empty_space))
goto err;
/*
If page was not read before, write it but keep it pinned.
We don't update its LSN When we have processed all REDOs for this page
in the current REDO's group, we will stamp page with UNDO's LSN
(if we stamped it now, a next REDO, in
this group, for this page, would be skipped) and unpin then.
*/
result= 0;
if (lock_method == PAGECACHE_LOCK_WRITE &&
pagecache_write(share->pagecache,
&info->dfile, page, 0,
buff, PAGECACHE_PLAIN_PAGE,
lock_method, pin_method,
PAGECACHE_WRITE_DELAY, &page_link.link,
LSN_IMPOSSIBLE))
result= my_errno;
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
/*
Data page and bitmap page are in place, we can update data_file_length in
case we extended the file. We could not do it earlier: bitmap code tests
data_file_length to know if it has to create a new page or not.
*/
set_if_bigger(share->state.state.data_file_length, end_of_page);
DBUG_RETURN(result);
crashed_file:
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
err:
error= my_errno;
if (lock_method == PAGECACHE_LOCK_LEFT_WRITELOCKED)
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
_ma_mark_file_crashed(share);
DBUG_ASSERT(!maria_assert_if_crashed_table); /* catch recovery error early */
DBUG_RETURN((my_errno= error));
} | O3 | c | ma_apply_redo_insert_row_head_or_tail:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r12d
movq %rsi, %r14
movq (%rdi), %rbx
movl 0x7bc(%rbx), %r13d
movl (%r8), %eax
movzbl 0x4(%r8), %ecx
shlq $0x20, %rcx
leaq (%rcx,%rax), %r10
movzbl 0x5(%r8), %r11d
orl $0x181, 0x170(%rbx) # imm = 0x181
leaq (%rcx,%rax), %rsi
incq %rsi
imulq %r13, %rsi
movq 0x40(%rbx), %r8
cmpq %r8, %rsi
jbe 0x650b7
testl %r11d, %r11d
setne %al
testb %r12b, %r12b
sete %cl
movl $0x4, %r14d
orb %al, %cl
jne 0x6546c
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movq %r10, -0x60(%rbp)
movq %rsi, -0x58(%rbp)
movq 0x380(%rdi), %r15
movb $0x1, 0x685(%rdi)
movq %rdi, -0x38(%rbp)
movq %r15, %rsi
movl %edx, -0x30(%rbp)
movl $0x1, %ecx
callq 0x654fe
movl 0xc18(%rbx), %eax
movl %r13d, %ecx
subl %eax, %ecx
addl $-0x14, %ecx
movl %ecx, -0x2c(%rbp)
addl $0xc, %eax
movl %eax, -0x3c(%rbp)
addq %r15, %r13
addq $-0x8, %r13
movl $0x4, -0x48(%rbp)
movl $0x2, %eax
movq %rax, -0x50(%rbp)
jmp 0x65363
movq %r11, -0x48(%rbp)
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movl %edx, -0x30(%rbp)
movq %rsi, -0x58(%rbp)
movq 0x600(%rbx), %rax
movl $0xffffffef, %ecx # imm = 0xFFFFFFEF
andq %rcx, 0x198(%rax)
movb $0x1, 0x7ec(%rbx)
movq 0x600(%rbx), %rcx
movq %rdi, -0x38(%rbp)
leaq 0x470(%rdi), %rsi
leaq -0x88(%rbp), %rax
movq %rcx, %rdi
movq %r10, -0x60(%rbp)
movq %r10, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
pushq %rax
pushq $0x4
callq 0x5383a
addq $0x10, %rsp
movq %rax, %r15
movq 0x600(%rbx), %rax
movq 0x1a0(%rax), %rcx
movq %rcx, 0x198(%rax)
movb $0x0, 0x7ec(%rbx)
testq %r15, %r15
je 0x65170
movzwl (%r15), %eax
shlq $0x20, %rax
movzbl 0x2(%r15), %ecx
shlq $0x30, %rcx
orq %rax, %rcx
movl 0x3(%r15), %esi
orq %rcx, %rsi
cmpq %r14, %rsi
jge 0x65278
movzbl 0x7(%r15), %eax
andl $0x7, %eax
jmp 0x651b9
testb %r12b, %r12b
je 0x652c6
callq 0x85b0e
cmpl $0xaf, (%rax)
je 0x651a4
callq 0x85b0e
cmpl $0xb0, (%rax)
je 0x651a4
callq 0x85b0e
cmpl $0xc0, (%rax)
jne 0x652c6
movq -0x88(%rbp), %rdi
callq 0x55d1d
movq %rax, %r15
movb $0x0, 0x7(%rax)
xorl %eax, %eax
movl -0x30(%rbp), %edx
cmpl %edx, %eax
movq -0x38(%rbp), %rdi
jne 0x652d3
movzbl 0x8(%r15), %ecx
movzwl 0xa(%r15), %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %r14
cmpb %r14b, %cl
ja 0x65210
xorl %eax, %eax
cmpl $0x1, %edx
sete %al
subq $0x8, %rsp
leaq -0x2c(%rbp), %r9
movq %r15, %rsi
movl %r13d, %edx
movl %r14d, %r8d
pushq %rax
callq 0x65594
movl -0x30(%rbp), %edx
movq -0x38(%rbp), %rdi
addq $0x10, %rsp
testb %al, %al
jne 0x65466
addq %r15, %r13
leal (,%r14,4), %eax
subq %rax, %r13
addq $-0x8, %r13
xorl %eax, %eax
cmpl $0x1, %edx
sete %al
subq $0x8, %rsp
leaq -0x8c(%rbp), %r10
leaq -0x3c(%rbp), %r11
leaq -0x2c(%rbp), %r9
movq %r15, %rsi
movq %r13, %rdx
movl %r14d, %ecx
movq 0x10(%rbp), %r8
pushq %rax
pushq %r10
pushq %r11
callq 0x6570a
movq -0x38(%rbp), %rdi
addq $0x20, %rsp
testb %al, %al
jne 0x65466
movl $0x2, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
jmp 0x65363
movq -0x38(%rbp), %rdi
movl $0x1, %edx
movq -0x60(%rbp), %r13
movq %r13, %rcx
callq 0x4e449
movzwl 0xa(%r15), %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x62076
xorl %r12d, %r12d
testb %al, %al
cmovel %r12d, %r14d
xorl %edx, %edx
cmpl $0x1, -0x30(%rbp)
sete %dl
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl %r14d, %ecx
callq 0x438f3
testb %al, %al
je 0x654d1
callq 0x85b0e
movl (%rax), %r12d
jmp 0x65484
testb %r12b, %r12b
je 0x65466
movq $0x0, -0x50(%rbp)
movq %rdi, %r12
movq %r15, %rsi
xorl %ecx, %ecx
movl %edx, %r14d
callq 0x654fe
movl %r13d, %eax
subl 0xc18(%rbx), %eax
addl $-0x10, %eax
leaq -0x2c(%rbp), %rcx
movl %eax, (%rcx)
movq %rcx, %r9
xorl %eax, %eax
cmpl $0x1, %r14d
sete %al
subq $0x8, %rsp
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
xorl %ecx, %ecx
movq -0x48(%rbp), %r14
movl %r14d, %r8d
movq %r9, %r12
pushq %rax
callq 0x65594
addq $0x10, %rsp
movl 0xc18(%rbx), %eax
addl $0xc, %eax
movl %eax, -0x3c(%rbp)
addq %r15, %r13
leal (,%r14,4), %eax
subq %rax, %r13
movzwl -0x6(%r13), %eax
addq $-0x8, %r13
addl %eax, (%r12)
movl $0x2, -0x48(%rbp)
movq 0x10(%rbp), %r12
movw %r12w, 0x2(%r13)
movl -0x3c(%rbp), %edi
addq %r15, %rdi
movq -0x70(%rbp), %rsi
movq %r12, %rdx
callq 0x270d0
movl -0x2c(%rbp), %r14d
subl %r12d, %r14d
movl %r14d, -0x2c(%rbp)
movw %r14w, 0xa(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x62076
testb %al, %al
jne 0x653a7
movl $0x0, -0x2c(%rbp)
xorl %r14d, %r14d
xorl %edx, %edx
cmpl $0x1, -0x30(%rbp)
sete %dl
movq -0x38(%rbp), %r12
movq %r12, %rdi
movq -0x60(%rbp), %r13
movq %r13, %rsi
movl %r14d, %ecx
callq 0x438f3
testb %al, %al
movl -0x48(%rbp), %r14d
jne 0x65476
movq %r12, %r14
xorl %r12d, %r12d
movq -0x68(%rbp), %rax
cmpq %rax, -0x58(%rbp)
jbe 0x65435
movq 0x600(%rbx), %rdi
leaq 0x470(%r14), %rsi
movl 0x80(%rdi), %eax
subq $0x8, %rsp
xorl %r12d, %r12d
leaq -0x88(%rbp), %r10
movq %r13, %rdx
xorl %ecx, %ecx
movq %r15, %r8
movl $0x1, %r9d
pushq %rax
pushq %r12
pushq $0x0
pushq %r10
pushq %r12
pushq -0x50(%rbp)
pushq $0x4
callq 0x54c9e
addq $0x40, %rsp
testb %al, %al
je 0x65435
callq 0x85b0e
movl (%rax), %r12d
leaq -0x88(%rbp), %rsi
movl $0x6, 0x8(%rsi)
movb $0x1, 0x10(%rsi)
movq %r14, %rdi
addq $0x2e8, %rdi # imm = 0x2E8
callq 0x7705a
movq -0x58(%rbp), %rax
cmpq %rax, 0x40(%rbx)
jae 0x654bf
movq %rax, 0x40(%rbx)
jmp 0x654bf
movl $0x2, %r14d
movl $0x7f, %esi
callq 0x38698
callq 0x85b0e
movl (%rax), %r12d
cmpl $0x2, %r14d
jne 0x654af
movq 0x600(%rbx), %rdi
movq -0x88(%rbp), %rsi
xorl %eax, %eax
movl $0x6, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
callq 0x53555
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x39e96
callq 0x85b0e
movl %r12d, (%rax)
movl %r12d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x600(%rbx), %rdi
movq -0x88(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r12
pushq %r12
callq 0x53555
addq $0x10, %rsp
jmp 0x654bf
| _ma_apply_redo_insert_row_head_or_tail:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12d, ecx
mov r14, rsi
mov rbx, [rdi]
mov r13d, [rbx+7BCh]
mov eax, [r8]
movzx ecx, byte ptr [r8+4]
shl rcx, 20h
lea r10, [rcx+rax]
movzx r11d, byte ptr [r8+5]
or dword ptr [rbx+170h], 181h
lea rsi, [rcx+rax]
inc rsi
imul rsi, r13
mov r8, [rbx+40h]
cmp rsi, r8
jbe short loc_650B7
test r11d, r11d
setnz al
test r12b, r12b
setz cl
mov r14d, 4
or cl, al
jnz loc_6546C
mov [rbp+var_70], r9
mov [rbp+var_68], r8
mov [rbp+var_60], r10
mov [rbp+var_58], rsi
mov r15, [rdi+380h]
mov byte ptr [rdi+685h], 1
mov [rbp+var_38], rdi
mov rsi, r15
mov [rbp+var_30], edx
mov ecx, 1
call make_empty_page
mov eax, [rbx+0C18h]
mov ecx, r13d
sub ecx, eax
add ecx, 0FFFFFFECh
mov [rbp+var_2C], ecx
add eax, 0Ch
mov [rbp+var_3C], eax
add r13, r15
add r13, 0FFFFFFFFFFFFFFF8h
mov dword ptr [rbp+var_48], 4
mov eax, 2
mov [rbp+var_50], rax
jmp loc_65363
loc_650B7:
mov [rbp+var_48], r11
mov [rbp+var_70], r9
mov [rbp+var_68], r8
mov [rbp+var_30], edx
mov [rbp+var_58], rsi
mov rax, [rbx+600h]
mov ecx, 0FFFFFFEFh
and [rax+198h], rcx
mov byte ptr [rbx+7ECh], 1
mov rcx, [rbx+600h]
mov [rbp+var_38], rdi
lea rsi, [rdi+470h]
lea rax, [rbp+var_88]
mov rdi, rcx
mov [rbp+var_60], r10
mov rdx, r10
xor ecx, ecx
xor r8d, r8d
mov r9d, 1
push rax
push 4
call pagecache_read
add rsp, 10h
mov r15, rax
mov rax, [rbx+600h]
mov rcx, [rax+1A0h]
mov [rax+198h], rcx
mov byte ptr [rbx+7ECh], 0
test r15, r15
jz short loc_65170
movzx eax, word ptr [r15]
shl rax, 20h
movzx ecx, byte ptr [r15+2]
shl rcx, 30h
or rcx, rax
mov esi, [r15+3]
or rsi, rcx
cmp rsi, r14
jge loc_65278
movzx eax, byte ptr [r15+7]
and eax, 7
jmp short loc_651B9
loc_65170:
test r12b, r12b
jz loc_652C6
call _my_thread_var
cmp dword ptr [rax], 0AFh
jz short loc_651A4
call _my_thread_var
cmp dword ptr [rax], 0B0h
jz short loc_651A4
call _my_thread_var
cmp dword ptr [rax], 0C0h
jnz loc_652C6
loc_651A4:
mov rdi, [rbp+var_88]
call pagecache_block_link_to_buffer
mov r15, rax
mov byte ptr [rax+7], 0
xor eax, eax
loc_651B9:
mov edx, [rbp+var_30]
cmp eax, edx
mov rdi, [rbp+var_38]
jnz loc_652D3
movzx ecx, byte ptr [r15+8]
movzx eax, word ptr [r15+0Ah]
mov [rbp+var_2C], eax
mov r14, [rbp+var_48]
cmp cl, r14b
ja short loc_65210
xor eax, eax
cmp edx, 1
setz al
sub rsp, 8
lea r9, [rbp+var_2C]
mov rsi, r15
mov edx, r13d
mov r8d, r14d
push rax
call extend_directory
mov edx, [rbp+var_30]
mov rdi, [rbp+var_38]
add rsp, 10h
test al, al
jnz loc_65466
loc_65210:
add r13, r15
lea eax, ds:0[r14*4]
sub r13, rax
add r13, 0FFFFFFFFFFFFFFF8h
xor eax, eax
cmp edx, 1
setz al
sub rsp, 8
lea r10, [rbp+var_8C]
lea r11, [rbp+var_3C]
lea r9, [rbp+var_2C]
mov rsi, r15
mov rdx, r13
mov ecx, r14d
mov r8, [rbp+arg_0]
push rax
push r10
push r11
call extend_area_on_page
mov rdi, [rbp+var_38]
add rsp, 20h
test al, al
jnz loc_65466
mov dword ptr [rbp+var_48], 2
mov [rbp+var_50], 0
jmp loc_65363
loc_65278:
mov rdi, [rbp+var_38]
mov edx, 1
mov r13, [rbp+var_60]
mov rcx, r13
call check_skipped_lsn
movzx r14d, word ptr [r15+0Ah]
mov rdi, rbx
mov rsi, r15
call enough_free_entries_on_page
xor r12d, r12d
test al, al
cmovz r14d, r12d
xor edx, edx
cmp [rbp+var_30], 1
setz dl
mov rdi, [rbp+var_38]
mov rsi, r13
mov ecx, r14d
call _ma_bitmap_set
test al, al
jz loc_654D1
loc_652C6:
call _my_thread_var
mov r12d, [rax]
jmp loc_65484
loc_652D3:
test r12b, r12b
jz loc_65466
mov [rbp+var_50], 0
mov r12, rdi
mov rsi, r15
xor ecx, ecx
mov r14d, edx
call make_empty_page
mov eax, r13d
sub eax, [rbx+0C18h]
add eax, 0FFFFFFF0h
lea rcx, [rbp+var_2C]
mov [rcx], eax
mov r9, rcx
xor eax, eax
cmp r14d, 1
setz al
sub rsp, 8
mov rdi, r12
mov rsi, r15
mov edx, r13d
xor ecx, ecx
mov r14, [rbp+var_48]
mov r8d, r14d
mov r12, r9
push rax
call extend_directory
add rsp, 10h
mov eax, [rbx+0C18h]
add eax, 0Ch
mov [rbp+var_3C], eax
add r13, r15
lea eax, ds:0[r14*4]
sub r13, rax
movzx eax, word ptr [r13-6]
add r13, 0FFFFFFFFFFFFFFF8h
add [r12], eax
mov dword ptr [rbp+var_48], 2
loc_65363:
mov r12, [rbp+arg_0]
mov [r13+2], r12w
mov edi, [rbp+var_3C]
add rdi, r15
mov rsi, [rbp+var_70]
mov rdx, r12
call _memcpy
mov r14d, [rbp+var_2C]
sub r14d, r12d
mov [rbp+var_2C], r14d
mov [r15+0Ah], r14w
mov rdi, rbx
mov rsi, r15
call enough_free_entries_on_page
test al, al
jnz short loc_653A7
mov [rbp+var_2C], 0
xor r14d, r14d
loc_653A7:
xor edx, edx
cmp [rbp+var_30], 1
setz dl
mov r12, [rbp+var_38]
mov rdi, r12
mov r13, [rbp+var_60]
mov rsi, r13
mov ecx, r14d
call _ma_bitmap_set
test al, al
mov r14d, dword ptr [rbp+var_48]
jnz loc_65476
mov r14, r12
xor r12d, r12d
mov rax, [rbp+var_68]
cmp [rbp+var_58], rax
jbe short loc_65435
mov rdi, [rbx+600h]
lea rsi, [r14+470h]
mov eax, [rdi+80h]
sub rsp, 8
xor r12d, r12d
lea r10, [rbp+var_88]
mov rdx, r13
xor ecx, ecx
mov r8, r15
mov r9d, 1
push rax
push r12
push 0
push r10
push r12
push [rbp+var_50]
push 4
call pagecache_write_part
add rsp, 40h
test al, al
jz short loc_65435
call _my_thread_var
mov r12d, [rax]
loc_65435:
lea rsi, [rbp+var_88]
mov dword ptr [rsi+8], 6
mov byte ptr [rsi+10h], 1
mov rdi, r14
add rdi, 2E8h
call insert_dynamic
mov rax, [rbp+var_58]
cmp [rbx+40h], rax
jnb short loc_654BF
mov [rbx+40h], rax
jmp short loc_654BF
loc_65466:
mov r14d, 2
loc_6546C:
mov esi, 7Fh
call _ma_set_fatal_error
loc_65476:
call _my_thread_var
mov r12d, [rax]
cmp r14d, 2
jnz short loc_654AF
loc_65484:
mov rdi, [rbx+600h]
mov rsi, [rbp+var_88]
xor eax, eax
mov edx, 6
mov ecx, 3
xor r8d, r8d
xor r9d, r9d
push rax
push rax
call pagecache_unlock_by_link
add rsp, 10h
loc_654AF:
mov rdi, rbx
call _ma_mark_file_crashed
call _my_thread_var
mov [rax], r12d
loc_654BF:
mov eax, r12d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_654D1:
mov rdi, [rbx+600h]
mov rsi, [rbp+var_88]
mov edx, 6
mov ecx, 3
xor r8d, r8d
xor r9d, r9d
push r12
push r12
call pagecache_unlock_by_link
add rsp, 10h
jmp short loc_654BF
| long long ma_apply_redo_insert_row_head_or_tail(
long long *a1,
long long a2,
long long a3,
char a4,
unsigned int *a5,
long long a6,
long long a7)
{
long long v9; // rbx
long long v10; // r13
long long v11; // rax
unsigned long long v12; // rcx
long long v13; // r10
long long v14; // r11
unsigned long long v15; // rsi
unsigned long long v16; // r8
int v17; // r14d
unsigned __int16 *v18; // r15
int v19; // eax
long long v20; // r13
long long v21; // rcx
long long v22; // rsi
long long *v23; // rdi
long long v24; // rsi
int v25; // eax
int v26; // ecx
int v27; // r14d
char v28; // al
char v29; // al
unsigned long long v30; // r13
unsigned int v31; // r14d
unsigned int v32; // r12d
unsigned int v33; // r14d
char v34; // al
int v35; // r14d
char *v36; // r13
int v37; // eax
unsigned int v38; // r14d
long long *v39; // r12
long long v40; // r13
char v41; // al
long long *v42; // r14
__m128i *v43; // rdi
_BYTE v45[4]; // [rsp+4h] [rbp-8Ch] BYREF
long long v46; // [rsp+8h] [rbp-88h] BYREF
int v47; // [rsp+10h] [rbp-80h]
char v48; // [rsp+18h] [rbp-78h]
long long v49; // [rsp+20h] [rbp-70h]
unsigned long long v50; // [rsp+28h] [rbp-68h]
long long v51; // [rsp+30h] [rbp-60h]
unsigned long long v52; // [rsp+38h] [rbp-58h]
long long v53; // [rsp+40h] [rbp-50h]
long long v54; // [rsp+48h] [rbp-48h]
unsigned int v55; // [rsp+54h] [rbp-3Ch] BYREF
long long *v56; // [rsp+58h] [rbp-38h]
unsigned int v57; // [rsp+60h] [rbp-30h]
_DWORD v58[11]; // [rsp+64h] [rbp-2Ch] BYREF
v9 = *a1;
v10 = *(unsigned int *)(*a1 + 1980);
v11 = *a5;
v12 = (unsigned long long)*((unsigned __int8 *)a5 + 4) << 32;
v13 = v12 + v11;
v14 = *((unsigned __int8 *)a5 + 5);
*(_DWORD *)(v9 + 368) |= 0x181u;
v15 = v10 * (v12 + v11 + 1);
v16 = *(_QWORD *)(v9 + 64);
if ( v15 > v16 )
{
v17 = 4;
LOBYTE(v12) = (_DWORD)v14 != 0 || a4 == 0;
if ( !(_BYTE)v12 )
{
v49 = a6;
v50 = v16;
v51 = v13;
v52 = v15;
v18 = (unsigned __int16 *)a1[112];
*((_BYTE *)a1 + 1669) = 1;
v56 = a1;
v57 = a3;
make_empty_page(a1, v18, a3, 1LL);
v19 = *(_DWORD *)(v9 + 3096);
v58[0] = v10 - v19 - 20;
v55 = v19 + 12;
v20 = (long long)v18 + v10 - 8;
LODWORD(v54) = 4;
v53 = 2LL;
goto LABEL_23;
}
LABEL_32:
ma_set_fatal_error(a1, 127, a3, v12, v16, a6);
goto LABEL_33;
}
v54 = v14;
v49 = a6;
v50 = v16;
v57 = a3;
v52 = v10 * (v12 + v11 + 1);
*(_QWORD *)(*(_QWORD *)(v9 + 1536) + 408LL) &= 0xFFFFFFEFuLL;
*(_BYTE *)(v9 + 2028) = 1;
v21 = *(_QWORD *)(v9 + 1536);
v56 = a1;
v22 = (long long)(a1 + 142);
v23 = (long long *)v21;
v51 = v13;
v18 = (unsigned __int16 *)pagecache_read(v21, v22, v13, 0, 0LL, 1, 4u, &v46);
*(_QWORD *)(*(_QWORD *)(v9 + 1536) + 408LL) = *(_QWORD *)(*(_QWORD *)(v9 + 1536) + 416LL);
*(_BYTE *)(v9 + 2028) = 0;
if ( v18 )
{
v12 = ((unsigned long long)*v18 << 32) | ((unsigned long long)*((unsigned __int8 *)v18 + 2) << 48);
v24 = v12 | *(unsigned int *)((char *)v18 + 3);
if ( v24 < a2 )
{
v25 = *((_BYTE *)v18 + 7) & 7;
goto LABEL_12;
}
v30 = v51;
check_skipped_lsn((long long)v56, v24, 1, v51);
v31 = v18[5];
v32 = 0;
if ( !enough_free_entries_on_page(v9, v18) )
v31 = 0;
v23 = v56;
if ( !(unsigned __int8)ma_bitmap_set(v56, v30, v57 == 1, v31) )
{
pagecache_unlock_by_link(*(_QWORD *)(v9 + 1536), v46, 6, 3, 0LL, 0LL, 0);
return v32;
}
LABEL_20:
v32 = *(_DWORD *)my_thread_var(v23);
goto LABEL_34;
}
if ( !a4
|| *(_DWORD *)my_thread_var(v23) != 175
&& *(_DWORD *)my_thread_var(v23) != 176
&& *(_DWORD *)my_thread_var(v23) != 192 )
{
goto LABEL_20;
}
v18 = (unsigned __int16 *)pagecache_block_link_to_buffer(v46);
*((_BYTE *)v18 + 7) = 0;
v25 = 0;
LABEL_12:
a3 = v57;
a1 = v56;
if ( v25 == v57 )
{
v26 = *((unsigned __int8 *)v18 + 8);
v58[0] = v18[5];
v27 = v54;
if ( (unsigned __int8)v26 > (unsigned __int8)v54
|| (v28 = extend_directory((_DWORD)v56, (_DWORD)v18, v10, v26, v54, (unsigned int)v58, v57 == 1),
a3 = v57,
a1 = v56,
!v28) )
{
v20 = (long long)v18 + v10 - (unsigned int)(4 * v27) - 8;
v29 = extend_area_on_page(
(_DWORD)a1,
(_DWORD)v18,
v20,
v27,
a7,
(unsigned int)v58,
(long long)&v55,
(long long)v45,
(_DWORD)a3 == 1);
a1 = v56;
if ( !v29 )
{
LODWORD(v54) = 2;
v53 = 0LL;
goto LABEL_23;
}
}
LABEL_31:
v17 = 2;
goto LABEL_32;
}
if ( !a4 )
goto LABEL_31;
v53 = 0LL;
v33 = v57;
make_empty_page(v56, v18, v57, 0LL);
v58[0] = v10 - *(_DWORD *)(v9 + 3096) - 16;
v34 = v33 == 1;
v35 = v54;
extend_directory((_DWORD)a1, (_DWORD)v18, v10, 0, v54, (unsigned int)v58, v34);
v55 = *(_DWORD *)(v9 + 3096) + 12;
v36 = (char *)v18 + v10 - (unsigned int)(4 * v35);
v37 = *((unsigned __int16 *)v36 - 3);
v20 = (long long)(v36 - 8);
v58[0] += v37;
LODWORD(v54) = 2;
LABEL_23:
*(_WORD *)(v20 + 2) = a7;
memcpy((char *)v18 + v55, v49, a7);
v38 = v58[0] - a7;
v58[0] = v38;
v18[5] = v38;
if ( !enough_free_entries_on_page(v9, v18) )
{
v58[0] = 0;
v38 = 0;
}
v39 = v56;
a1 = v56;
v40 = v51;
v41 = ma_bitmap_set(v56, v51, v57 == 1, v38);
v17 = v54;
if ( v41 )
{
LABEL_33:
v32 = *(_DWORD *)my_thread_var(a1);
if ( v17 != 2 )
{
LABEL_35:
ma_mark_file_crashed(v9);
*(_DWORD *)my_thread_var(v9) = v32;
return v32;
}
LABEL_34:
pagecache_unlock_by_link(*(_QWORD *)(v9 + 1536), v46, 6, 3, 0LL, 0LL, 0);
goto LABEL_35;
}
v42 = v39;
v32 = 0;
if ( v52 > v50 )
{
v43 = *(__m128i **)(v9 + 1536);
v32 = 0;
if ( (unsigned __int8)pagecache_write_part(
v43,
(char *)v42 + 1136,
v40,
0,
(char *)v18,
1,
4u,
v53,
0,
&v46,
0LL,
0,
v43[8].m128i_u32[0]) )
v32 = *(_DWORD *)my_thread_var(v43);
}
v47 = 6;
v48 = 1;
insert_dynamic(v42 + 93, &v46);
if ( *(_QWORD *)(v9 + 64) < v52 )
*(_QWORD *)(v9 + 64) = v52;
return v32;
}
| _ma_apply_redo_insert_row_head_or_tail:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12D,ECX
MOV R14,RSI
MOV RBX,qword ptr [RDI]
MOV R13D,dword ptr [RBX + 0x7bc]
MOV EAX,dword ptr [R8]
MOVZX ECX,byte ptr [R8 + 0x4]
SHL RCX,0x20
LEA R10,[RCX + RAX*0x1]
MOVZX R11D,byte ptr [R8 + 0x5]
OR dword ptr [RBX + 0x170],0x181
LEA RSI,[RCX + RAX*0x1]
INC RSI
IMUL RSI,R13
MOV R8,qword ptr [RBX + 0x40]
CMP RSI,R8
JBE 0x001650b7
TEST R11D,R11D
SETNZ AL
TEST R12B,R12B
SETZ CL
MOV R14D,0x4
OR CL,AL
JNZ 0x0016546c
MOV qword ptr [RBP + -0x70],R9
MOV qword ptr [RBP + -0x68],R8
MOV qword ptr [RBP + -0x60],R10
MOV qword ptr [RBP + -0x58],RSI
MOV R15,qword ptr [RDI + 0x380]
MOV byte ptr [RDI + 0x685],0x1
MOV qword ptr [RBP + -0x38],RDI
MOV RSI,R15
MOV dword ptr [RBP + -0x30],EDX
MOV ECX,0x1
CALL 0x001654fe
MOV EAX,dword ptr [RBX + 0xc18]
MOV ECX,R13D
SUB ECX,EAX
ADD ECX,-0x14
MOV dword ptr [RBP + -0x2c],ECX
ADD EAX,0xc
MOV dword ptr [RBP + -0x3c],EAX
ADD R13,R15
ADD R13,-0x8
MOV dword ptr [RBP + -0x48],0x4
MOV EAX,0x2
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00165363
LAB_001650b7:
MOV qword ptr [RBP + -0x48],R11
MOV qword ptr [RBP + -0x70],R9
MOV qword ptr [RBP + -0x68],R8
MOV dword ptr [RBP + -0x30],EDX
MOV qword ptr [RBP + -0x58],RSI
MOV RAX,qword ptr [RBX + 0x600]
MOV ECX,0xffffffef
AND qword ptr [RAX + 0x198],RCX
MOV byte ptr [RBX + 0x7ec],0x1
MOV RCX,qword ptr [RBX + 0x600]
MOV qword ptr [RBP + -0x38],RDI
LEA RSI,[RDI + 0x470]
LEA RAX,[RBP + -0x88]
MOV RDI,RCX
MOV qword ptr [RBP + -0x60],R10
MOV RDX,R10
XOR ECX,ECX
XOR R8D,R8D
MOV R9D,0x1
PUSH RAX
PUSH 0x4
CALL 0x0015383a
ADD RSP,0x10
MOV R15,RAX
MOV RAX,qword ptr [RBX + 0x600]
MOV RCX,qword ptr [RAX + 0x1a0]
MOV qword ptr [RAX + 0x198],RCX
MOV byte ptr [RBX + 0x7ec],0x0
TEST R15,R15
JZ 0x00165170
MOVZX EAX,word ptr [R15]
SHL RAX,0x20
MOVZX ECX,byte ptr [R15 + 0x2]
SHL RCX,0x30
OR RCX,RAX
MOV ESI,dword ptr [R15 + 0x3]
OR RSI,RCX
CMP RSI,R14
JGE 0x00165278
MOVZX EAX,byte ptr [R15 + 0x7]
AND EAX,0x7
JMP 0x001651b9
LAB_00165170:
TEST R12B,R12B
JZ 0x001652c6
CALL 0x00185b0e
CMP dword ptr [RAX],0xaf
JZ 0x001651a4
CALL 0x00185b0e
CMP dword ptr [RAX],0xb0
JZ 0x001651a4
CALL 0x00185b0e
CMP dword ptr [RAX],0xc0
JNZ 0x001652c6
LAB_001651a4:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00155d1d
MOV R15,RAX
MOV byte ptr [RAX + 0x7],0x0
XOR EAX,EAX
LAB_001651b9:
MOV EDX,dword ptr [RBP + -0x30]
CMP EAX,EDX
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x001652d3
MOVZX ECX,byte ptr [R15 + 0x8]
MOVZX EAX,word ptr [R15 + 0xa]
MOV dword ptr [RBP + -0x2c],EAX
MOV R14,qword ptr [RBP + -0x48]
CMP CL,R14B
JA 0x00165210
XOR EAX,EAX
CMP EDX,0x1
SETZ AL
SUB RSP,0x8
LEA R9,[RBP + -0x2c]
MOV RSI,R15
MOV EDX,R13D
MOV R8D,R14D
PUSH RAX
CALL 0x00165594
MOV EDX,dword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x38]
ADD RSP,0x10
TEST AL,AL
JNZ 0x00165466
LAB_00165210:
ADD R13,R15
LEA EAX,[R14*0x4]
SUB R13,RAX
ADD R13,-0x8
XOR EAX,EAX
CMP EDX,0x1
SETZ AL
SUB RSP,0x8
LEA R10,[RBP + -0x8c]
LEA R11,[RBP + -0x3c]
LEA R9,[RBP + -0x2c]
MOV RSI,R15
MOV RDX,R13
MOV ECX,R14D
MOV R8,qword ptr [RBP + 0x10]
PUSH RAX
PUSH R10
PUSH R11
CALL 0x0016570a
MOV RDI,qword ptr [RBP + -0x38]
ADD RSP,0x20
TEST AL,AL
JNZ 0x00165466
MOV dword ptr [RBP + -0x48],0x2
MOV qword ptr [RBP + -0x50],0x0
JMP 0x00165363
LAB_00165278:
MOV RDI,qword ptr [RBP + -0x38]
MOV EDX,0x1
MOV R13,qword ptr [RBP + -0x60]
MOV RCX,R13
CALL 0x0014e449
MOVZX R14D,word ptr [R15 + 0xa]
MOV RDI,RBX
MOV RSI,R15
CALL 0x00162076
XOR R12D,R12D
TEST AL,AL
CMOVZ R14D,R12D
XOR EDX,EDX
CMP dword ptr [RBP + -0x30],0x1
SETZ DL
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,R13
MOV ECX,R14D
CALL 0x001438f3
TEST AL,AL
JZ 0x001654d1
LAB_001652c6:
CALL 0x00185b0e
MOV R12D,dword ptr [RAX]
JMP 0x00165484
LAB_001652d3:
TEST R12B,R12B
JZ 0x00165466
MOV qword ptr [RBP + -0x50],0x0
MOV R12,RDI
MOV RSI,R15
XOR ECX,ECX
MOV R14D,EDX
CALL 0x001654fe
MOV EAX,R13D
SUB EAX,dword ptr [RBX + 0xc18]
ADD EAX,-0x10
LEA RCX,[RBP + -0x2c]
MOV dword ptr [RCX],EAX
MOV R9,RCX
XOR EAX,EAX
CMP R14D,0x1
SETZ AL
SUB RSP,0x8
MOV RDI,R12
MOV RSI,R15
MOV EDX,R13D
XOR ECX,ECX
MOV R14,qword ptr [RBP + -0x48]
MOV R8D,R14D
MOV R12,R9
PUSH RAX
CALL 0x00165594
ADD RSP,0x10
MOV EAX,dword ptr [RBX + 0xc18]
ADD EAX,0xc
MOV dword ptr [RBP + -0x3c],EAX
ADD R13,R15
LEA EAX,[R14*0x4]
SUB R13,RAX
MOVZX EAX,word ptr [R13 + -0x6]
ADD R13,-0x8
ADD dword ptr [R12],EAX
MOV dword ptr [RBP + -0x48],0x2
LAB_00165363:
MOV R12,qword ptr [RBP + 0x10]
MOV word ptr [R13 + 0x2],R12W
MOV EDI,dword ptr [RBP + -0x3c]
ADD RDI,R15
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,R12
CALL 0x001270d0
MOV R14D,dword ptr [RBP + -0x2c]
SUB R14D,R12D
MOV dword ptr [RBP + -0x2c],R14D
MOV word ptr [R15 + 0xa],R14W
MOV RDI,RBX
MOV RSI,R15
CALL 0x00162076
TEST AL,AL
JNZ 0x001653a7
MOV dword ptr [RBP + -0x2c],0x0
XOR R14D,R14D
LAB_001653a7:
XOR EDX,EDX
CMP dword ptr [RBP + -0x30],0x1
SETZ DL
MOV R12,qword ptr [RBP + -0x38]
MOV RDI,R12
MOV R13,qword ptr [RBP + -0x60]
MOV RSI,R13
MOV ECX,R14D
CALL 0x001438f3
TEST AL,AL
MOV R14D,dword ptr [RBP + -0x48]
JNZ 0x00165476
MOV R14,R12
XOR R12D,R12D
MOV RAX,qword ptr [RBP + -0x68]
CMP qword ptr [RBP + -0x58],RAX
JBE 0x00165435
MOV RDI,qword ptr [RBX + 0x600]
LEA RSI,[R14 + 0x470]
MOV EAX,dword ptr [RDI + 0x80]
SUB RSP,0x8
XOR R12D,R12D
LEA R10,[RBP + -0x88]
MOV RDX,R13
XOR ECX,ECX
MOV R8,R15
MOV R9D,0x1
PUSH RAX
PUSH R12
PUSH 0x0
PUSH R10
PUSH R12
PUSH qword ptr [RBP + -0x50]
PUSH 0x4
CALL 0x00154c9e
ADD RSP,0x40
TEST AL,AL
JZ 0x00165435
CALL 0x00185b0e
MOV R12D,dword ptr [RAX]
LAB_00165435:
LEA RSI,[RBP + -0x88]
MOV dword ptr [RSI + 0x8],0x6
MOV byte ptr [RSI + 0x10],0x1
MOV RDI,R14
ADD RDI,0x2e8
CALL 0x0017705a
MOV RAX,qword ptr [RBP + -0x58]
CMP qword ptr [RBX + 0x40],RAX
JNC 0x001654bf
MOV qword ptr [RBX + 0x40],RAX
JMP 0x001654bf
LAB_00165466:
MOV R14D,0x2
LAB_0016546c:
MOV ESI,0x7f
CALL 0x00138698
LAB_00165476:
CALL 0x00185b0e
MOV R12D,dword ptr [RAX]
CMP R14D,0x2
JNZ 0x001654af
LAB_00165484:
MOV RDI,qword ptr [RBX + 0x600]
MOV RSI,qword ptr [RBP + -0x88]
XOR EAX,EAX
MOV EDX,0x6
MOV ECX,0x3
XOR R8D,R8D
XOR R9D,R9D
PUSH RAX
PUSH RAX
CALL 0x00153555
ADD RSP,0x10
LAB_001654af:
MOV RDI,RBX
CALL 0x00139e96
CALL 0x00185b0e
MOV dword ptr [RAX],R12D
LAB_001654bf:
MOV EAX,R12D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001654d1:
MOV RDI,qword ptr [RBX + 0x600]
MOV RSI,qword ptr [RBP + -0x88]
MOV EDX,0x6
MOV ECX,0x3
XOR R8D,R8D
XOR R9D,R9D
PUSH R12
PUSH R12
CALL 0x00153555
ADD RSP,0x10
JMP 0x001654bf
|
int4
_ma_apply_redo_insert_row_head_or_tail
(long *param_1,long param_2,int8 param_3,char param_4,uint5 *param_5,void *param_6,
size_t param_7)
{
ulong *puVar1;
ulong uVar2;
byte bVar3;
long lVar4;
uint5 uVar5;
long lVar6;
long *plVar7;
uint uVar8;
char cVar9;
uint uVar10;
ushort *puVar11;
int *piVar12;
int4 *puVar13;
ulong uVar14;
ulong uVar15;
int4 uVar16;
ulong uVar17;
long lVar18;
ushort uVar19;
uint uVar20;
int iVar21;
int1 local_94 [4];
int8 local_90;
int4 local_88;
int1 local_80;
void *local_78;
ulong local_70;
ulong local_68;
ulong local_60;
int8 local_58;
ulong local_50;
uint local_44;
long *local_40;
uint local_38;
uint local_34;
lVar4 = *param_1;
uVar20 = *(uint *)(lVar4 + 0x7bc);
uVar17 = (ulong)uVar20;
uVar5 = *param_5;
uVar2 = (ulong)*param_5;
bVar3 = *(byte *)((long)param_5 + 5);
*(uint *)(lVar4 + 0x170) = *(uint *)(lVar4 + 0x170) | 0x181;
uVar14 = ((ulong)uVar5 + 1) * uVar17;
uVar15 = *(ulong *)(lVar4 + 0x40);
if (uVar14 < uVar15 || uVar14 - uVar15 == 0) {
puVar1 = (ulong *)(*(long *)(lVar4 + 0x600) + 0x198);
*puVar1 = *puVar1 & 0xffffffef;
*(int1 *)(lVar4 + 0x7ec) = 1;
local_78 = param_6;
local_70 = uVar15;
local_68 = uVar2;
local_60 = uVar14;
local_50 = (ulong)bVar3;
local_40 = param_1;
local_38 = (uint)param_3;
puVar11 = (ushort *)
pagecache_read(*(int8 *)(lVar4 + 0x600),param_1 + 0x8e,uVar2,0,0,1,4,&local_90);
uVar2 = local_68;
*(int8 *)(*(long *)(lVar4 + 0x600) + 0x198) =
*(int8 *)(*(long *)(lVar4 + 0x600) + 0x1a0);
*(int1 *)(lVar4 + 0x7ec) = 0;
if (puVar11 == (ushort *)0x0) {
if ((param_4 != '\0') &&
(((piVar12 = (int *)_my_thread_var(), *piVar12 == 0xaf ||
(piVar12 = (int *)_my_thread_var(), *piVar12 == 0xb0)) ||
(piVar12 = (int *)_my_thread_var(), *piVar12 == 0xc0)))) {
puVar11 = (ushort *)pagecache_block_link_to_buffer(local_90);
*(int1 *)((long)puVar11 + 7) = 0;
uVar10 = 0;
goto LAB_001651b9;
}
}
else {
uVar15 = (ulong)*(uint *)((long)puVar11 + 3) |
(ulong)(byte)puVar11[1] << 0x30 | (ulong)*puVar11 << 0x20;
if ((long)uVar15 < param_2) {
uVar10 = *(byte *)((long)puVar11 + 7) & 7;
LAB_001651b9:
uVar8 = local_38;
plVar7 = local_40;
uVar2 = local_50;
if (uVar10 == local_38) {
local_34 = (uint)puVar11[5];
if (((byte)local_50 < (byte)puVar11[4]) ||
(cVar9 = extend_directory(local_40,puVar11,uVar17,(byte)puVar11[4],
local_50 & 0xffffffff,&local_34,local_38 == 1), cVar9 == '\0'
)) {
lVar18 = (long)puVar11 + (uVar17 - (uint)((int)uVar2 * 4)) + -8;
cVar9 = extend_area_on_page(local_40,puVar11,lVar18,uVar2 & 0xffffffff,param_7,&local_34
,&local_44,local_94,local_38 == 1);
if (cVar9 == '\0') {
local_50 = CONCAT44(local_50._4_4_,2);
local_58 = 0;
goto LAB_00165363;
}
}
LAB_00165466:
iVar21 = 2;
param_1 = local_40;
goto LAB_0016546c;
}
if (param_4 == '\0') goto LAB_00165466;
local_58 = 0;
make_empty_page(local_40,puVar11,local_38,0);
uVar2 = local_50;
local_34 = (uVar20 - *(int *)(lVar4 + 0xc18)) - 0x10;
extend_directory(plVar7,puVar11,uVar17,0,local_50 & 0xffffffff,&local_34,uVar8 == 1);
local_44 = *(int *)(lVar4 + 0xc18) + 0xc;
lVar6 = uVar17 - (uint)((int)uVar2 * 4);
lVar18 = (long)puVar11 + lVar6 + -8;
local_34 = local_34 + *(ushort *)((long)puVar11 + lVar6 + -6);
local_50 = CONCAT44(local_50._4_4_,2);
LAB_00165363:
*(short *)(lVar18 + 2) = (short)param_7;
memcpy((void *)((ulong)local_44 + (long)puVar11),local_78,param_7);
uVar20 = local_34 - (int)param_7;
puVar11[5] = (ushort)uVar20;
local_34 = uVar20;
cVar9 = enough_free_entries_on_page(lVar4,puVar11);
plVar7 = local_40;
uVar2 = local_68;
if (cVar9 == '\0') {
local_34 = 0;
uVar20 = 0;
}
cVar9 = _ma_bitmap_set(local_40,local_68,local_38 == 1,uVar20);
iVar21 = (int)local_50;
if (cVar9 == '\0') {
uVar16 = 0;
if (local_70 < local_60) {
uVar16 = 0;
cVar9 = pagecache_write_part
(*(long *)(lVar4 + 0x600),plVar7 + 0x8e,uVar2,0,puVar11,1,4,local_58,0
,&local_90,0,0,*(int4 *)(*(long *)(lVar4 + 0x600) + 0x80));
if (cVar9 != '\0') {
puVar13 = (int4 *)_my_thread_var();
uVar16 = *puVar13;
}
}
local_88 = 6;
local_80 = 1;
insert_dynamic(plVar7 + 0x5d);
if (local_60 <= *(ulong *)(lVar4 + 0x40)) {
return uVar16;
}
*(ulong *)(lVar4 + 0x40) = local_60;
return uVar16;
}
goto LAB_00165476;
}
check_skipped_lsn(local_40,uVar15,1,local_68);
uVar19 = puVar11[5];
cVar9 = enough_free_entries_on_page(lVar4,puVar11);
if (cVar9 == '\0') {
uVar19 = 0;
}
cVar9 = _ma_bitmap_set(local_40,uVar2,local_38 == 1,uVar19);
if (cVar9 == '\0') {
pagecache_unlock_by_link(*(int8 *)(lVar4 + 0x600),local_90,6,3,0,0,0,0);
return 0;
}
}
puVar13 = (int4 *)_my_thread_var();
uVar16 = *puVar13;
}
else {
iVar21 = 4;
if (param_4 != '\0' && bVar3 == 0) {
puVar11 = (ushort *)param_1[0x70];
*(int1 *)((long)param_1 + 0x685) = 1;
local_78 = param_6;
local_70 = uVar15;
local_68 = uVar2;
local_60 = uVar14;
local_40 = param_1;
local_38 = (uint)param_3;
make_empty_page(param_1,puVar11,param_3,1);
local_34 = (uVar20 - *(int *)(lVar4 + 0xc18)) - 0x14;
local_44 = *(int *)(lVar4 + 0xc18) + 0xc;
lVar18 = (long)puVar11 + (uVar17 - 8);
local_50 = CONCAT44(local_50._4_4_,4);
local_58 = 2;
goto LAB_00165363;
}
LAB_0016546c:
_ma_set_fatal_error(param_1,0x7f);
LAB_00165476:
puVar13 = (int4 *)_my_thread_var();
uVar16 = *puVar13;
if (iVar21 != 2) goto LAB_001654af;
}
pagecache_unlock_by_link(*(int8 *)(lVar4 + 0x600),local_90,6,3,0,0,0,0);
LAB_001654af:
_ma_mark_file_crashed(lVar4);
puVar13 = (int4 *)_my_thread_var();
*puVar13 = uVar16;
return uVar16;
}
|
|
6,426 | Vector3Equals | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h | RMAPI int Vector3Equals(Vector3 p, Vector3 q)
{
#if !defined(EPSILON)
#define EPSILON 0.000001f
#endif
int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) &&
((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) &&
((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z)))));
return result;
} | O1 | c | Vector3Equals:
movaps %xmm0, %xmm5
subss %xmm2, %xmm5
movaps 0x703d8(%rip), %xmm4 # 0xd9d00
movaps %xmm0, %xmm6
andps %xmm4, %xmm6
movaps %xmm2, %xmm7
andps %xmm4, %xmm7
movaps %xmm6, %xmm8
cmpunordss %xmm6, %xmm8
movaps %xmm8, %xmm9
andps %xmm7, %xmm9
maxss %xmm6, %xmm7
andnps %xmm7, %xmm8
orps %xmm9, %xmm8
maxss 0x6ffe9(%rip), %xmm8 # 0xd9944
mulss 0x79aec(%rip), %xmm8 # 0xe3450
andps %xmm4, %xmm5
xorl %eax, %eax
ucomiss %xmm5, %xmm8
jb 0x699f8
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
movaps %xmm0, %xmm5
subss %xmm2, %xmm5
andps %xmm4, %xmm5
andps %xmm4, %xmm0
andps %xmm4, %xmm2
movaps %xmm0, %xmm6
cmpunordss %xmm0, %xmm6
movaps %xmm6, %xmm7
andps %xmm2, %xmm7
maxss %xmm0, %xmm2
andnps %xmm2, %xmm6
orps %xmm7, %xmm6
maxss 0x6ff99(%rip), %xmm6 # 0xd9944
mulss 0x79a9d(%rip), %xmm6 # 0xe3450
ucomiss %xmm5, %xmm6
jb 0x699f8
movaps %xmm1, %xmm0
subss %xmm3, %xmm0
andps %xmm4, %xmm0
andps %xmm4, %xmm1
andps %xmm4, %xmm3
movaps %xmm1, %xmm2
cmpunordss %xmm1, %xmm2
movaps %xmm2, %xmm4
andps %xmm3, %xmm4
maxss %xmm1, %xmm3
andnps %xmm3, %xmm2
orps %xmm4, %xmm2
maxss 0x6ff5c(%rip), %xmm2 # 0xd9944
mulss 0x79a60(%rip), %xmm2 # 0xe3450
xorl %eax, %eax
ucomiss %xmm0, %xmm2
setae %al
retq
| Vector3Equals:
movaps xmm5, xmm0
subss xmm5, xmm2
movaps xmm4, cs:xmmword_D9D00
movaps xmm6, xmm0
andps xmm6, xmm4
movaps xmm7, xmm2
andps xmm7, xmm4
movaps xmm8, xmm6
cmpunordss xmm8, xmm6
movaps xmm9, xmm8
andps xmm9, xmm7
maxss xmm7, xmm6
andnps xmm8, xmm7
orps xmm8, xmm9
maxss xmm8, cs:dword_D9944
mulss xmm8, cs:dword_E3450
andps xmm5, xmm4
xor eax, eax
ucomiss xmm8, xmm5
jb locret_699F8
shufps xmm0, xmm0, 55h ; 'U'
shufps xmm2, xmm2, 55h ; 'U'
movaps xmm5, xmm0
subss xmm5, xmm2
andps xmm5, xmm4
andps xmm0, xmm4
andps xmm2, xmm4
movaps xmm6, xmm0
cmpunordss xmm6, xmm0
movaps xmm7, xmm6
andps xmm7, xmm2
maxss xmm2, xmm0
andnps xmm6, xmm2
orps xmm6, xmm7
maxss xmm6, cs:dword_D9944
mulss xmm6, cs:dword_E3450
ucomiss xmm6, xmm5
jb short locret_699F8
movaps xmm0, xmm1
subss xmm0, xmm3
andps xmm0, xmm4
andps xmm1, xmm4
andps xmm3, xmm4
movaps xmm2, xmm1
cmpunordss xmm2, xmm1
movaps xmm4, xmm2
andps xmm4, xmm3
maxss xmm3, xmm1
andnps xmm2, xmm3
orps xmm2, xmm4
maxss xmm2, cs:dword_D9944
mulss xmm2, cs:dword_E3450
xor eax, eax
ucomiss xmm2, xmm0
setnb al
locret_699F8:
retn
| _BOOL8 Vector3Equals(__m128 a1, __m128 a2, __m128 a3, __m128 a4)
{
__m128 v4; // xmm6
__m128 v5; // xmm7
__m128 v6; // xmm8
__int32 v7; // xmm9_4
_BOOL8 result; // rax
__m128 v9; // xmm0
__m128 v10; // xmm2
float v11; // xmm5_4
__m128 v12; // xmm0
__m128 v13; // xmm2
__m128 v14; // xmm6
__int32 v15; // xmm7_4
float v16; // xmm0_4
__m128 v17; // xmm1
__m128 v18; // xmm3
__m128 v19; // xmm2
__int32 v20; // xmm4_4
v4 = _mm_and_ps(a1, (__m128)xmmword_D9D00);
v5 = _mm_and_ps(a3, (__m128)xmmword_D9D00);
v6 = _mm_cmpunord_ss(v4, v4);
v7 = v6.m128_i32[0] & v5.m128_i32[0];
v5.m128_f32[0] = fmaxf(v5.m128_f32[0], v4.m128_f32[0]);
result = 0LL;
if ( (float)(fmaxf(COERCE_FLOAT(_mm_andnot_ps(v6, v5).m128_u32[0] | v7), 1.0) * 0.000001) >= fabs(
a1.m128_f32[0]
- a3.m128_f32[0]) )
{
v9 = _mm_shuffle_ps(a1, a1, 85);
v10 = _mm_shuffle_ps(a3, a3, 85);
v11 = fabs(v9.m128_f32[0] - v10.m128_f32[0]);
v12 = _mm_and_ps(v9, (__m128)xmmword_D9D00);
v13 = _mm_and_ps(v10, (__m128)xmmword_D9D00);
v14 = _mm_cmpunord_ss(v12, v12);
v15 = v14.m128_i32[0] & v13.m128_i32[0];
v13.m128_f32[0] = fmaxf(v13.m128_f32[0], v12.m128_f32[0]);
if ( (float)(fmaxf(COERCE_FLOAT(_mm_andnot_ps(v14, v13).m128_u32[0] | v15), 1.0) * 0.000001) >= v11 )
{
v16 = a2.m128_f32[0] - a4.m128_f32[0];
v17 = _mm_and_ps(a2, (__m128)xmmword_D9D00);
v18 = _mm_and_ps(a4, (__m128)xmmword_D9D00);
v19 = _mm_cmpunord_ss(v17, v17);
v20 = v19.m128_i32[0] & v18.m128_i32[0];
v18.m128_f32[0] = fmaxf(v18.m128_f32[0], v17.m128_f32[0]);
return (float)(fmaxf(COERCE_FLOAT(_mm_andnot_ps(v19, v18).m128_u32[0] | v20), 1.0) * 0.000001) >= fabs(v16);
}
}
return result;
}
| Vector3Equals:
MOVAPS XMM5,XMM0
SUBSS XMM5,XMM2
MOVAPS XMM4,xmmword ptr [0x001d9d00]
MOVAPS XMM6,XMM0
ANDPS XMM6,XMM4
MOVAPS XMM7,XMM2
ANDPS XMM7,XMM4
MOVAPS XMM8,XMM6
CMPUNORDSS XMM8,XMM6
MOVAPS XMM9,XMM8
ANDPS XMM9,XMM7
MAXSS XMM7,XMM6
ANDNPS XMM8,XMM7
ORPS XMM8,XMM9
MAXSS XMM8,dword ptr [0x001d9944]
MULSS XMM8,dword ptr [0x001e3450]
ANDPS XMM5,XMM4
XOR EAX,EAX
UCOMISS XMM8,XMM5
JC 0x001699f8
SHUFPS XMM0,XMM0,0x55
SHUFPS XMM2,XMM2,0x55
MOVAPS XMM5,XMM0
SUBSS XMM5,XMM2
ANDPS XMM5,XMM4
ANDPS XMM0,XMM4
ANDPS XMM2,XMM4
MOVAPS XMM6,XMM0
CMPUNORDSS XMM6,XMM0
MOVAPS XMM7,XMM6
ANDPS XMM7,XMM2
MAXSS XMM2,XMM0
ANDNPS XMM6,XMM2
ORPS XMM6,XMM7
MAXSS XMM6,dword ptr [0x001d9944]
MULSS XMM6,dword ptr [0x001e3450]
UCOMISS XMM6,XMM5
JC 0x001699f8
MOVAPS XMM0,XMM1
SUBSS XMM0,XMM3
ANDPS XMM0,XMM4
ANDPS XMM1,XMM4
ANDPS XMM3,XMM4
MOVAPS XMM2,XMM1
CMPUNORDSS XMM2,XMM1
MOVAPS XMM4,XMM2
ANDPS XMM4,XMM3
MAXSS XMM3,XMM1
ANDNPS XMM2,XMM3
ORPS XMM2,XMM4
MAXSS XMM2,dword ptr [0x001d9944]
MULSS XMM2,dword ptr [0x001e3450]
XOR EAX,EAX
UCOMISS XMM2,XMM0
SETNC AL
LAB_001699f8:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
bool Vector3Equals(int8 param_1,float param_2,int8 param_3,float param_4)
{
bool bVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
fVar3 = (float)((ulong)param_3 >> 0x20);
fVar2 = (float)((ulong)param_1 >> 0x20);
fVar5 = (float)((uint)(float)param_1 & _DAT_001d9d00);
fVar6 = (float)((uint)(float)param_3 & _DAT_001d9d00);
fVar4 = fVar6;
if (fVar6 <= fVar5) {
fVar4 = fVar5;
}
fVar4 = (float)(~-(uint)NAN(fVar5) & (uint)fVar4 | -(uint)NAN(fVar5) & (uint)fVar6);
if (fVar4 <= DAT_001d9944) {
fVar4 = DAT_001d9944;
}
bVar1 = false;
if ((float)((uint)((float)param_1 - (float)param_3) & _DAT_001d9d00) <= fVar4 * DAT_001e3450) {
fVar5 = (float)((uint)fVar2 & _DAT_001d9d00);
fVar6 = (float)((uint)fVar3 & _DAT_001d9d00);
fVar4 = fVar6;
if (fVar6 <= fVar5) {
fVar4 = fVar5;
}
fVar4 = (float)(~-(uint)NAN(fVar5) & (uint)fVar4 | -(uint)NAN(fVar5) & (uint)fVar6);
if (fVar4 <= DAT_001d9944) {
fVar4 = DAT_001d9944;
}
if ((float)((uint)(fVar2 - fVar3) & _DAT_001d9d00) <= fVar4 * DAT_001e3450) {
fVar2 = (float)((uint)param_2 & _DAT_001d9d00);
fVar3 = (float)((uint)param_4 & _DAT_001d9d00);
fVar4 = fVar3;
if (fVar3 <= fVar2) {
fVar4 = fVar2;
}
fVar4 = (float)(~-(uint)NAN(fVar2) & (uint)fVar4 | -(uint)NAN(fVar2) & (uint)fVar3);
if (fVar4 <= DAT_001d9944) {
fVar4 = DAT_001d9944;
}
bVar1 = (float)((uint)(param_2 - param_4) & _DAT_001d9d00) <= fVar4 * DAT_001e3450;
}
}
return bVar1;
}
|
|
6,427 | ecp_mod_p384 | msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/ecp_curves.c | static int ecp_mod_p384(mbedtls_mpi *N)
{
INIT(384);
ADD(12); ADD(21); ADD(20);
SUB(23); NEXT; // A0
ADD(13); ADD(22); ADD(23);
SUB(12); SUB(20); NEXT; // A2
ADD(14); ADD(23);
SUB(13); SUB(21); NEXT; // A2
ADD(15); ADD(12); ADD(20); ADD(21);
SUB(14); SUB(22); SUB(23); NEXT; // A3
ADD(21); ADD(21); ADD(16); ADD(13); ADD(12); ADD(20); ADD(22);
SUB(15); SUB(23); SUB(23); NEXT; // A4
ADD(22); ADD(22); ADD(17); ADD(14); ADD(13); ADD(21); ADD(23);
SUB(16); NEXT; // A5
ADD(23); ADD(23); ADD(18); ADD(15); ADD(14); ADD(22);
SUB(17); NEXT; // A6
ADD(19); ADD(16); ADD(15); ADD(23);
SUB(18); NEXT; // A7
ADD(20); ADD(17); ADD(16);
SUB(19); NEXT; // A8
ADD(21); ADD(18); ADD(17);
SUB(20); NEXT; // A9
ADD(22); ADD(19); ADD(18);
SUB(21); NEXT; // A10
ADD(23); ADD(20); ADD(19);
SUB(22); LAST; // A11
cleanup:
return ret;
} | O3 | c | ecp_mod_p384:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0xd, %esi
callq 0x7df41
movl %eax, %ebp
testl %eax, %eax
jne 0x888cb
movl %ebp, 0xc(%rsp)
movq 0x10(%rbx), %rax
movq (%rax), %r11
movq 0x30(%rax), %r13
movl %r13d, %r9d
addl %r11d, %r9d
setb %cl
movq 0x50(%rax), %rdx
movq %rdx, %r8
shrq $0x20, %r8
addl %r8d, %r9d
setb %r10b
addl %edx, %r9d
adcb %cl, %r10b
movq 0x58(%rax), %rsi
movq %rsi, %rdi
shrq $0x20, %rdi
subl %edi, %r9d
sbbb $0x0, %r10b
shrq $0x20, %r11
movsbl %r10b, %r10d
testb %r10b, %r10b
js 0x884d2
addl %r11d, %r10d
setb %bpl
jmp 0x884e1
movl %r10d, %ecx
negl %ecx
xorl %ebp, %ebp
cmpl %ecx, %r11d
sbbl %ebp, %ebp
addl %r11d, %r10d
movq %r13, %r11
shrq $0x20, %r11
addl %r11d, %r10d
adcb $0x0, %bpl
addl %esi, %r10d
setb %cl
addl %edi, %r10d
adcb %bpl, %cl
subl %r13d, %r10d
setb %bpl
subl %edx, %r10d
sbbb %bpl, %cl
shlq $0x20, %r10
orq %r9, %r10
movq %r10, (%rax)
movq 0x8(%rax), %r9
movsbl %cl, %r14d
testb %r14b, %r14b
js 0x88527
addl %r9d, %r14d
setb %cl
jmp 0x88537
movl %r14d, %r10d
negl %r10d
xorl %ecx, %ecx
cmpl %r10d, %r9d
sbbl %ecx, %ecx
addl %r9d, %r14d
movq 0x38(%rax), %r10
addl %r10d, %r14d
setb %bpl
addl %edi, %r14d
adcb %cl, %bpl
subl %r11d, %r14d
setb %cl
subl %r8d, %r14d
sbbb %cl, %bpl
shrq $0x20, %r9
movsbl %bpl, %r15d
testb %r15b, %r15b
js 0x8856a
addl %r9d, %r15d
setb %bpl
jmp 0x88579
movl %r15d, %ecx
negl %ecx
xorl %ebp, %ebp
cmpl %ecx, %r9d
sbbl %ebp, %ebp
addl %r9d, %r15d
movq %r10, %r9
shrq $0x20, %r9
addl %r9d, %r15d
setb %cl
addl %r13d, %r15d
adcb %bpl, %cl
addl %edx, %r15d
setb %bpl
addl %r8d, %r15d
adcb %cl, %bpl
subl %r10d, %r15d
sbbb $0x0, %bpl
subl %esi, %r15d
setb %cl
subl %edi, %r15d
sbbb %cl, %bpl
shlq $0x20, %r15
orq %r14, %r15
movq %r15, 0x8(%rax)
movq 0x10(%rax), %r15
movsbl %bpl, %r12d
testb %r12b, %r12b
js 0x885cd
addl %r15d, %r12d
setb %bpl
jmp 0x885dc
movl %r12d, %ecx
negl %ecx
xorl %ebp, %ebp
cmpl %ecx, %r15d
sbbl %ebp, %ebp
addl %r15d, %r12d
addl %r8d, %r12d
adcb $0x0, %bpl
addl %r8d, %r12d
setb %cl
movq 0x40(%rax), %r14
addl %r14d, %r12d
adcb %bpl, %cl
addl %r11d, %r12d
setb %bpl
movq %r13, 0x10(%rsp)
addl %r13d, %r12d
adcb %cl, %bpl
addl %edx, %r12d
setb %cl
addl %esi, %r12d
adcb %bpl, %cl
subl %r9d, %r12d
sbbb $0x0, %cl
subl %edi, %r12d
setb %bpl
subl %edi, %r12d
sbbb %bpl, %cl
shrq $0x20, %r15
movsbl %cl, %r13d
testb %r13b, %r13b
js 0x8863a
addl %r15d, %r13d
setb %bpl
jmp 0x88649
movl %r13d, %ecx
negl %ecx
xorl %ebp, %ebp
cmpl %ecx, %r15d
sbbl %ebp, %ebp
addl %r15d, %r13d
addl %esi, %r13d
adcb $0x0, %bpl
addl %esi, %r13d
setb %cl
movq %r14, %r15
shrq $0x20, %r15
addl %r15d, %r13d
adcb %bpl, %cl
addl %r10d, %r13d
setb %bpl
addl %r11d, %r13d
adcb %cl, %bpl
addl %r8d, %r13d
setb %cl
addl %edi, %r13d
adcb %bpl, %cl
subl %r14d, %r13d
sbbb $0x0, %cl
shlq $0x20, %r13
orq %r12, %r13
movq %r13, 0x10(%rax)
movq 0x18(%rax), %r13
movsbl %cl, %r12d
testb %r12b, %r12b
js 0x886a2
addl %r13d, %r12d
setb %cl
jmp 0x886b2
movl %r12d, %r11d
negl %r11d
xorl %ecx, %ecx
cmpl %r11d, %r13d
sbbl %ecx, %ecx
addl %r13d, %r12d
addl %edi, %r12d
setb %bpl
addl %edi, %r12d
adcb %cl, %bpl
movq 0x48(%rax), %r11
addl %r11d, %r12d
setb %cl
addl %r9d, %r12d
adcb %bpl, %cl
addl %r10d, %r12d
setb %r10b
addl %esi, %r12d
adcb %cl, %r10b
subl %r15d, %r12d
sbbb $0x0, %r10b
shrq $0x20, %r13
movsbl %r10b, %ebp
testb %bpl, %bpl
js 0x886f8
addl %r13d, %ebp
setb %cl
jmp 0x88708
movl %ebp, %r10d
negl %r10d
xorl %ecx, %ecx
cmpl %r10d, %r13d
sbbl %ecx, %ecx
addl %r13d, %ebp
movq %r11, %r10
shrq $0x20, %r10
addl %r10d, %ebp
setb %r13b
addl %r14d, %ebp
adcb %cl, %r13b
addl %r9d, %ebp
setb %cl
addl %edi, %ebp
adcb %r13b, %cl
subl %r11d, %ebp
sbbb $0x0, %cl
shlq $0x20, %rbp
orq %r12, %rbp
movq %rbp, 0x18(%rax)
movq 0x20(%rax), %r12
movsbl %cl, %r9d
testb %r9b, %r9b
js 0x8874e
addl %r12d, %r9d
setb %bpl
jmp 0x8875d
movl %r9d, %ecx
negl %ecx
xorl %ebp, %ebp
cmpl %ecx, %r12d
sbbl %ebp, %ebp
addl %r12d, %r9d
movq 0x10(%rsp), %r13
addl %edx, %r9d
adcb $0x0, %bpl
addl %r15d, %r9d
setb %cl
addl %r14d, %r9d
adcb %bpl, %cl
subl %r10d, %r9d
sbbb $0x0, %cl
shrq $0x20, %r12
movsbl %cl, %r14d
testb %r14b, %r14b
js 0x88791
addl %r12d, %r14d
setb %bpl
jmp 0x887a0
movl %r14d, %ecx
negl %ecx
xorl %ebp, %ebp
cmpl %ecx, %r12d
sbbl %ebp, %ebp
addl %r12d, %r14d
addl %r8d, %r14d
adcb $0x0, %bpl
addl %r11d, %r14d
setb %cl
addl %r15d, %r14d
adcb %bpl, %cl
subl %edx, %r14d
sbbb $0x0, %cl
shlq $0x20, %r14
orq %r9, %r14
movq %r14, 0x20(%rax)
movq 0x28(%rax), %r14
movsbl %cl, %r9d
testb %r9b, %r9b
js 0x887da
addl %r14d, %r9d
setb %bpl
jmp 0x887e9
movl %r9d, %ecx
negl %ecx
xorl %ebp, %ebp
cmpl %ecx, %r14d
sbbl %ebp, %ebp
addl %r14d, %r9d
addl %esi, %r9d
adcb $0x0, %bpl
addl %r10d, %r9d
setb %cl
addl %r11d, %r9d
adcb %bpl, %cl
subl %r8d, %r9d
sbbb $0x0, %cl
shrq $0x20, %r14
movsbl %cl, %r8d
testb %r8b, %r8b
js 0x88818
addl %r14d, %r8d
setb %r11b
jmp 0x88829
movl %r8d, %ecx
negl %ecx
xorl %r11d, %r11d
cmpl %ecx, %r14d
sbbl %r11d, %r11d
addl %r14d, %r8d
movl 0xc(%rsp), %ebp
addl %edi, %r8d
adcb $0x0, %r11b
addl %edx, %r8d
setb %dl
addl %r10d, %r8d
adcb %r11b, %dl
subl %esi, %r8d
sbbb $0x0, %dl
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
shlq $0x20, %r8
orq %r9, %r8
movzbl %dl, %ecx
xorl %edi, %edi
testb %cl, %cl
cmovgl %ecx, %edi
movq %r8, 0x28(%rax)
andq %rsi, %r13
movzbl %dil, %ecx
orq %r13, %rcx
movq %rcx, 0x30(%rax)
movq 0x8(%rbx), %rcx
addq %rcx, %rcx
cmpq $0xe, %rcx
jb 0x888b7
movl $0xc, %edi
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
leaq 0x1(%rdi), %r8
movq %r8, %r9
andq $-0x2, %r9
testb $0x1, %dil
movq %rsi, %r10
cmoveq %rcx, %r10
andq %r10, (%rax,%r9,4)
movq 0x8(%rbx), %r9
addq %r9, %r9
addq $0x2, %rdi
cmpq %r9, %rdi
movq %r8, %rdi
jb 0x8888a
testb %dl, %dl
jns 0x888cb
movsbl %dl, %esi
movl $0x180, %edx # imm = 0x180
movq %rbx, %rdi
callq 0x88c1e
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ecp_mod_p384:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov esi, 0Dh
call mbedtls_mpi_grow
mov ebp, eax
test eax, eax
jnz loc_888CB
mov [rsp+48h+var_3C], ebp
mov rax, [rbx+10h]
mov r11, [rax]
mov r13, [rax+30h]
mov r9d, r13d
add r9d, r11d
setb cl
mov rdx, [rax+50h]
mov r8, rdx
shr r8, 20h
add r9d, r8d
setb r10b
add r9d, edx
adc r10b, cl
mov rsi, [rax+58h]
mov rdi, rsi
shr rdi, 20h
sub r9d, edi
sbb r10b, 0
shr r11, 20h
movsx r10d, r10b
test r10b, r10b
js short loc_884D2
add r10d, r11d
setb bpl
jmp short loc_884E1
loc_884D2:
mov ecx, r10d
neg ecx
xor ebp, ebp
cmp r11d, ecx
sbb ebp, ebp
add r10d, r11d
loc_884E1:
mov r11, r13
shr r11, 20h
add r10d, r11d
adc bpl, 0
add r10d, esi
setb cl
add r10d, edi
adc cl, bpl
sub r10d, r13d
setb bpl
sub r10d, edx
sbb cl, bpl
shl r10, 20h
or r10, r9
mov [rax], r10
mov r9, [rax+8]
movsx r14d, cl
test r14b, r14b
js short loc_88527
add r14d, r9d
setb cl
jmp short loc_88537
loc_88527:
mov r10d, r14d
neg r10d
xor ecx, ecx
cmp r9d, r10d
sbb ecx, ecx
add r14d, r9d
loc_88537:
mov r10, [rax+38h]
add r14d, r10d
setb bpl
add r14d, edi
adc bpl, cl
sub r14d, r11d
setb cl
sub r14d, r8d
sbb bpl, cl
shr r9, 20h
movsx r15d, bpl
test r15b, r15b
js short loc_8856A
add r15d, r9d
setb bpl
jmp short loc_88579
loc_8856A:
mov ecx, r15d
neg ecx
xor ebp, ebp
cmp r9d, ecx
sbb ebp, ebp
add r15d, r9d
loc_88579:
mov r9, r10
shr r9, 20h
add r15d, r9d
setb cl
add r15d, r13d
adc cl, bpl
add r15d, edx
setb bpl
add r15d, r8d
adc bpl, cl
sub r15d, r10d
sbb bpl, 0
sub r15d, esi
setb cl
sub r15d, edi
sbb bpl, cl
shl r15, 20h
or r15, r14
mov [rax+8], r15
mov r15, [rax+10h]
movsx r12d, bpl
test r12b, r12b
js short loc_885CD
add r12d, r15d
setb bpl
jmp short loc_885DC
loc_885CD:
mov ecx, r12d
neg ecx
xor ebp, ebp
cmp r15d, ecx
sbb ebp, ebp
add r12d, r15d
loc_885DC:
add r12d, r8d
adc bpl, 0
add r12d, r8d
setb cl
mov r14, [rax+40h]
add r12d, r14d
adc cl, bpl
add r12d, r11d
setb bpl
mov [rsp+48h+var_38], r13
add r12d, r13d
adc bpl, cl
add r12d, edx
setb cl
add r12d, esi
adc cl, bpl
sub r12d, r9d
sbb cl, 0
sub r12d, edi
setb bpl
sub r12d, edi
sbb cl, bpl
shr r15, 20h
movsx r13d, cl
test r13b, r13b
js short loc_8863A
add r13d, r15d
setb bpl
jmp short loc_88649
loc_8863A:
mov ecx, r13d
neg ecx
xor ebp, ebp
cmp r15d, ecx
sbb ebp, ebp
add r13d, r15d
loc_88649:
add r13d, esi
adc bpl, 0
add r13d, esi
setb cl
mov r15, r14
shr r15, 20h
add r13d, r15d
adc cl, bpl
add r13d, r10d
setb bpl
add r13d, r11d
adc bpl, cl
add r13d, r8d
setb cl
add r13d, edi
adc cl, bpl
sub r13d, r14d
sbb cl, 0
shl r13, 20h
or r13, r12
mov [rax+10h], r13
mov r13, [rax+18h]
movsx r12d, cl
test r12b, r12b
js short loc_886A2
add r12d, r13d
setb cl
jmp short loc_886B2
loc_886A2:
mov r11d, r12d
neg r11d
xor ecx, ecx
cmp r13d, r11d
sbb ecx, ecx
add r12d, r13d
loc_886B2:
add r12d, edi
setb bpl
add r12d, edi
adc bpl, cl
mov r11, [rax+48h]
add r12d, r11d
setb cl
add r12d, r9d
adc cl, bpl
add r12d, r10d
setb r10b
add r12d, esi
adc r10b, cl
sub r12d, r15d
sbb r10b, 0
shr r13, 20h
movsx ebp, r10b
test bpl, bpl
js short loc_886F8
add ebp, r13d
setb cl
jmp short loc_88708
loc_886F8:
mov r10d, ebp
neg r10d
xor ecx, ecx
cmp r13d, r10d
sbb ecx, ecx
add ebp, r13d
loc_88708:
mov r10, r11
shr r10, 20h
add ebp, r10d
setb r13b
add ebp, r14d
adc r13b, cl
add ebp, r9d
setb cl
add ebp, edi
adc cl, r13b
sub ebp, r11d
sbb cl, 0
shl rbp, 20h
or rbp, r12
mov [rax+18h], rbp
mov r12, [rax+20h]
movsx r9d, cl
test r9b, r9b
js short loc_8874E
add r9d, r12d
setb bpl
jmp short loc_8875D
loc_8874E:
mov ecx, r9d
neg ecx
xor ebp, ebp
cmp r12d, ecx
sbb ebp, ebp
add r9d, r12d
loc_8875D:
mov r13, [rsp+48h+var_38]
add r9d, edx
adc bpl, 0
add r9d, r15d
setb cl
add r9d, r14d
adc cl, bpl
sub r9d, r10d
sbb cl, 0
shr r12, 20h
movsx r14d, cl
test r14b, r14b
js short loc_88791
add r14d, r12d
setb bpl
jmp short loc_887A0
loc_88791:
mov ecx, r14d
neg ecx
xor ebp, ebp
cmp r12d, ecx
sbb ebp, ebp
add r14d, r12d
loc_887A0:
add r14d, r8d
adc bpl, 0
add r14d, r11d
setb cl
add r14d, r15d
adc cl, bpl
sub r14d, edx
sbb cl, 0
shl r14, 20h
or r14, r9
mov [rax+20h], r14
mov r14, [rax+28h]
movsx r9d, cl
test r9b, r9b
js short loc_887DA
add r9d, r14d
setb bpl
jmp short loc_887E9
loc_887DA:
mov ecx, r9d
neg ecx
xor ebp, ebp
cmp r14d, ecx
sbb ebp, ebp
add r9d, r14d
loc_887E9:
add r9d, esi
adc bpl, 0
add r9d, r10d
setb cl
add r9d, r11d
adc cl, bpl
sub r9d, r8d
sbb cl, 0
shr r14, 20h
movsx r8d, cl
test r8b, r8b
js short loc_88818
add r8d, r14d
setb r11b
jmp short loc_88829
loc_88818:
mov ecx, r8d
neg ecx
xor r11d, r11d
cmp r14d, ecx
sbb r11d, r11d
add r8d, r14d
loc_88829:
mov ebp, [rsp+48h+var_3C]
add r8d, edi
adc r11b, 0
add r8d, edx
setb dl
add r8d, r10d
adc dl, r11b
sub r8d, esi
sbb dl, 0
mov rsi, 0FFFFFFFF00000000h
shl r8, 20h
or r8, r9
movzx ecx, dl
xor edi, edi
test cl, cl
cmovg edi, ecx
mov [rax+28h], r8
and r13, rsi
movzx ecx, dil
or rcx, r13
mov [rax+30h], rcx
mov rcx, [rbx+8]
add rcx, rcx
cmp rcx, 0Eh
jb short loc_888B7
mov edi, 0Ch
mov ecx, 0FFFFFFFFh
loc_8888A:
lea r8, [rdi+1]
mov r9, r8
and r9, 0FFFFFFFFFFFFFFFEh
test dil, 1
mov r10, rsi
cmovz r10, rcx
and [rax+r9*4], r10
mov r9, [rbx+8]
add r9, r9
add rdi, 2
cmp rdi, r9
mov rdi, r8
jb short loc_8888A
loc_888B7:
test dl, dl
jns short loc_888CB
movsx esi, dl
mov edx, 180h
mov rdi, rbx
call mbedtls_ecp_fix_negative
loc_888CB:
mov eax, ebp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ecp_mod_p384(long long a1)
{
unsigned int v2; // ebp
unsigned long long *v3; // rax
unsigned long long v4; // r13
int v5; // r9d
unsigned long long v6; // rdx
bool v7; // cf
int v8; // r9d
bool v9; // r10
unsigned int v10; // r9d
char v11; // r10
unsigned long long v12; // rsi
long long v13; // r9
unsigned long long v14; // r11
int v15; // r10d
int v16; // r10d
int v17; // ebp
unsigned long long v18; // r11
int v19; // r10d
char v20; // bp
int v21; // r10d
bool v22; // cl
unsigned int v23; // r10d
char v24; // cl
unsigned int v25; // r10d
char v26; // cl
unsigned long long v27; // r9
int v28; // r14d
int v29; // r14d
int v30; // ecx
unsigned long long v31; // r10
int v32; // r14d
bool v33; // bp
unsigned int v34; // r14d
char v35; // bp
unsigned int v36; // r14d
bool v37; // cl
long long v38; // r14
char v39; // bp
unsigned long long v40; // r9
int v41; // r15d
int v42; // r15d
int v43; // ebp
unsigned long long v44; // r9
int v45; // r15d
bool v46; // cl
int v47; // r15d
char v48; // cl
int v49; // r15d
bool v50; // bp
unsigned int v51; // r15d
char v52; // bp
unsigned int v53; // r15d
char v54; // bp
unsigned int v55; // r15d
char v56; // bp
unsigned long long v57; // r15
int v58; // r12d
int v59; // r12d
int v60; // ebp
int v61; // r12d
char v62; // bp
int v63; // r12d
bool v64; // cl
unsigned long long v65; // r14
int v66; // r12d
char v67; // cl
int v68; // r12d
bool v69; // bp
int v70; // r12d
char v71; // bp
int v72; // r12d
bool v73; // cl
unsigned int v74; // r12d
char v75; // cl
unsigned int v76; // r12d
char v77; // cl
unsigned int v78; // r12d
bool v79; // bp
long long v80; // r12
char v81; // cl
unsigned long long v82; // r15
int v83; // r13d
int v84; // ebp
int v85; // r13d
char v86; // bp
int v87; // r13d
bool v88; // cl
unsigned long long v89; // r15
int v90; // r13d
char v91; // cl
int v92; // r13d
bool v93; // bp
int v94; // r13d
char v95; // bp
int v96; // r13d
bool v97; // cl
unsigned int v98; // r13d
char v99; // cl
unsigned long long v100; // r13
int v101; // r12d
int v102; // r12d
int v103; // ecx
int v104; // r12d
bool v105; // bp
int v106; // r12d
char v107; // bp
unsigned long long v108; // r11
int v109; // r12d
bool v110; // cl
int v111; // r12d
char v112; // cl
int v113; // r12d
bool v114; // r10
unsigned int v115; // r12d
char v116; // r10
long long v117; // r12
char v118; // r10
unsigned long long v119; // r13
int v120; // ebp
int v121; // ecx
unsigned long long v122; // r10
int v123; // ebp
bool v124; // r13
int v125; // ebp
char v126; // r13
int v127; // ebp
bool v128; // cl
unsigned int v129; // ebp
char v130; // cl
unsigned long long v131; // r12
int v132; // r9d
int v133; // ebp
int v134; // r9d
char v135; // bp
int v136; // r9d
bool v137; // cl
unsigned int v138; // r9d
char v139; // cl
long long v140; // r9
char v141; // cl
unsigned long long v142; // r12
int v143; // r14d
int v144; // ebp
int v145; // r14d
char v146; // bp
int v147; // r14d
bool v148; // cl
unsigned int v149; // r14d
char v150; // cl
unsigned long long v151; // r14
int v152; // r9d
int v153; // ebp
int v154; // r9d
char v155; // bp
int v156; // r9d
bool v157; // cl
unsigned int v158; // r9d
char v159; // cl
long long v160; // r9
char v161; // cl
unsigned long long v162; // r14
int v163; // r8d
int v164; // r11d
int v165; // r8d
char v166; // r11
int v167; // r8d
bool v168; // dl
unsigned int v169; // r8d
char v170; // dl
unsigned long long v171; // r8
unsigned __int8 v172; // di
long long v173; // rdi
unsigned long long v174; // r10
unsigned long long v176; // [rsp+10h] [rbp-38h]
v2 = mbedtls_mpi_grow(a1, 0xDuLL);
if ( !v2 )
{
v3 = *(unsigned long long **)(a1 + 16);
v4 = v3[6];
v5 = *v3 + v4;
v6 = v3[10];
v7 = __CFADD__(HIDWORD(v6), v5);
v8 = HIDWORD(v6) + v5;
v9 = v7;
v7 = __CFADD__((_DWORD)v6, v8);
v10 = v6 + v8;
v11 = __CFADD__((unsigned int)*v3, (_DWORD)v4) + v7 + v9;
v12 = v3[11];
v7 = v10 < HIDWORD(v12);
v13 = v10 - HIDWORD(v12);
v14 = HIDWORD(*v3);
v15 = (char)(v11 - v7);
if ( (v15 & 0x80u) != 0 )
{
v17 = -((unsigned int)v14 < -v15);
v16 = v14 + v15;
}
else
{
v7 = __CFADD__((_DWORD)v14, v15);
v16 = v14 + v15;
LOBYTE(v17) = v7;
}
v18 = HIDWORD(v4);
v7 = __CFADD__(HIDWORD(v4), v16);
v19 = HIDWORD(v4) + v16;
v20 = v7 + v17;
v7 = __CFADD__((_DWORD)v12, v19);
v21 = v12 + v19;
v22 = v7;
v7 = __CFADD__(HIDWORD(v12), v21);
v23 = HIDWORD(v12) + v21;
v24 = v20 + v7 + v22;
v7 = v23 < (unsigned int)v4;
v25 = v23 - v4;
v26 = v24 - ((v25 < (unsigned int)v6) + v7);
*v3 = v13 | ((unsigned long long)(v25 - (unsigned int)v6) << 32);
v27 = v3[1];
v28 = v26;
if ( v26 < 0 )
{
v30 = -((unsigned int)v27 < -v26);
v29 = v27 + v28;
}
else
{
v29 = v27 + v26;
LOBYTE(v30) = __CFADD__((_DWORD)v27, v26);
}
v31 = v3[7];
v7 = __CFADD__((_DWORD)v31, v29);
v32 = v31 + v29;
v33 = v7;
v7 = __CFADD__(HIDWORD(v12), v32);
v34 = HIDWORD(v12) + v32;
v35 = v30 + v7 + v33;
v7 = v34 < HIDWORD(v4);
v36 = v34 - HIDWORD(v4);
v37 = v7;
v7 = v36 < HIDWORD(v6);
v38 = v36 - HIDWORD(v6);
v39 = v35 - (v7 + v37);
v40 = HIDWORD(v27);
v41 = v39;
if ( v39 < 0 )
{
v43 = -((unsigned int)v40 < -v39);
v42 = v40 + v41;
}
else
{
v42 = v40 + v39;
LOBYTE(v43) = __CFADD__((_DWORD)v40, v39);
}
v44 = HIDWORD(v31);
v7 = __CFADD__(HIDWORD(v31), v42);
v45 = HIDWORD(v31) + v42;
v46 = v7;
v7 = __CFADD__((_DWORD)v4, v45);
v47 = v4 + v45;
v48 = v43 + v7 + v46;
v7 = __CFADD__((_DWORD)v6, v47);
v49 = v6 + v47;
v50 = v7;
v7 = __CFADD__(HIDWORD(v6), v49);
v51 = HIDWORD(v6) + v49;
v52 = v48 + v7 + v50;
v7 = v51 < (unsigned int)v31;
v53 = v51 - v31;
v54 = v52 - v7;
v7 = v53 < (unsigned int)v12;
v55 = v53 - v12;
v56 = v54 - ((v55 < HIDWORD(v12)) + v7);
v3[1] = v38 | ((unsigned long long)(v55 - HIDWORD(v12)) << 32);
v57 = v3[2];
v58 = v56;
if ( v56 < 0 )
{
v60 = -((unsigned int)v57 < -v56);
v59 = v57 + v58;
}
else
{
v59 = v57 + v56;
LOBYTE(v60) = __CFADD__((_DWORD)v57, v56);
}
v7 = __CFADD__(HIDWORD(v6), v59);
v61 = HIDWORD(v6) + v59;
v62 = v7 + v60;
v7 = __CFADD__(HIDWORD(v6), v61);
v63 = HIDWORD(v6) + v61;
v64 = v7;
v65 = v3[8];
v7 = __CFADD__((_DWORD)v65, v63);
v66 = v65 + v63;
v67 = v62 + v7 + v64;
v7 = __CFADD__(HIDWORD(v4), v66);
v68 = HIDWORD(v4) + v66;
v69 = v7;
v176 = v4;
v7 = __CFADD__((_DWORD)v4, v68);
v70 = v4 + v68;
v71 = v67 + v7 + v69;
v7 = __CFADD__((_DWORD)v6, v70);
v72 = v6 + v70;
v73 = v7;
v7 = __CFADD__((_DWORD)v12, v72);
v74 = v12 + v72;
v75 = v71 + v7 + v73;
v7 = v74 < HIDWORD(v31);
v76 = v74 - HIDWORD(v31);
v77 = v75 - v7;
v7 = v76 < HIDWORD(v12);
v78 = v76 - HIDWORD(v12);
v79 = v7;
v7 = v78 < HIDWORD(v12);
v80 = v78 - HIDWORD(v12);
v81 = v77 - (v7 + v79);
v82 = HIDWORD(v57);
if ( v81 < 0 )
{
v84 = -((unsigned int)v82 < -v81);
v83 = v82 + v81;
}
else
{
v83 = v82 + v81;
LOBYTE(v84) = __CFADD__((_DWORD)v82, v81);
}
v7 = __CFADD__((_DWORD)v12, v83);
v85 = v12 + v83;
v86 = v7 + v84;
v7 = __CFADD__((_DWORD)v12, v85);
v87 = v12 + v85;
v88 = v7;
v89 = HIDWORD(v65);
v7 = __CFADD__(HIDWORD(v65), v87);
v90 = HIDWORD(v65) + v87;
v91 = v86 + v7 + v88;
v7 = __CFADD__((_DWORD)v31, v90);
v92 = v31 + v90;
v93 = v7;
v7 = __CFADD__((_DWORD)v18, v92);
v94 = v18 + v92;
v95 = v91 + v7 + v93;
v7 = __CFADD__(HIDWORD(v6), v94);
v96 = HIDWORD(v6) + v94;
v97 = v7;
v7 = __CFADD__(HIDWORD(v12), v96);
v98 = HIDWORD(v12) + v96;
v99 = v95 + v7 + v97 - (v98 < (unsigned int)v65);
v3[2] = v80 | ((unsigned long long)(v98 - (unsigned int)v65) << 32);
v100 = v3[3];
v101 = v99;
if ( v99 < 0 )
{
v103 = -((unsigned int)v100 < -v99);
v102 = v100 + v101;
}
else
{
v102 = v100 + v99;
LOBYTE(v103) = __CFADD__((_DWORD)v100, v99);
}
v7 = __CFADD__(HIDWORD(v12), v102);
v104 = HIDWORD(v12) + v102;
v105 = v7;
v7 = __CFADD__(HIDWORD(v12), v104);
v106 = HIDWORD(v12) + v104;
v107 = v103 + v7 + v105;
v108 = v3[9];
v7 = __CFADD__((_DWORD)v108, v106);
v109 = v108 + v106;
v110 = v7;
v7 = __CFADD__(HIDWORD(v31), v109);
v111 = HIDWORD(v31) + v109;
v112 = v107 + v7 + v110;
v7 = __CFADD__((_DWORD)v31, v111);
v113 = v31 + v111;
v114 = v7;
v7 = __CFADD__((_DWORD)v12, v113);
v115 = v12 + v113;
v116 = v112 + v7 + v114;
v7 = v115 < HIDWORD(v65);
v117 = v115 - HIDWORD(v65);
v118 = v116 - v7;
v119 = HIDWORD(v100);
if ( v118 < 0 )
{
v121 = -((unsigned int)v119 < -v118);
v120 = v119 + v118;
}
else
{
v120 = v119 + v118;
LOBYTE(v121) = __CFADD__((_DWORD)v119, v118);
}
v122 = HIDWORD(v108);
v7 = __CFADD__(HIDWORD(v108), v120);
v123 = HIDWORD(v108) + v120;
v124 = v7;
v7 = __CFADD__((_DWORD)v65, v123);
v125 = v65 + v123;
v126 = v121 + v7 + v124;
v7 = __CFADD__((_DWORD)v44, v125);
v127 = v44 + v125;
v128 = v7;
v7 = __CFADD__(HIDWORD(v12), v127);
v129 = HIDWORD(v12) + v127;
v130 = v126 + v7 + v128 - (v129 < (unsigned int)v108);
v3[3] = v117 | ((unsigned long long)(v129 - (unsigned int)v108) << 32);
v131 = v3[4];
if ( v130 < 0 )
{
v133 = -((unsigned int)v131 < -v130);
v132 = v131 + v130;
}
else
{
v132 = v131 + v130;
LOBYTE(v133) = __CFADD__((_DWORD)v131, v130);
}
v7 = __CFADD__((_DWORD)v6, v132);
v134 = v6 + v132;
v135 = v7 + v133;
v7 = __CFADD__(HIDWORD(v65), v134);
v136 = HIDWORD(v65) + v134;
v137 = v7;
v7 = __CFADD__((_DWORD)v65, v136);
v138 = v65 + v136;
v139 = v135 + v7 + v137;
v7 = v138 < HIDWORD(v108);
v140 = v138 - HIDWORD(v108);
v141 = v139 - v7;
v142 = HIDWORD(v131);
if ( v141 < 0 )
{
v144 = -((unsigned int)v142 < -v141);
v143 = v142 + v141;
}
else
{
v143 = v142 + v141;
LOBYTE(v144) = __CFADD__((_DWORD)v142, v141);
}
v7 = __CFADD__(HIDWORD(v6), v143);
v145 = HIDWORD(v6) + v143;
v146 = v7 + v144;
v7 = __CFADD__((_DWORD)v108, v145);
v147 = v108 + v145;
v148 = v7;
v7 = __CFADD__((_DWORD)v89, v147);
v149 = v89 + v147;
v150 = v146 + v7 + v148 - (v149 < (unsigned int)v6);
v3[4] = v140 | ((unsigned long long)(v149 - (unsigned int)v6) << 32);
v151 = v3[5];
if ( v150 < 0 )
{
v153 = -((unsigned int)v151 < -v150);
v152 = v151 + v150;
}
else
{
v152 = v151 + v150;
LOBYTE(v153) = __CFADD__((_DWORD)v151, v150);
}
v7 = __CFADD__((_DWORD)v12, v152);
v154 = v12 + v152;
v155 = v7 + v153;
v7 = __CFADD__(HIDWORD(v108), v154);
v156 = HIDWORD(v108) + v154;
v157 = v7;
v7 = __CFADD__((_DWORD)v108, v156);
v158 = v108 + v156;
v159 = v155 + v7 + v157;
v7 = v158 < HIDWORD(v6);
v160 = v158 - HIDWORD(v6);
v161 = v159 - v7;
v162 = HIDWORD(v151);
if ( v161 < 0 )
{
v164 = -((unsigned int)v162 < -v161);
v163 = v162 + v161;
}
else
{
v163 = v162 + v161;
LOBYTE(v164) = __CFADD__((_DWORD)v162, v161);
}
v2 = 0;
v7 = __CFADD__(HIDWORD(v12), v163);
v165 = HIDWORD(v12) + v163;
v166 = v7 + v164;
v7 = __CFADD__((_DWORD)v6, v165);
v167 = v6 + v165;
v168 = v7;
v7 = __CFADD__((_DWORD)v122, v167);
v169 = v122 + v167;
v170 = v166 + v7 + v168 - (v169 < (unsigned int)v12);
v171 = v160 | ((unsigned long long)(v169 - (unsigned int)v12) << 32);
v172 = 0;
if ( v170 > 0 )
v172 = v170;
v3[5] = v171;
v3[6] = v176 & 0xFFFFFFFF00000000LL | v172;
if ( (unsigned long long)(2LL * *(_QWORD *)(a1 + 8)) >= 0xE )
{
v173 = 12LL;
do
{
v174 = 0xFFFFFFFF00000000LL;
if ( (v173 & 1) == 0 )
v174 = 0xFFFFFFFFLL;
*(unsigned long long *)((char *)v3 + 4 * ((v173 + 1) & 0xFFFFFFFFFFFFFFFELL)) &= v174;
v7 = v173 + 2 < (unsigned long long)(2LL * *(_QWORD *)(a1 + 8));
++v173;
}
while ( v7 );
}
if ( v170 < 0 )
mbedtls_ecp_fix_negative(a1, (unsigned int)v170, 384LL);
}
return v2;
}
| ecp_mod_p384:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV ESI,0xd
CALL 0x0017df41
MOV EBP,EAX
TEST EAX,EAX
JNZ 0x001888cb
MOV dword ptr [RSP + 0xc],EBP
MOV RAX,qword ptr [RBX + 0x10]
MOV R11,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x30]
MOV R9D,R13D
ADD R9D,R11D
SETC CL
MOV RDX,qword ptr [RAX + 0x50]
MOV R8,RDX
SHR R8,0x20
ADD R9D,R8D
SETC R10B
ADD R9D,EDX
ADC R10B,CL
MOV RSI,qword ptr [RAX + 0x58]
MOV RDI,RSI
SHR RDI,0x20
SUB R9D,EDI
SBB R10B,0x0
SHR R11,0x20
MOVSX R10D,R10B
TEST R10B,R10B
JS 0x001884d2
ADD R10D,R11D
SETC BPL
JMP 0x001884e1
LAB_001884d2:
MOV ECX,R10D
NEG ECX
XOR EBP,EBP
CMP R11D,ECX
SBB EBP,EBP
ADD R10D,R11D
LAB_001884e1:
MOV R11,R13
SHR R11,0x20
ADD R10D,R11D
ADC BPL,0x0
ADD R10D,ESI
SETC CL
ADD R10D,EDI
ADC CL,BPL
SUB R10D,R13D
SETC BPL
SUB R10D,EDX
SBB CL,BPL
SHL R10,0x20
OR R10,R9
MOV qword ptr [RAX],R10
MOV R9,qword ptr [RAX + 0x8]
MOVSX R14D,CL
TEST R14B,R14B
JS 0x00188527
ADD R14D,R9D
SETC CL
JMP 0x00188537
LAB_00188527:
MOV R10D,R14D
NEG R10D
XOR ECX,ECX
CMP R9D,R10D
SBB ECX,ECX
ADD R14D,R9D
LAB_00188537:
MOV R10,qword ptr [RAX + 0x38]
ADD R14D,R10D
SETC BPL
ADD R14D,EDI
ADC BPL,CL
SUB R14D,R11D
SETC CL
SUB R14D,R8D
SBB BPL,CL
SHR R9,0x20
MOVSX R15D,BPL
TEST R15B,R15B
JS 0x0018856a
ADD R15D,R9D
SETC BPL
JMP 0x00188579
LAB_0018856a:
MOV ECX,R15D
NEG ECX
XOR EBP,EBP
CMP R9D,ECX
SBB EBP,EBP
ADD R15D,R9D
LAB_00188579:
MOV R9,R10
SHR R9,0x20
ADD R15D,R9D
SETC CL
ADD R15D,R13D
ADC CL,BPL
ADD R15D,EDX
SETC BPL
ADD R15D,R8D
ADC BPL,CL
SUB R15D,R10D
SBB BPL,0x0
SUB R15D,ESI
SETC CL
SUB R15D,EDI
SBB BPL,CL
SHL R15,0x20
OR R15,R14
MOV qword ptr [RAX + 0x8],R15
MOV R15,qword ptr [RAX + 0x10]
MOVSX R12D,BPL
TEST R12B,R12B
JS 0x001885cd
ADD R12D,R15D
SETC BPL
JMP 0x001885dc
LAB_001885cd:
MOV ECX,R12D
NEG ECX
XOR EBP,EBP
CMP R15D,ECX
SBB EBP,EBP
ADD R12D,R15D
LAB_001885dc:
ADD R12D,R8D
ADC BPL,0x0
ADD R12D,R8D
SETC CL
MOV R14,qword ptr [RAX + 0x40]
ADD R12D,R14D
ADC CL,BPL
ADD R12D,R11D
SETC BPL
MOV qword ptr [RSP + 0x10],R13
ADD R12D,R13D
ADC BPL,CL
ADD R12D,EDX
SETC CL
ADD R12D,ESI
ADC CL,BPL
SUB R12D,R9D
SBB CL,0x0
SUB R12D,EDI
SETC BPL
SUB R12D,EDI
SBB CL,BPL
SHR R15,0x20
MOVSX R13D,CL
TEST R13B,R13B
JS 0x0018863a
ADD R13D,R15D
SETC BPL
JMP 0x00188649
LAB_0018863a:
MOV ECX,R13D
NEG ECX
XOR EBP,EBP
CMP R15D,ECX
SBB EBP,EBP
ADD R13D,R15D
LAB_00188649:
ADD R13D,ESI
ADC BPL,0x0
ADD R13D,ESI
SETC CL
MOV R15,R14
SHR R15,0x20
ADD R13D,R15D
ADC CL,BPL
ADD R13D,R10D
SETC BPL
ADD R13D,R11D
ADC BPL,CL
ADD R13D,R8D
SETC CL
ADD R13D,EDI
ADC CL,BPL
SUB R13D,R14D
SBB CL,0x0
SHL R13,0x20
OR R13,R12
MOV qword ptr [RAX + 0x10],R13
MOV R13,qword ptr [RAX + 0x18]
MOVSX R12D,CL
TEST R12B,R12B
JS 0x001886a2
ADD R12D,R13D
SETC CL
JMP 0x001886b2
LAB_001886a2:
MOV R11D,R12D
NEG R11D
XOR ECX,ECX
CMP R13D,R11D
SBB ECX,ECX
ADD R12D,R13D
LAB_001886b2:
ADD R12D,EDI
SETC BPL
ADD R12D,EDI
ADC BPL,CL
MOV R11,qword ptr [RAX + 0x48]
ADD R12D,R11D
SETC CL
ADD R12D,R9D
ADC CL,BPL
ADD R12D,R10D
SETC R10B
ADD R12D,ESI
ADC R10B,CL
SUB R12D,R15D
SBB R10B,0x0
SHR R13,0x20
MOVSX EBP,R10B
TEST BPL,BPL
JS 0x001886f8
ADD EBP,R13D
SETC CL
JMP 0x00188708
LAB_001886f8:
MOV R10D,EBP
NEG R10D
XOR ECX,ECX
CMP R13D,R10D
SBB ECX,ECX
ADD EBP,R13D
LAB_00188708:
MOV R10,R11
SHR R10,0x20
ADD EBP,R10D
SETC R13B
ADD EBP,R14D
ADC R13B,CL
ADD EBP,R9D
SETC CL
ADD EBP,EDI
ADC CL,R13B
SUB EBP,R11D
SBB CL,0x0
SHL RBP,0x20
OR RBP,R12
MOV qword ptr [RAX + 0x18],RBP
MOV R12,qword ptr [RAX + 0x20]
MOVSX R9D,CL
TEST R9B,R9B
JS 0x0018874e
ADD R9D,R12D
SETC BPL
JMP 0x0018875d
LAB_0018874e:
MOV ECX,R9D
NEG ECX
XOR EBP,EBP
CMP R12D,ECX
SBB EBP,EBP
ADD R9D,R12D
LAB_0018875d:
MOV R13,qword ptr [RSP + 0x10]
ADD R9D,EDX
ADC BPL,0x0
ADD R9D,R15D
SETC CL
ADD R9D,R14D
ADC CL,BPL
SUB R9D,R10D
SBB CL,0x0
SHR R12,0x20
MOVSX R14D,CL
TEST R14B,R14B
JS 0x00188791
ADD R14D,R12D
SETC BPL
JMP 0x001887a0
LAB_00188791:
MOV ECX,R14D
NEG ECX
XOR EBP,EBP
CMP R12D,ECX
SBB EBP,EBP
ADD R14D,R12D
LAB_001887a0:
ADD R14D,R8D
ADC BPL,0x0
ADD R14D,R11D
SETC CL
ADD R14D,R15D
ADC CL,BPL
SUB R14D,EDX
SBB CL,0x0
SHL R14,0x20
OR R14,R9
MOV qword ptr [RAX + 0x20],R14
MOV R14,qword ptr [RAX + 0x28]
MOVSX R9D,CL
TEST R9B,R9B
JS 0x001887da
ADD R9D,R14D
SETC BPL
JMP 0x001887e9
LAB_001887da:
MOV ECX,R9D
NEG ECX
XOR EBP,EBP
CMP R14D,ECX
SBB EBP,EBP
ADD R9D,R14D
LAB_001887e9:
ADD R9D,ESI
ADC BPL,0x0
ADD R9D,R10D
SETC CL
ADD R9D,R11D
ADC CL,BPL
SUB R9D,R8D
SBB CL,0x0
SHR R14,0x20
MOVSX R8D,CL
TEST R8B,R8B
JS 0x00188818
ADD R8D,R14D
SETC R11B
JMP 0x00188829
LAB_00188818:
MOV ECX,R8D
NEG ECX
XOR R11D,R11D
CMP R14D,ECX
SBB R11D,R11D
ADD R8D,R14D
LAB_00188829:
MOV EBP,dword ptr [RSP + 0xc]
ADD R8D,EDI
ADC R11B,0x0
ADD R8D,EDX
SETC DL
ADD R8D,R10D
ADC DL,R11B
SUB R8D,ESI
SBB DL,0x0
MOV RSI,-0x100000000
SHL R8,0x20
OR R8,R9
MOVZX ECX,DL
XOR EDI,EDI
TEST CL,CL
CMOVG EDI,ECX
MOV qword ptr [RAX + 0x28],R8
AND R13,RSI
MOVZX ECX,DIL
OR RCX,R13
MOV qword ptr [RAX + 0x30],RCX
MOV RCX,qword ptr [RBX + 0x8]
ADD RCX,RCX
CMP RCX,0xe
JC 0x001888b7
MOV EDI,0xc
MOV ECX,0xffffffff
LAB_0018888a:
LEA R8,[RDI + 0x1]
MOV R9,R8
AND R9,-0x2
TEST DIL,0x1
MOV R10,RSI
CMOVZ R10,RCX
AND qword ptr [RAX + R9*0x4],R10
MOV R9,qword ptr [RBX + 0x8]
ADD R9,R9
ADD RDI,0x2
CMP RDI,R9
MOV RDI,R8
JC 0x0018888a
LAB_001888b7:
TEST DL,DL
JNS 0x001888cb
MOVSX ESI,DL
MOV EDX,0x180
MOV RDI,RBX
CALL 0x00188c1e
LAB_001888cb:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int ecp_mod_p384(long param_1)
{
ulong *puVar1;
int8 *puVar2;
int iVar3;
byte bVar4;
uint uVar5;
uint uVar6;
byte bVar7;
uint uVar8;
ulong uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
char cVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uint uVar18;
ulong uVar19;
uint uVar20;
uint uVar21;
uint uVar22;
uint uVar23;
uint uVar24;
uint uVar25;
uint uVar26;
uint uVar27;
uint uVar28;
iVar3 = mbedtls_mpi_grow(param_1,0xd);
if (iVar3 == 0) {
puVar2 = *(int8 **)(param_1 + 0x10);
uVar9 = puVar2[6];
uVar23 = (uint)uVar9;
uVar6 = (uint)*puVar2;
uVar11 = uVar23 + uVar6;
uVar10 = (uint)((ulong)puVar2[10] >> 0x20);
uVar12 = uVar11 + uVar10;
uVar5 = (uint)puVar2[10];
uVar13 = uVar12 + uVar5;
uVar8 = (uint)((ulong)puVar2[0xb] >> 0x20);
cVar14 = (CARRY4(uVar11,uVar10) + CARRY4(uVar23,uVar6) + CARRY4(uVar12,uVar5)) -
(uVar13 < uVar8);
uVar11 = (uint)cVar14;
uVar12 = (uint)((ulong)*puVar2 >> 0x20);
if (cVar14 < '\0') {
cVar14 = -(uVar12 < -uVar11);
}
else {
cVar14 = CARRY4(uVar11,uVar12);
}
uVar22 = (uint)(uVar9 >> 0x20);
uVar15 = uVar11 + uVar12 + uVar22;
uVar6 = (uint)puVar2[0xb];
uVar16 = uVar15 + uVar6;
uVar17 = uVar16 + uVar8;
uVar18 = uVar17 - uVar23;
cVar14 = ((CARRY4(uVar15,uVar6) + cVar14 + CARRY4(uVar11 + uVar12,uVar22) + CARRY4(uVar16,uVar8)
) - (uVar17 < uVar23)) - (uVar18 < uVar5);
*puVar2 = CONCAT44(uVar18 - uVar5,uVar13 - uVar8);
uVar12 = (uint)cVar14;
uVar11 = (uint)puVar2[1];
if (cVar14 < '\0') {
cVar14 = -(uVar11 < -uVar12);
}
else {
cVar14 = CARRY4(uVar12,uVar11);
}
uVar13 = (uint)puVar2[7];
uVar15 = uVar12 + uVar11 + uVar13;
uVar16 = uVar15 + uVar8;
uVar17 = uVar16 - uVar22;
cVar14 = ((CARRY4(uVar12 + uVar11,uVar13) + cVar14 + CARRY4(uVar15,uVar8)) - (uVar16 < uVar22))
- (uVar17 < uVar10);
uVar12 = (uint)cVar14;
uVar11 = (uint)((ulong)puVar2[1] >> 0x20);
if (cVar14 < '\0') {
cVar14 = -(uVar11 < -uVar12);
}
else {
cVar14 = CARRY4(uVar12,uVar11);
}
uVar15 = (uint)((ulong)puVar2[7] >> 0x20);
uVar16 = uVar12 + uVar11 + uVar15;
uVar18 = uVar16 + uVar23;
uVar25 = uVar18 + uVar5;
uVar26 = uVar25 + uVar10;
uVar27 = uVar26 - uVar13;
uVar28 = uVar27 - uVar6;
cVar14 = (((CARRY4(uVar18,uVar5) +
CARRY4(uVar12 + uVar11,uVar15) + cVar14 + CARRY4(uVar16,uVar23) +
CARRY4(uVar25,uVar10)) - (uVar26 < uVar13)) - (uVar27 < uVar6)) - (uVar28 < uVar8);
puVar2[1] = CONCAT44(uVar28 - uVar8,uVar17 - uVar10);
uVar11 = (uint)cVar14;
uVar12 = (uint)puVar2[2];
if (cVar14 < '\0') {
cVar14 = -(uVar12 < -uVar11);
}
else {
cVar14 = CARRY4(uVar11,uVar12);
}
uVar16 = uVar11 + uVar12 + uVar10;
uVar17 = uVar16 + uVar10;
uVar24 = (uint)puVar2[8];
uVar18 = uVar17 + uVar24;
uVar25 = uVar18 + uVar22;
uVar26 = uVar25 + uVar23;
uVar27 = uVar26 + uVar5;
uVar28 = uVar27 + uVar6;
uVar20 = uVar28 - uVar15;
uVar21 = uVar20 - uVar8;
cVar14 = (((CARRY4(uVar26,uVar5) +
CARRY4(uVar18,uVar22) +
CARRY4(uVar16,uVar10) + cVar14 + CARRY4(uVar11 + uVar12,uVar10) +
CARRY4(uVar17,uVar24) + CARRY4(uVar25,uVar23) + CARRY4(uVar27,uVar6)) -
(uVar28 < uVar15)) - (uVar20 < uVar8)) - (uVar21 < uVar8);
uVar11 = (uint)cVar14;
uVar12 = (uint)((ulong)puVar2[2] >> 0x20);
if (cVar14 < '\0') {
cVar14 = -(uVar12 < -uVar11);
}
else {
cVar14 = CARRY4(uVar11,uVar12);
}
uVar23 = uVar11 + uVar12 + uVar6;
uVar16 = uVar23 + uVar6;
uVar28 = (uint)((ulong)puVar2[8] >> 0x20);
uVar17 = uVar16 + uVar28;
uVar18 = uVar17 + uVar13;
uVar25 = uVar18 + uVar22;
uVar26 = uVar25 + uVar10;
uVar27 = uVar26 + uVar8;
cVar14 = (CARRY4(uVar25,uVar10) +
CARRY4(uVar17,uVar13) +
CARRY4(uVar23,uVar6) + cVar14 + CARRY4(uVar11 + uVar12,uVar6) + CARRY4(uVar16,uVar28)
+ CARRY4(uVar18,uVar22) + CARRY4(uVar26,uVar8)) - (uVar27 < uVar24);
puVar2[2] = CONCAT44(uVar27 - uVar24,uVar21 - uVar8);
uVar11 = (uint)cVar14;
uVar12 = (uint)puVar2[3];
if (cVar14 < '\0') {
cVar14 = -(uVar12 < -uVar11);
}
else {
cVar14 = CARRY4(uVar11,uVar12);
}
uVar16 = uVar11 + uVar12 + uVar8;
uVar17 = uVar16 + uVar8;
uVar23 = (uint)puVar2[9];
uVar18 = uVar17 + uVar23;
uVar22 = uVar18 + uVar15;
uVar25 = uVar22 + uVar13;
uVar26 = uVar25 + uVar6;
cVar14 = (CARRY4(uVar22,uVar13) +
CARRY4(uVar17,uVar23) + CARRY4(uVar11 + uVar12,uVar8) + cVar14 + CARRY4(uVar16,uVar8)
+ CARRY4(uVar18,uVar15) + CARRY4(uVar25,uVar6)) - (uVar26 < uVar28);
uVar11 = (uint)cVar14;
uVar12 = (uint)((ulong)puVar2[3] >> 0x20);
if (cVar14 < '\0') {
cVar14 = -(uVar12 < -uVar11);
}
else {
cVar14 = CARRY4(uVar11,uVar12);
}
uVar22 = (uint)((ulong)puVar2[9] >> 0x20);
uVar13 = uVar11 + uVar12 + uVar22;
uVar16 = uVar13 + uVar24;
uVar17 = uVar16 + uVar15;
uVar18 = uVar17 + uVar8;
cVar14 = (CARRY4(uVar16,uVar15) +
CARRY4(uVar11 + uVar12,uVar22) + cVar14 + CARRY4(uVar13,uVar24) + CARRY4(uVar17,uVar8)
) - (uVar18 < uVar23);
puVar2[3] = CONCAT44(uVar18 - uVar23,uVar26 - uVar28);
uVar11 = (uint)cVar14;
uVar12 = (uint)puVar2[4];
if (cVar14 < '\0') {
cVar14 = -(uVar12 < -uVar11);
}
else {
cVar14 = CARRY4(uVar11,uVar12);
}
uVar13 = uVar11 + uVar12 + uVar5;
uVar15 = uVar13 + uVar28;
uVar16 = uVar15 + uVar24;
cVar14 = (CARRY4(uVar13,uVar28) + cVar14 + CARRY4(uVar11 + uVar12,uVar5) + CARRY4(uVar15,uVar24)
) - (uVar16 < uVar22);
uVar12 = (uint)cVar14;
uVar11 = (uint)((ulong)puVar2[4] >> 0x20);
if (cVar14 < '\0') {
cVar14 = -(uVar11 < -uVar12);
}
else {
cVar14 = CARRY4(uVar12,uVar11);
}
uVar13 = uVar12 + uVar11 + uVar10;
uVar15 = uVar13 + uVar23;
uVar17 = uVar15 + uVar28;
cVar14 = (CARRY4(uVar13,uVar23) + cVar14 + CARRY4(uVar12 + uVar11,uVar10) +
CARRY4(uVar15,uVar28)) - (uVar17 < uVar5);
puVar2[4] = CONCAT44(uVar17 - uVar5,uVar16 - uVar22);
uVar11 = (uint)cVar14;
uVar12 = (uint)puVar2[5];
if (cVar14 < '\0') {
cVar14 = -(uVar12 < -uVar11);
}
else {
cVar14 = CARRY4(uVar11,uVar12);
}
uVar13 = uVar11 + uVar12 + uVar6;
uVar15 = uVar13 + uVar22;
uVar16 = uVar15 + uVar23;
cVar14 = (CARRY4(uVar13,uVar22) + cVar14 + CARRY4(uVar11 + uVar12,uVar6) + CARRY4(uVar15,uVar23)
) - (uVar16 < uVar10);
uVar11 = (uint)cVar14;
uVar12 = (uint)((ulong)puVar2[5] >> 0x20);
if (cVar14 < '\0') {
cVar14 = -(uVar12 < -uVar11);
}
else {
cVar14 = CARRY4(uVar11,uVar12);
}
uVar13 = uVar11 + uVar12 + uVar8;
uVar23 = uVar13 + uVar5;
uVar15 = uVar23 + uVar22;
bVar4 = (CARRY4(uVar13,uVar5) + cVar14 + CARRY4(uVar11 + uVar12,uVar8) + CARRY4(uVar23,uVar22))
- (uVar15 < uVar6);
bVar7 = 0;
if ('\0' < (char)bVar4) {
bVar7 = bVar4;
}
puVar2[5] = CONCAT44(uVar15 - uVar6,uVar16 - uVar10);
puVar2[6] = (ulong)bVar7 | uVar9 & 0xffffffff00000000;
if (0xd < (ulong)(*(long *)(param_1 + 8) * 2)) {
uVar9 = 0xc;
do {
uVar19 = 0xffffffff00000000;
if ((uVar9 & 1) == 0) {
uVar19 = 0xffffffff;
}
puVar1 = (ulong *)((long)puVar2 + (uVar9 + 1 & 0xfffffffffffffffe) * 4);
*puVar1 = *puVar1 & uVar19;
uVar19 = uVar9 + 2;
uVar9 = uVar9 + 1;
} while (uVar19 < (ulong)(*(long *)(param_1 + 8) * 2));
}
if ((char)bVar4 < '\0') {
mbedtls_ecp_fix_negative(param_1,(int)(char)bVar4,0x180);
}
}
return iVar3;
}
|
|
6,428 | xml_parser_peek | eloqsql/storage/maria/libmarias3/src/xml.c | static uint8_t xml_parser_peek(struct xml_parser* parser, size_t n) {
size_t position = parser->position;
while (position < parser->length) {
if (!isspace(parser->buffer[position])) {
if (n == 0) {
return parser->buffer[position];
} else {
--n;
}
}
position++;
}
return 0;
} | O0 | c | xml_parser_peek:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x32e48
callq 0x27150
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
jne 0x32e3a
cmpq $0x0, -0x18(%rbp)
jne 0x32e2c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x32e4c
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x32e3a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x32ddc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| xml_parser_peek:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_20], rax
loc_32DDC:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
jnb short loc_32E48
call ___ctype_b_loc
mov rax, [rax]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov rdx, [rbp+var_20]
movzx ecx, byte ptr [rcx+rdx]
movsxd rcx, ecx
movzx eax, word ptr [rax+rcx*2]
and eax, 2000h
cmp eax, 0
jnz short loc_32E3A
cmp [rbp+var_18], 0
jnz short loc_32E2C
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_20]
mov al, [rax+rcx]
mov [rbp+var_1], al
jmp short loc_32E4C
loc_32E2C:
mov rax, [rbp+var_18]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_18], rax
jmp short $+2
loc_32E3A:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_32DDC
loc_32E48:
mov [rbp+var_1], 0
loc_32E4C:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char xml_parser_peek(_QWORD *a1, long long a2)
{
unsigned long long i; // [rsp+0h] [rbp-20h]
for ( i = a1[1]; i < a1[2]; ++i )
{
if ( (*(_WORD *)(*(_QWORD *)__ctype_b_loc() + 2LL * *(unsigned __int8 *)(*a1 + i)) & 0x2000) == 0 )
{
if ( !a2 )
return *(_BYTE *)(*a1 + i);
--a2;
}
}
return 0;
}
| xml_parser_peek:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_00132ddc:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x00132e48
CALL 0x00127150
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV RDX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
MOVSXD RCX,ECX
MOVZX EAX,word ptr [RAX + RCX*0x2]
AND EAX,0x2000
CMP EAX,0x0
JNZ 0x00132e3a
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x00132e2c
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x1],AL
JMP 0x00132e4c
LAB_00132e2c:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00132e3a
LAB_00132e3a:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00132ddc
LAB_00132e48:
MOV byte ptr [RBP + -0x1],0x0
LAB_00132e4c:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int8 xml_parser_peek(long *param_1,long param_2)
{
ushort **ppuVar1;
ulong local_28;
long local_20;
int1 local_9;
local_28 = param_1[1];
local_20 = param_2;
do {
if ((ulong)param_1[2] <= local_28) {
local_9 = 0;
LAB_00132e4c:
return CONCAT71((int7)(local_28 >> 8),local_9);
}
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[(int)(uint)*(byte *)(*param_1 + local_28)] & 0x2000) == 0) {
if (local_20 == 0) {
local_9 = *(int1 *)(*param_1 + local_28);
local_28 = CONCAT71((int7)((ulong)*param_1 >> 8),local_9);
goto LAB_00132e4c;
}
local_20 = local_20 + -1;
}
local_28 = local_28 + 1;
} while( true );
}
|
|
6,429 | fmt::v11::detail::parse_dynamic_spec_result<char> fmt::v11::detail::parse_dynamic_spec<char>(char const*, char const*, int&, fmt::v11::detail::arg_ref<char>&, fmt::v11::parse_context<char>&) | zkingston[P]unknot/build_O1/_deps/fmt-src/include/fmt/base.h | FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end,
int& value, arg_ref<Char>& ref,
parse_context<Char>& ctx)
-> parse_dynamic_spec_result<Char> {
FMT_ASSERT(begin != end, "");
auto kind = arg_id_kind::none;
if ('0' <= *begin && *begin <= '9') {
int val = parse_nonnegative_int(begin, end, -1);
if (val == -1) report_error("number is too big");
value = val;
} else {
if (*begin == '{') {
++begin;
if (begin != end) {
Char c = *begin;
if (c == '}' || c == ':') {
int id = ctx.next_arg_id();
ref = id;
kind = arg_id_kind::index;
ctx.check_dynamic_spec(id);
} else {
begin = parse_arg_id(begin, end,
dynamic_spec_handler<Char>{ctx, ref, kind});
}
}
if (begin != end && *begin == '}') return {++begin, kind};
}
report_error("invalid format string");
}
return {begin, kind};
} | O1 | c | fmt::v11::detail::parse_dynamic_spec_result<char> fmt::v11::detail::parse_dynamic_spec<char>(char const*, char const*, int&, fmt::v11::detail::arg_ref<char>&, fmt::v11::parse_context<char>&):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movb (%rdi), %al
leal -0x30(%rax), %edx
cmpb $0x9, %dl
ja 0x46d66
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x4673b
cmpl $-0x1, %eax
je 0x46df0
movl %eax, (%r14)
movq 0x8(%rsp), %rax
jmp 0x46dd8
cmpb $0x7b, %al
jne 0x46de4
incq %rdi
movq %rdi, 0x8(%rsp)
cmpq %rbx, %rdi
je 0x46dc1
movzbl (%rdi), %eax
cmpl $0x7d, %eax
je 0x46d84
cmpl $0x3a, %eax
jne 0x46d9f
movl 0x10(%r8), %eax
testl %eax, %eax
js 0x46dfc
leal 0x1(%rax), %edx
movl %edx, 0x10(%r8)
movl %eax, (%rcx)
movl $0x1, 0x4(%rsp)
jmp 0x46dc1
leaq 0x10(%rsp), %rdx
movq %r8, (%rdx)
movq %rcx, 0x8(%rdx)
leaq 0x4(%rsp), %rax
movq %rax, 0x10(%rdx)
movq %rbx, %rsi
callq 0x46e08
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq %rbx, %rax
je 0x46de4
cmpb $0x7d, (%rax)
jne 0x46de4
incq %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %edx
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x24cb98(%rip), %rdi # 0x293983
callq 0x3d5e8
leaq 0x24cb48(%rip), %rdi # 0x29393f
callq 0x3d5e8
leaq 0x24cbcc(%rip), %rdi # 0x2939cf
callq 0x3d5e8
| _ZN3fmt3v116detail18parse_dynamic_specIcEENS1_25parse_dynamic_spec_resultIT_EEPKS4_S7_RiRNS1_7arg_refIS4_EERNS0_13parse_contextIS4_EE:
push r14
push rbx
sub rsp, 28h
mov r14, rdx
mov rbx, rsi
mov [rsp+38h+var_30], rdi
mov [rsp+38h+var_34], 0
mov al, [rdi]
lea edx, [rax-30h]
cmp dl, 9
ja short loc_46D66
lea rdi, [rsp+38h+var_30]
mov rsi, rbx; char *
mov edx, 0FFFFFFFFh
call _ZN3fmt3v116detail21parse_nonnegative_intIcEEiRPKT_S5_i; fmt::v11::detail::parse_nonnegative_int<char>(char const*&,char const*,int)
cmp eax, 0FFFFFFFFh
jz loc_46DF0
mov [r14], eax
mov rax, [rsp+38h+var_30]
jmp short loc_46DD8
loc_46D66:
cmp al, 7Bh ; '{'
jnz short loc_46DE4
inc rdi
mov [rsp+38h+var_30], rdi
cmp rdi, rbx
jz short loc_46DC1
movzx eax, byte ptr [rdi]
cmp eax, 7Dh ; '}'
jz short loc_46D84
cmp eax, 3Ah ; ':'
jnz short loc_46D9F
loc_46D84:
mov eax, [r8+10h]
test eax, eax
js short loc_46DFC
lea edx, [rax+1]
mov [r8+10h], edx
mov [rcx], eax
mov [rsp+38h+var_34], 1
jmp short loc_46DC1
loc_46D9F:
lea rdx, [rsp+38h+var_28]
mov [rdx], r8
mov [rdx+8], rcx
lea rax, [rsp+38h+var_34]
mov [rdx+10h], rax
mov rsi, rbx; char *
call _ZN3fmt3v116detail12parse_arg_idIcNS1_20dynamic_spec_handlerIcEEEEPKT_S7_S7_OT0_; fmt::v11::detail::parse_arg_id<char,fmt::v11::detail::dynamic_spec_handler<char>>(char const*,char const*,fmt::v11::detail::dynamic_spec_handler<char> &&)
mov [rsp+38h+var_30], rax
loc_46DC1:
mov rax, [rsp+38h+var_30]
cmp rax, rbx
jz short loc_46DE4
cmp byte ptr [rax], 7Dh ; '}'
jnz short loc_46DE4
inc rax
mov [rsp+38h+var_30], rax
loc_46DD8:
mov edx, [rsp+38h+var_34]
add rsp, 28h
pop rbx
pop r14
retn
loc_46DE4:
lea rdi, aInvalidFormatS; "invalid format string"
call _ZN3fmt3v1112report_errorEPKc; fmt::v11::report_error(char const*)
loc_46DF0:
lea rdi, aNumberIsTooBig; "number is too big"
call _ZN3fmt3v1112report_errorEPKc; fmt::v11::report_error(char const*)
loc_46DFC:
lea rdi, aCannotSwitchFr; "cannot switch from manual to automatic "...
call _ZN3fmt3v1112report_errorEPKc; fmt::v11::report_error(char const*)
| char * fmt::v11::detail::parse_dynamic_spec<char>(char *a1, char *a2, _DWORD *a3, char *a4, long long a5)
{
int v6; // eax
char *v8; // rdi
int v9; // eax
int v10; // eax
int v11; // [rsp+4h] [rbp-34h] BYREF
char *v12[6]; // [rsp+8h] [rbp-30h] BYREF
v12[0] = a1;
v11 = 0;
if ( (unsigned __int8)(*a1 - 48) > 9u )
{
if ( *a1 != 123 )
goto LABEL_15;
v8 = a1 + 1;
v12[0] = v8;
if ( v8 != a2 )
{
v9 = (unsigned __int8)*v8;
if ( v9 == 125 || v9 == 58 )
{
v10 = *(_DWORD *)(a5 + 16);
if ( v10 < 0 )
fmt::v11::report_error((fmt::v11 *)"cannot switch from manual to automatic argument indexing", a2);
*(_DWORD *)(a5 + 16) = v10 + 1;
*(_DWORD *)a4 = v10;
v11 = 1;
}
else
{
v12[1] = (char *)a5;
v12[2] = a4;
v12[3] = (char *)&v11;
v12[0] = (char *)fmt::v11::detail::parse_arg_id<char,fmt::v11::detail::dynamic_spec_handler<char>>(v8, a2);
}
}
if ( v12[0] == a2 || *v12[0] != 125 )
LABEL_15:
fmt::v11::report_error((fmt::v11 *)"invalid format string", a2);
return ++v12[0];
}
else
{
v6 = fmt::v11::detail::parse_nonnegative_int<char>(v12, a2, 0xFFFFFFFF);
if ( v6 == -1 )
fmt::v11::report_error((fmt::v11 *)"number is too big", a2);
*a3 = v6;
return v12[0];
}
}
| parse_dynamic_spec<char>:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV RBX,RSI
MOV qword ptr [RSP + 0x8],RDI
MOV dword ptr [RSP + 0x4],0x0
MOV AL,byte ptr [RDI]
LEA EDX,[RAX + -0x30]
CMP DL,0x9
JA 0x00146d66
LEA RDI,[RSP + 0x8]
MOV RSI,RBX
MOV EDX,0xffffffff
CALL 0x0014673b
CMP EAX,-0x1
JZ 0x00146df0
MOV dword ptr [R14],EAX
MOV RAX,qword ptr [RSP + 0x8]
JMP 0x00146dd8
LAB_00146d66:
CMP AL,0x7b
JNZ 0x00146de4
INC RDI
MOV qword ptr [RSP + 0x8],RDI
CMP RDI,RBX
JZ 0x00146dc1
MOVZX EAX,byte ptr [RDI]
CMP EAX,0x7d
JZ 0x00146d84
CMP EAX,0x3a
JNZ 0x00146d9f
LAB_00146d84:
MOV EAX,dword ptr [R8 + 0x10]
TEST EAX,EAX
JS 0x00146dfc
LEA EDX,[RAX + 0x1]
MOV dword ptr [R8 + 0x10],EDX
MOV dword ptr [RCX],EAX
MOV dword ptr [RSP + 0x4],0x1
JMP 0x00146dc1
LAB_00146d9f:
LEA RDX,[RSP + 0x10]
MOV qword ptr [RDX],R8
MOV qword ptr [RDX + 0x8],RCX
LEA RAX,[RSP + 0x4]
MOV qword ptr [RDX + 0x10],RAX
MOV RSI,RBX
CALL 0x00146e08
MOV qword ptr [RSP + 0x8],RAX
LAB_00146dc1:
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,RBX
JZ 0x00146de4
CMP byte ptr [RAX],0x7d
JNZ 0x00146de4
INC RAX
MOV qword ptr [RSP + 0x8],RAX
LAB_00146dd8:
MOV EDX,dword ptr [RSP + 0x4]
ADD RSP,0x28
POP RBX
POP R14
RET
LAB_00146de4:
LEA RDI,[0x393983]
CALL 0x0013d5e8
LAB_00146df0:
LEA RDI,[0x39393f]
CALL 0x0013d5e8
LAB_00146dfc:
LEA RDI,[0x3939cf]
CALL 0x0013d5e8
|
/* fmt::v11::detail::parse_dynamic_spec_result<char> fmt::v11::detail::parse_dynamic_spec<char>(char
const*, char const*, int&, fmt::v11::detail::arg_ref<char>&, fmt::v11::parse_context<char>&) */
int1 [16]
fmt::v11::detail::parse_dynamic_spec<char>
(char *param_1,char *param_2,int *param_3,arg_ref *param_4,parse_context *param_5)
{
int iVar1;
int1 auVar2 [16];
int4 local_34;
char *local_30;
parse_context *local_28;
arg_ref *local_20;
int4 *local_18;
local_34 = 0;
local_30 = param_1;
if ((byte)(*param_1 - 0x30U) < 10) {
iVar1 = parse_nonnegative_int<char>(&local_30,param_2,-1);
if (iVar1 == -1) {
/* WARNING: Subroutine does not return */
report_error("number is too big");
}
*param_3 = iVar1;
LAB_00146dd8:
auVar2._8_4_ = local_34;
auVar2._0_8_ = local_30;
auVar2._12_4_ = 0;
return auVar2;
}
if (*param_1 == '{') {
local_30 = param_1 + 1;
if (local_30 != param_2) {
if ((*local_30 == '}') || (*local_30 == ':')) {
iVar1 = *(int *)(param_5 + 0x10);
if (iVar1 < 0) {
/* WARNING: Subroutine does not return */
report_error("cannot switch from manual to automatic argument indexing");
}
*(int *)(param_5 + 0x10) = iVar1 + 1;
*(int *)param_4 = iVar1;
local_34 = 1;
}
else {
local_18 = &local_34;
local_28 = param_5;
local_20 = param_4;
local_30 = parse_arg_id<char,fmt::v11::detail::dynamic_spec_handler<char>>
(local_30,param_2,(dynamic_spec_handler *)&local_28);
}
}
if ((local_30 != param_2) && (*local_30 == '}')) {
local_30 = local_30 + 1;
goto LAB_00146dd8;
}
}
/* WARNING: Subroutine does not return */
report_error("invalid format string");
}
|
|
6,430 | bool minja::Value::get<bool>() const | llama.cpp/common/minja/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O3 | cpp | bool minja::Value::get<bool>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0xc2421
cmpq $0x0, 0x20(%r14)
jne 0xc2421
cmpq $0x0, 0x30(%r14)
jne 0xc2421
addq $0x40, %r14
leaq 0x20(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc24ef
movq (%rbx), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20620
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xb669c
leaq 0x5d733(%rip), %rsi # 0x11fb7a
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xb0110
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x20450
xorl %ebp, %ebp
movq 0x9fb53(%rip), %rsi # 0x161fc0
movq 0x9fb0c(%rip), %rdx # 0x161f80
movq %rbx, %rdi
callq 0x20a30
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc249a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20170
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc24b5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20170
testb %bpl, %bpl
jne 0xc24df
jmp 0xc24e7
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc24df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20170
jmp 0xc24df
movq %rax, %r14
movq %rbx, %rdi
callq 0x20eb0
movq %r14, %rdi
callq 0x20ad0
| _ZNK5minja5Value3getIlEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rdi+10h], 0
jnz short loc_C2421
cmp qword ptr [r14+20h], 0
jnz short loc_C2421
cmp qword ptr [r14+30h], 0
jnz short loc_C2421
add r14, 40h ; '@'
lea rbx, [rsp+58h+var_38]
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_
mov rax, [rbx]
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_C2421:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C249A
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C249A:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C24B5
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C24B5:
test bpl, bpl
jnz short loc_C24DF
jmp short loc_C24E7
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C24DF
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_C24DF
mov r14, rax
loc_C24DF:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C24E7:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<long>(_QWORD *a1)
{
void *exception; // rbx
_BYTE v3[16]; // [rsp+0h] [rbp-58h] BYREF
_QWORD v4[2]; // [rsp+20h] [rbp-38h] BYREF
if ( a1[2] || a1[4] || a1[6] )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v3, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>(v4, (long long)"get<T> not defined for this value type: ", (long long)v3);
std::runtime_error::runtime_error(exception, v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4[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 + 8,
v4);
return v4[0];
}
| get<long>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RDI + 0x10],0x0
JNZ 0x001c2421
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x001c2421
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x001c2421
ADD R14,0x40
LEA RBX,[RSP + 0x20]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x001c24ef
MOV RAX,qword ptr [RBX]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001c2421:
MOV EDI,0x10
CALL 0x00120620
MOV RBX,RAX
LAB_001c242e:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001b669c
LAB_001c2440:
LEA RSI,[0x21fb7a]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001b0110
MOV BPL,0x1
LAB_001c2457:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00120450
XOR EBP,EBP
MOV RSI,qword ptr [0x00261fc0]
MOV RDX,qword ptr [0x00261f80]
MOV RDI,RBX
CALL 0x00120a30
|
/* long minja::Value::get<long>() const */
long __thiscall minja::Value::get<long>(Value *this)
{
runtime_error *this_00;
int1 auStack_58 [32];
long local_38 [4];
if (((*(long *)(this + 0x10) == 0) && (*(long *)(this + 0x20) == 0)) &&
(*(long *)(this + 0x30) == 0)) {
local_38[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_
(this + 0x40,local_38);
return local_38[0];
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001c242e to 001c243f has its CatchHandler @ 001c24dc */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 001c2440 to 001c2453 has its CatchHandler @ 001c24bc */
std::operator+((char *)local_38,(string *)"get<T> not defined for this value type: ");
/* try { // try from 001c2457 to 001c247b has its CatchHandler @ 001c247c */
std::runtime_error::runtime_error(this_00,(string *)local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00261fc0,PTR__runtime_error_00261f80);
}
|
|
6,431 | ftxui::(anonymous namespace)::TileEncoding::operator<(ftxui::(anonymous namespace)::TileEncoding const&) const | Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/screen/screen.cpp | bool operator<(const TileEncoding& other) const {
if (left < other.left) { return true; }
if (left > other.left) { return false; }
if (top < other.top) { return true; }
if (top > other.top) { return false; }
if (right < other.right) { return true; }
if (right > other.right) { return false; }
if (down < other.down) { return true; }
if (down > other.down) { return false; }
if (round < other.round) { return true; }
if (round > other.round) { return false; }
return false;
} | O0 | cpp | ftxui::(anonymous namespace)::TileEncoding::operator<(ftxui::(anonymous namespace)::TileEncoding const&) const:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movw (%rax), %ax
andw $0x3, %ax
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
andw $0x3, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x8a6a9
movb $0x1, -0x1(%rbp)
jmp 0x8a855
movq -0x20(%rbp), %rax
movw (%rax), %ax
andw $0x3, %ax
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
andw $0x3, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
jle 0x8a6d2
movb $0x0, -0x1(%rbp)
jmp 0x8a855
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x2, %ax
andw $0x3, %ax
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
shrw $0x2, %cx
andw $0x3, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x8a703
movb $0x1, -0x1(%rbp)
jmp 0x8a855
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x2, %ax
andw $0x3, %ax
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
shrw $0x2, %cx
andw $0x3, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
jle 0x8a734
movb $0x0, -0x1(%rbp)
jmp 0x8a855
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x4, %ax
andw $0x3, %ax
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
shrw $0x4, %cx
andw $0x3, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x8a765
movb $0x1, -0x1(%rbp)
jmp 0x8a855
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x4, %ax
andw $0x3, %ax
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
shrw $0x4, %cx
andw $0x3, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
jle 0x8a796
movb $0x0, -0x1(%rbp)
jmp 0x8a855
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x6, %ax
andw $0x3, %ax
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
shrw $0x6, %cx
andw $0x3, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x8a7c7
movb $0x1, -0x1(%rbp)
jmp 0x8a855
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x6, %ax
andw $0x3, %ax
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
shrw $0x6, %cx
andw $0x3, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
jle 0x8a7f5
movb $0x0, -0x1(%rbp)
jmp 0x8a855
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
shrw $0x8, %cx
andw $0x1, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x8a823
movb $0x1, -0x1(%rbp)
jmp 0x8a855
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
shrw $0x8, %cx
andw $0x1, %cx
movzbl %cl, %ecx
cmpl %ecx, %eax
jle 0x8a851
movb $0x0, -0x1(%rbp)
jmp 0x8a855
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
| _ZNK5ftxui12_GLOBAL__N_112TileEncodingltERKS1_:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov ax, [rax]
and ax, 3
movzx eax, al
mov rcx, [rbp+var_18]
mov cx, [rcx]
and cx, 3
movzx ecx, cl
cmp eax, ecx
jge short loc_8A6A9
mov [rbp+var_1], 1
jmp loc_8A855
loc_8A6A9:
mov rax, [rbp+var_20]
mov ax, [rax]
and ax, 3
movzx eax, al
mov rcx, [rbp+var_18]
mov cx, [rcx]
and cx, 3
movzx ecx, cl
cmp eax, ecx
jle short loc_8A6D2
mov [rbp+var_1], 0
jmp loc_8A855
loc_8A6D2:
mov rax, [rbp+var_20]
mov ax, [rax]
shr ax, 2
and ax, 3
movzx eax, al
mov rcx, [rbp+var_18]
mov cx, [rcx]
shr cx, 2
and cx, 3
movzx ecx, cl
cmp eax, ecx
jge short loc_8A703
mov [rbp+var_1], 1
jmp loc_8A855
loc_8A703:
mov rax, [rbp+var_20]
mov ax, [rax]
shr ax, 2
and ax, 3
movzx eax, al
mov rcx, [rbp+var_18]
mov cx, [rcx]
shr cx, 2
and cx, 3
movzx ecx, cl
cmp eax, ecx
jle short loc_8A734
mov [rbp+var_1], 0
jmp loc_8A855
loc_8A734:
mov rax, [rbp+var_20]
mov ax, [rax]
shr ax, 4
and ax, 3
movzx eax, al
mov rcx, [rbp+var_18]
mov cx, [rcx]
shr cx, 4
and cx, 3
movzx ecx, cl
cmp eax, ecx
jge short loc_8A765
mov [rbp+var_1], 1
jmp loc_8A855
loc_8A765:
mov rax, [rbp+var_20]
mov ax, [rax]
shr ax, 4
and ax, 3
movzx eax, al
mov rcx, [rbp+var_18]
mov cx, [rcx]
shr cx, 4
and cx, 3
movzx ecx, cl
cmp eax, ecx
jle short loc_8A796
mov [rbp+var_1], 0
jmp loc_8A855
loc_8A796:
mov rax, [rbp+var_20]
mov ax, [rax]
shr ax, 6
and ax, 3
movzx eax, al
mov rcx, [rbp+var_18]
mov cx, [rcx]
shr cx, 6
and cx, 3
movzx ecx, cl
cmp eax, ecx
jge short loc_8A7C7
mov [rbp+var_1], 1
jmp loc_8A855
loc_8A7C7:
mov rax, [rbp+var_20]
mov ax, [rax]
shr ax, 6
and ax, 3
movzx eax, al
mov rcx, [rbp+var_18]
mov cx, [rcx]
shr cx, 6
and cx, 3
movzx ecx, cl
cmp eax, ecx
jle short loc_8A7F5
mov [rbp+var_1], 0
jmp short loc_8A855
loc_8A7F5:
mov rax, [rbp+var_20]
mov ax, [rax]
shr ax, 8
and ax, 1
movzx eax, al
mov rcx, [rbp+var_18]
mov cx, [rcx]
shr cx, 8
and cx, 1
movzx ecx, cl
cmp eax, ecx
jge short loc_8A823
mov [rbp+var_1], 1
jmp short loc_8A855
loc_8A823:
mov rax, [rbp+var_20]
mov ax, [rax]
shr ax, 8
and ax, 1
movzx eax, al
mov rcx, [rbp+var_18]
mov cx, [rcx]
shr cx, 8
and cx, 1
movzx ecx, cl
cmp eax, ecx
jle short loc_8A851
mov [rbp+var_1], 0
jmp short loc_8A855
loc_8A851:
mov [rbp+var_1], 0
loc_8A855:
mov al, [rbp+var_1]
and al, 1
pop rbp
retn
| bool ftxui::`anonymous namespace'::TileEncoding::operator<(_WORD *a1, _WORD *a2)
{
if ( (*a1 & 3) < (*a2 & 3) )
return 1;
if ( (*a1 & 3) > (*a2 & 3) )
return 0;
if ( ((*a1 >> 2) & 3) < ((*a2 >> 2) & 3) )
return 1;
if ( ((*a1 >> 2) & 3) > ((*a2 >> 2) & 3) )
return 0;
if ( ((*a1 >> 4) & 3) < ((*a2 >> 4) & 3) )
return 1;
if ( ((*a1 >> 4) & 3) > ((*a2 >> 4) & 3) )
return 0;
if ( ((*a1 >> 6) & 3) >= ((*a2 >> 6) & 3) )
return ((*a1 >> 6) & 3) <= ((*a2 >> 6) & 3) && (HIBYTE(*a1) & 1) < (HIBYTE(*a2) & 1);
return 1;
}
| operator<:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV AX,word ptr [RAX]
AND AX,0x3
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RCX]
AND CX,0x3
MOVZX ECX,CL
CMP EAX,ECX
JGE 0x0018a6a9
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018a855
LAB_0018a6a9:
MOV RAX,qword ptr [RBP + -0x20]
MOV AX,word ptr [RAX]
AND AX,0x3
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RCX]
AND CX,0x3
MOVZX ECX,CL
CMP EAX,ECX
JLE 0x0018a6d2
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0018a855
LAB_0018a6d2:
MOV RAX,qword ptr [RBP + -0x20]
MOV AX,word ptr [RAX]
SHR AX,0x2
AND AX,0x3
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RCX]
SHR CX,0x2
AND CX,0x3
MOVZX ECX,CL
CMP EAX,ECX
JGE 0x0018a703
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018a855
LAB_0018a703:
MOV RAX,qword ptr [RBP + -0x20]
MOV AX,word ptr [RAX]
SHR AX,0x2
AND AX,0x3
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RCX]
SHR CX,0x2
AND CX,0x3
MOVZX ECX,CL
CMP EAX,ECX
JLE 0x0018a734
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0018a855
LAB_0018a734:
MOV RAX,qword ptr [RBP + -0x20]
MOV AX,word ptr [RAX]
SHR AX,0x4
AND AX,0x3
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RCX]
SHR CX,0x4
AND CX,0x3
MOVZX ECX,CL
CMP EAX,ECX
JGE 0x0018a765
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018a855
LAB_0018a765:
MOV RAX,qword ptr [RBP + -0x20]
MOV AX,word ptr [RAX]
SHR AX,0x4
AND AX,0x3
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RCX]
SHR CX,0x4
AND CX,0x3
MOVZX ECX,CL
CMP EAX,ECX
JLE 0x0018a796
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0018a855
LAB_0018a796:
MOV RAX,qword ptr [RBP + -0x20]
MOV AX,word ptr [RAX]
SHR AX,0x6
AND AX,0x3
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RCX]
SHR CX,0x6
AND CX,0x3
MOVZX ECX,CL
CMP EAX,ECX
JGE 0x0018a7c7
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018a855
LAB_0018a7c7:
MOV RAX,qword ptr [RBP + -0x20]
MOV AX,word ptr [RAX]
SHR AX,0x6
AND AX,0x3
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RCX]
SHR CX,0x6
AND CX,0x3
MOVZX ECX,CL
CMP EAX,ECX
JLE 0x0018a7f5
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0018a855
LAB_0018a7f5:
MOV RAX,qword ptr [RBP + -0x20]
MOV AX,word ptr [RAX]
SHR AX,0x8
AND AX,0x1
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RCX]
SHR CX,0x8
AND CX,0x1
MOVZX ECX,CL
CMP EAX,ECX
JGE 0x0018a823
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018a855
LAB_0018a823:
MOV RAX,qword ptr [RBP + -0x20]
MOV AX,word ptr [RAX]
SHR AX,0x8
AND AX,0x1
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x18]
MOV CX,word ptr [RCX]
SHR CX,0x8
AND CX,0x1
MOVZX ECX,CL
CMP EAX,ECX
JLE 0x0018a851
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0018a855
LAB_0018a851:
MOV byte ptr [RBP + -0x1],0x0
LAB_0018a855:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
POP RBP
RET
|
/* ftxui::(anonymous namespace)::TileEncoding::TEMPNAMEPLACEHOLDERVALUE(ftxui::(anonymous
namespace)::TileEncoding const&) const */
int1 __thiscall
ftxui::(anonymous_namespace)::TileEncoding::operator<(TileEncoding *this,TileEncoding *param_1)
{
int1 local_9;
if (((byte)*(int2 *)this & 3) < ((byte)*(int2 *)param_1 & 3)) {
local_9 = 1;
}
else if (((byte)*(int2 *)param_1 & 3) < ((byte)*(int2 *)this & 3)) {
local_9 = 0;
}
else if (((byte)(*(ushort *)this >> 2) & 3) < ((byte)(*(ushort *)param_1 >> 2) & 3)) {
local_9 = 1;
}
else if (((byte)(*(ushort *)param_1 >> 2) & 3) < ((byte)(*(ushort *)this >> 2) & 3)) {
local_9 = 0;
}
else if (((byte)(*(ushort *)this >> 4) & 3) < ((byte)(*(ushort *)param_1 >> 4) & 3)) {
local_9 = 1;
}
else if (((byte)(*(ushort *)param_1 >> 4) & 3) < ((byte)(*(ushort *)this >> 4) & 3)) {
local_9 = 0;
}
else if (((byte)(*(ushort *)this >> 6) & 3) < ((byte)(*(ushort *)param_1 >> 6) & 3)) {
local_9 = 1;
}
else if (((byte)(*(ushort *)param_1 >> 6) & 3) < ((byte)(*(ushort *)this >> 6) & 3)) {
local_9 = 0;
}
else if (((byte)((ushort)*(int2 *)this >> 8) & 1) <
((byte)((ushort)*(int2 *)param_1 >> 8) & 1)) {
local_9 = 1;
}
else if (((byte)((ushort)*(int2 *)param_1 >> 8) & 1) <
((byte)((ushort)*(int2 *)this >> 8) & 1)) {
local_9 = 0;
}
else {
local_9 = 0;
}
return local_9;
}
|
|
6,432 | void (anonymous namespace)::tinyBLAS_Q0_AVX<block_q4_0, block_q8_0, float>::gemm4xN<3>(long, long, long, long) | llama.cpp/ggml/src/ggml-cpu/llamafile/sgemm.cpp | NOINLINE void gemm4xN(int64_t m0, int64_t m, int64_t n0, int64_t n) {
int64_t ytiles = (m - m0) / 4;
int64_t xtiles = (n - n0) / RN;
int64_t tiles = xtiles * ytiles;
int64_t duty = (tiles + nth - 1) / nth;
int64_t start = duty * ith;
int64_t end = start + duty;
if (end > tiles)
end = tiles;
for (int64_t job = start; job < end; ++job) {
int64_t ii = m0 + job / xtiles * 4;
int64_t jj = n0 + job % xtiles * RN;
__m256 Cv[RN][4] = {};
for (int64_t l = 0; l < k; ++l) {
uint64_t a_delta = ((uint64_t)A[lda * (ii + 3) + l].d << 48) | ((uint64_t)A[lda * (ii + 2) + l].d << 32) | ((uint64_t)A[lda * (ii + 1) + l].d << 16) | (A[lda * (ii + 0) + l].d);
// Convert delta values for four blocks to float values
__m128 da = _mm_cvtph_ps(_mm_set_epi64x(0, a_delta));
__m256i avec0 = load(A + lda * (ii + 0) + l);
__m256i avec1 = load(A + lda * (ii + 1) + l);
__m256i avec2 = load(A + lda * (ii + 2) + l);
__m256i avec3 = load(A + lda * (ii + 3) + l);
for (int64_t j = 0; j < RN; ++j) {
__m128 db = _mm_set1_ps(unhalf(B[ldb * (jj + j) + l].d));
// Computation of product of delta values for four blocks and replicate it across 256 bit lane
__m256 dvec = _mm256_castps128_ps256(_mm_mul_ps(da, db));
dvec = _mm256_permute2f128_ps(dvec ,dvec, 0);
// Computation of dot product and multiplication with appropriate delta value products
Cv[j][0] = madd(_mm256_shuffle_ps(dvec, dvec, 0),
updot(_mm256_sign_epi8(avec0, avec0),
_mm256_sign_epi8(load(B + ldb * (jj + j) + l), avec0)),
Cv[j][0]);
Cv[j][1] = madd(_mm256_shuffle_ps(dvec, dvec, 85),
updot(_mm256_sign_epi8(avec1, avec1),
_mm256_sign_epi8(load(B + ldb * (jj + j) + l), avec1)),
Cv[j][1]);
Cv[j][2] = madd(_mm256_shuffle_ps(dvec, dvec, 170),
updot(_mm256_sign_epi8(avec2, avec2),
_mm256_sign_epi8(load(B + ldb * (jj + j) + l), avec2)),
Cv[j][2]);
Cv[j][3] = madd(_mm256_shuffle_ps(dvec, dvec, 255),
updot(_mm256_sign_epi8(avec3, avec3),
_mm256_sign_epi8(load(B + ldb * (jj + j) + l), avec3)),
Cv[j][3]);
}
}
for (int64_t j = 0; j < RN; ++j)
for (int64_t i = 0; i < 4; ++i)
C[ldc * (jj + j) + (ii + i)] = hsum(Cv[j][i]);
}
} | O3 | cpp | void (anonymous namespace)::tinyBLAS_Q0_AVX<block_q4_0, block_q8_0, float>::gemm4xN<3>(long, long, long, long):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x100, %rsp # imm = 0x100
movq %rsi, 0x48(%rsp)
subq %rsi, %rdx
leaq 0x3(%rdx), %r9
testq %rdx, %rdx
cmovnsq %rdx, %r9
sarq $0x2, %r9
movq %rcx, 0x50(%rsp)
subq %rcx, %r8
movq %r8, 0x58(%rsp)
imulq %r8, %r9
movslq 0x3c(%rdi), %rsi
leaq (%r9,%rsi), %rax
decq %rax
cqto
idivq %rsi
movq %rdi, 0x10(%rsp)
movslq 0x38(%rdi), %r10
imulq %rax, %r10
addq %r10, %rax
cmpq %r9, %rax
cmovgeq %r9, %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %r10
jge 0x6603f
movq 0x10(%rsp), %rdx
movq 0x18(%rdx), %r8
movq 0x20(%rdx), %rax
movq (%rdx), %rdi
movq 0x8(%rdx), %r9
movq 0x28(%rdx), %rcx
movq 0x10(%rdx), %rsi
movq %rsi, 0x38(%rsp)
movq 0x30(%rdx), %rdx
movq %rdx, 0x30(%rsp)
addq %rax, %rax
leaq (%rax,%rax,8), %rsi
addq $0x2, %rdi
movq %rdi, 0x28(%rsp)
addq $0x2, %r9
movq %r9, 0x20(%rsp)
movq %rcx, %rax
shlq $0x5, %rax
leaq (%rax,%rcx,2), %rax
movq %rax, 0x18(%rsp)
vxorps %xmm0, %xmm0, %xmm0
movq 0x17197(%rip), %rbx # 0x7cf60
vpbroadcastb 0xdd96(%rip), %ymm1 # 0x73b68
vpbroadcastw 0xdd8f(%rip), %ymm2 # 0x73b6a
vbroadcastss 0x2fb8(%rip), %ymm3 # 0x68d9c
vbroadcastss 0x2fb3(%rip), %ymm4 # 0x68da0
vbroadcastss 0x2f82(%rip), %ymm5 # 0x68d78
movq %r10, %rax
cqto
idivq 0x58(%rsp)
addq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
leaq 0x80(%rsp), %rcx
vmovaps %ymm0, 0x40(%rcx)
vmovaps %ymm0, 0x20(%rcx)
vmovaps %ymm0, (%rcx)
vxorps %xmm7, %xmm7, %xmm7
testq %r8, %r8
jle 0x65fee
leaq 0x3(%rax), %r15
leaq 0x2(%rax), %rdi
movq 0x10(%rsp), %rcx
vmovdqa 0x40(%rcx), %xmm7
leaq 0x1(%rax), %rcx
imulq %rsi, %r15
imulq %rsi, %rdi
imulq %rsi, %rcx
movq %rsi, %r14
imulq %rax, %r14
movq 0x18(%rsp), %r12
imulq %rdx, %r12
addq 0x20(%rsp), %r12
vxorps %xmm6, %xmm6, %xmm6
vinserti128 $0x1, %xmm7, %ymm7, %ymm8
movq 0x28(%rsp), %r9
movq %r8, %r11
vxorps %xmm9, %xmm9, %xmm9
vxorps %xmm10, %xmm10, %xmm10
vpxor %xmm7, %xmm7, %xmm7
movzwl -0x2(%r9,%r14), %r13d
vmovd %r13d, %xmm11
vpinsrw $0x1, -0x2(%r9,%rcx), %xmm11, %xmm11
vpinsrw $0x2, -0x2(%r9,%rdi), %xmm11, %xmm11
vpinsrw $0x3, -0x2(%r9,%r15), %xmm11, %xmm11
vcvtph2ps %xmm11, %xmm11
vmovdqu (%r9,%r14), %xmm12
vpsrlw $0x4, %xmm12, %xmm13
vmovdqu (%r9,%rcx), %xmm14
vpsrlw $0x4, %xmm14, %xmm15
vmovdqu64 (%r9,%rdi), %xmm16
vpsrlw $0x4, %xmm16, %xmm17
vmovdqu64 (%r9,%r15), %xmm18
vpsrlw $0x4, %xmm18, %xmm19
movzwl -0x2(%r12), %r13d
vmulps (%rbx,%r13,4){1to4}, %xmm11, %xmm20
vbroadcastss %xmm20, %ymm21
vinserti128 $0x1, %xmm13, %ymm12, %ymm11
vpand %ymm1, %ymm11, %ymm11
vpshufb %ymm11, %ymm8, %ymm12
vpsignb %ymm12, %ymm12, %ymm13
vmovdqu (%r12), %ymm11
vpsignb %ymm12, %ymm11, %ymm12
vpmaddubsw %ymm12, %ymm13, %ymm12
vpmaddwd %ymm2, %ymm12, %ymm12
vcvtdq2ps %ymm12, %ymm12
vfmadd231ps %ymm12, %ymm21, %ymm7 # ymm7 = (ymm21 * ymm12) + ymm7
vpermps %ymm20, %ymm3, %ymm12
vinserti128 $0x1, %xmm15, %ymm14, %ymm13
vpand %ymm1, %ymm13, %ymm13
vpshufb %ymm13, %ymm8, %ymm13
vpsignb %ymm13, %ymm13, %ymm14
vpsignb %ymm13, %ymm11, %ymm13
vpmaddubsw %ymm13, %ymm14, %ymm13
vpmaddwd %ymm2, %ymm13, %ymm13
vcvtdq2ps %ymm13, %ymm13
vfmadd231ps %ymm13, %ymm12, %ymm10 # ymm10 = (ymm12 * ymm13) + ymm10
vpermps %ymm20, %ymm4, %ymm12
vinserti32x4 $0x1, %xmm17, %ymm16, %ymm13
vpand %ymm1, %ymm13, %ymm13
vpshufb %ymm13, %ymm8, %ymm13
vpsignb %ymm13, %ymm13, %ymm14
vpsignb %ymm13, %ymm11, %ymm13
vpmaddubsw %ymm13, %ymm14, %ymm13
vpmaddwd %ymm2, %ymm13, %ymm13
vcvtdq2ps %ymm13, %ymm13
vfmadd231ps %ymm13, %ymm12, %ymm9 # ymm9 = (ymm12 * ymm13) + ymm9
vpermps %ymm20, %ymm5, %ymm12
vinserti32x4 $0x1, %xmm19, %ymm18, %ymm13
vpand %ymm1, %ymm13, %ymm13
vpshufb %ymm13, %ymm8, %ymm13
vpsignb %ymm13, %ymm13, %ymm14
vpsignb %ymm13, %ymm11, %ymm11
vpmaddubsw %ymm11, %ymm14, %ymm11
vpmaddwd %ymm2, %ymm11, %ymm11
vcvtdq2ps %ymm11, %ymm11
vfmadd231ps %ymm11, %ymm12, %ymm6 # ymm6 = (ymm12 * ymm11) + ymm6
addq $0x12, %r9
addq $0x22, %r12
decq %r11
jne 0x65e88
vmovaps %ymm10, 0x80(%rsp)
vmovaps %ymm9, 0xa0(%rsp)
vmovaps %ymm6, 0xc0(%rsp)
vmovaps %ymm7, 0x60(%rsp)
imulq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq (%rcx,%rdx,4), %rcx
leaq (%rcx,%rax,4), %rax
xorl %ecx, %ecx
vmovaps 0x70(%rsp,%rcx,8), %xmm6
vaddps 0x60(%rsp,%rcx,8), %xmm6, %xmm6
vshufpd $0x1, %xmm6, %xmm6, %xmm7 # xmm7 = xmm6[1,0]
vaddps %xmm7, %xmm6, %xmm6
vhaddps %xmm6, %xmm6, %xmm6
vmovss %xmm6, (%rax,%rcx)
addq $0x4, %rcx
cmpq $0x10, %rcx
jne 0x66009
incq %r10
cmpq 0x40(%rsp), %r10
jne 0x65df6
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
nop
| _ZN12_GLOBAL__N_115tinyBLAS_Q0_AVXI12block_iq4_nl10block_q8_0fE7gemm4xNILi1EEEvllll:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
and rsp, 0FFFFFFFFFFFFFFE0h
sub rsp, 100h
mov [rsp+128h+var_E0], rsi
sub rdx, rsi
lea r9, [rdx+3]
test rdx, rdx
cmovns r9, rdx
sar r9, 2
mov [rsp+128h+var_D8], rcx
sub r8, rcx
mov [rsp+128h+var_D0], r8
imul r9, r8
movsxd rsi, dword ptr [rdi+3Ch]
lea rax, [r9+rsi]
dec rax
cqo
idiv rsi
mov [rsp+128h+var_118], rdi
movsxd r10, dword ptr [rdi+38h]
imul r10, rax
add rax, r10
cmp rax, r9
cmovge rax, r9
mov [rsp+128h+var_E8], rax
cmp r10, rax
jge loc_6603F
mov rdx, [rsp+128h+var_118]
mov r8, [rdx+18h]
mov rax, [rdx+20h]
mov rdi, [rdx]
mov r9, [rdx+8]
mov rcx, [rdx+28h]
mov rsi, [rdx+10h]
mov [rsp+128h+var_F0], rsi
mov rdx, [rdx+30h]
mov [rsp+128h+var_F8], rdx
add rax, rax
lea rsi, [rax+rax*8]
add rdi, 2
mov [rsp+128h+var_100], rdi
add r9, 2
mov [rsp+128h+var_108], r9
mov rax, rcx
shl rax, 5
lea rax, [rax+rcx*2]
mov [rsp+128h+var_110], rax
vxorps xmm0, xmm0, xmm0
mov rbx, cs:ggml_table_f32_f16_ptr
vpbroadcastb ymm1, cs:byte_73B68
vpbroadcastw ymm2, cs:word_73B6A
vbroadcastss ymm3, cs:dword_68D9C
vbroadcastss ymm4, cs:dword_68DA0
vbroadcastss ymm5, cs:dword_68D78
loc_65DF6:
mov rax, r10
cqo
idiv [rsp+128h+var_D0]
add rdx, [rsp+128h+var_D8]
mov rcx, [rsp+128h+var_E0]
lea rax, [rcx+rax*4]
lea rcx, [rsp+128h+var_A8]
vmovaps ymmword ptr [rcx+40h], ymm0
vmovaps ymmword ptr [rcx+20h], ymm0
vmovaps ymmword ptr [rcx], ymm0
vxorps xmm7, xmm7, xmm7
test r8, r8
jle loc_65FEE
lea r15, [rax+3]
lea rdi, [rax+2]
mov rcx, [rsp+128h+var_118]
vmovdqa xmm7, xmmword ptr [rcx+40h]
lea rcx, [rax+1]
imul r15, rsi
imul rdi, rsi
imul rcx, rsi
mov r14, rsi
imul r14, rax
mov r12, [rsp+128h+var_110]
imul r12, rdx
add r12, [rsp+128h+var_108]
vxorps xmm6, xmm6, xmm6
vinserti128 ymm8, ymm7, xmm7, 1
mov r9, [rsp+128h+var_100]
mov r11, r8
vxorps xmm9, xmm9, xmm9
vxorps xmm10, xmm10, xmm10
vpxor xmm7, xmm7, xmm7
loc_65E88:
movzx r13d, word ptr [r9+r14-2]
vmovd xmm11, r13d
vpinsrw xmm11, xmm11, word ptr [r9+rcx-2], 1
vpinsrw xmm11, xmm11, word ptr [r9+rdi-2], 2
vpinsrw xmm11, xmm11, word ptr [r9+r15-2], 3
vcvtph2ps xmm11, xmm11
vmovdqu xmm12, xmmword ptr [r9+r14]
vpsrlw xmm13, xmm12, 4
vmovdqu xmm14, xmmword ptr [r9+rcx]
vpsrlw xmm15, xmm14, 4
vmovdqu64 xmm16, xmmword ptr [r9+rdi]
vpsrlw xmm17, xmm16, 4
vmovdqu64 xmm18, xmmword ptr [r9+r15]
vpsrlw xmm19, xmm18, 4
movzx r13d, word ptr [r12-2]
vmulps xmm20, xmm11, dword ptr [rbx+r13*4]{1to4}
vbroadcastss ymm21, xmm20
vinserti128 ymm11, ymm12, xmm13, 1
vpand ymm11, ymm11, ymm1
vpshufb ymm12, ymm8, ymm11
vpsignb ymm13, ymm12, ymm12
vmovdqu ymm11, ymmword ptr [r12]
vpsignb ymm12, ymm11, ymm12
vpmaddubsw ymm12, ymm13, ymm12
vpmaddwd ymm12, ymm12, ymm2
vcvtdq2ps ymm12, ymm12
vfmadd231ps ymm7, ymm21, ymm12
vpermps ymm12, ymm3, ymm20
vinserti128 ymm13, ymm14, xmm15, 1
vpand ymm13, ymm13, ymm1
vpshufb ymm13, ymm8, ymm13
vpsignb ymm14, ymm13, ymm13
vpsignb ymm13, ymm11, ymm13
vpmaddubsw ymm13, ymm14, ymm13
vpmaddwd ymm13, ymm13, ymm2
vcvtdq2ps ymm13, ymm13
vfmadd231ps ymm10, ymm12, ymm13
vpermps ymm12, ymm4, ymm20
vinserti32x4 ymm13, ymm16, xmm17, 1
vpand ymm13, ymm13, ymm1
vpshufb ymm13, ymm8, ymm13
vpsignb ymm14, ymm13, ymm13
vpsignb ymm13, ymm11, ymm13
vpmaddubsw ymm13, ymm14, ymm13
vpmaddwd ymm13, ymm13, ymm2
vcvtdq2ps ymm13, ymm13
vfmadd231ps ymm9, ymm12, ymm13
vpermps ymm12, ymm5, ymm20
vinserti32x4 ymm13, ymm18, xmm19, 1
vpand ymm13, ymm13, ymm1
vpshufb ymm13, ymm8, ymm13
vpsignb ymm14, ymm13, ymm13
vpsignb ymm11, ymm11, ymm13
vpmaddubsw ymm11, ymm14, ymm11
vpmaddwd ymm11, ymm11, ymm2
vcvtdq2ps ymm11, ymm11
vfmadd231ps ymm6, ymm12, ymm11
add r9, 12h
add r12, 22h ; '"'
dec r11
jnz loc_65E88
vmovaps [rsp+128h+var_A8], ymm10
vmovaps [rsp+128h+var_88], ymm9
vmovaps [rsp+128h+var_68], ymm6
loc_65FEE:
vmovaps [rsp+128h+var_C8], ymm7
imul rdx, [rsp+128h+var_F8]
mov rcx, [rsp+128h+var_F0]
lea rcx, [rcx+rdx*4]
lea rax, [rcx+rax*4]
xor ecx, ecx
loc_66009:
vmovaps xmm6, xmmword ptr [rsp+rcx*8+128h+var_C8+10h]
vaddps xmm6, xmm6, xmmword ptr [rsp+rcx*8+128h+var_C8]
vshufpd xmm7, xmm6, xmm6, 1
vaddps xmm6, xmm6, xmm7
vhaddps xmm6, xmm6, xmm6
vmovss dword ptr [rax+rcx], xmm6
add rcx, 4
cmp rcx, 10h
jnz short loc_66009
inc r10
cmp r10, [rsp+128h+var_E8]
jnz loc_65DF6
loc_6603F:
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
vzeroupper
retn
| long long `anonymous namespace'::tinyBLAS_Q0_AVX<block_iq4_nl,block_q8_0,float>::gemm4xN<1>(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
__m128 _XMM0,
double a7,
double a8,
double a9,
double a10,
double a11,
__m128 _XMM6,
__m128 _XMM7)
{
long long v21; // r9
long long v22; // rax
long long v23; // r10
long long result; // rax
long long v25; // r8
long long v26; // rsi
long long v33; // rdx
long long v34; // rax
long long v47; // r11
long long v102; // [rsp+18h] [rbp-110h]
long long v103; // [rsp+20h] [rbp-108h]
long long v104; // [rsp+28h] [rbp-100h]
long long v105; // [rsp+30h] [rbp-F8h]
long long v106; // [rsp+38h] [rbp-F0h]
long long v107; // [rsp+40h] [rbp-E8h]
long long v110; // [rsp+58h] [rbp-D0h]
__m256 v112; // [rsp+80h] [rbp-A8h] BYREF
v110 = a5 - a4;
v21 = (a5 - a4) * ((a3 - a2) / 4);
v22 = (v21 + *(int *)(a1 + 60) - 1) / *(int *)(a1 + 60);
v23 = v22 * *(int *)(a1 + 56);
result = v23 + v22;
if ( result >= v21 )
result = (a5 - a4) * ((a3 - a2) / 4);
v107 = result;
if ( v23 < result )
{
v25 = *(_QWORD *)(a1 + 24);
v106 = *(_QWORD *)(a1 + 16);
v105 = *(_QWORD *)(a1 + 48);
v26 = 18LL * *(_QWORD *)(a1 + 32);
v104 = *(_QWORD *)a1 + 2LL;
v103 = *(_QWORD *)(a1 + 8) + 2LL;
v102 = 34LL * *(_QWORD *)(a1 + 40);
__asm
{
vxorps xmm0, xmm0, xmm0
vpbroadcastb ymm1, cs:byte_73B68
vpbroadcastw ymm2, cs:word_73B6A
vbroadcastss ymm3, cs:dword_68D9C
vbroadcastss ymm4, cs:dword_68DA0
vbroadcastss ymm5, cs:dword_68D78
}
do
{
v33 = a4 + v23 % v110;
v34 = a2 + 4 * (v23 / v110);
_RCX = &v112;
__asm
{
vmovaps ymmword ptr [rcx+40h], ymm0
vmovaps ymmword ptr [rcx+20h], ymm0
vmovaps ymmword ptr [rcx], ymm0
vxorps xmm7, xmm7, xmm7
}
if ( v25 > 0 )
{
_RCX = a1;
__asm { vmovdqa xmm7, xmmword ptr [rcx+40h] }
_R15 = v26 * (v34 + 3);
_RDI = v26 * (v34 + 2);
_RCX = v26 * (v34 + 1);
_R14 = v34 * v26;
_R12 = v103 + v33 * v102;
__asm
{
vxorps xmm6, xmm6, xmm6
vinserti128 ymm8, ymm7, xmm7, 1
}
_R9 = v104;
v47 = v25;
__asm
{
vxorps xmm9, xmm9, xmm9
vxorps xmm10, xmm10, xmm10
vpxor xmm7, xmm7, xmm7
}
do
{
_R13D = *(unsigned __int16 *)(_R9 + _R14 - 2);
__asm
{
vmovd xmm11, r13d
vpinsrw xmm11, xmm11, word ptr [r9+rcx-2], 1
vpinsrw xmm11, xmm11, word ptr [r9+rdi-2], 2
vpinsrw xmm11, xmm11, word ptr [r9+r15-2], 3
vcvtph2ps xmm11, xmm11
vmovdqu xmm12, xmmword ptr [r9+r14]
vpsrlw xmm13, xmm12, 4
vmovdqu xmm14, xmmword ptr [r9+rcx]
vpsrlw xmm15, xmm14, 4
vmovdqu64 xmm16, xmmword ptr [r9+rdi]
vpsrlw xmm17, xmm16, 4
vmovdqu64 xmm18, xmmword ptr [r9+r15]
vpsrlw xmm19, xmm18, 4
vmulps xmm20, xmm11, dword ptr [rbx+r13*4]{1to4}
vbroadcastss ymm21, xmm20
vinserti128 ymm11, ymm12, xmm13, 1
vpand ymm11, ymm11, ymm1
vpshufb ymm12, ymm8, ymm11
vpsignb ymm13, ymm12, ymm12
vmovdqu ymm11, ymmword ptr [r12]
vpsignb ymm12, ymm11, ymm12
vpmaddubsw ymm12, ymm13, ymm12
vpmaddwd ymm12, ymm12, ymm2
vcvtdq2ps ymm12, ymm12
vfmadd231ps ymm7, ymm21, ymm12
vpermps ymm12, ymm3, ymm20
vinserti128 ymm13, ymm14, xmm15, 1
vpand ymm13, ymm13, ymm1
vpshufb ymm13, ymm8, ymm13
vpsignb ymm14, ymm13, ymm13
vpsignb ymm13, ymm11, ymm13
vpmaddubsw ymm13, ymm14, ymm13
vpmaddwd ymm13, ymm13, ymm2
vcvtdq2ps ymm13, ymm13
vfmadd231ps ymm10, ymm12, ymm13
vpermps ymm12, ymm4, ymm20
vinserti32x4 ymm13, ymm16, xmm17, 1
vpand ymm13, ymm13, ymm1
vpshufb ymm13, ymm8, ymm13
vpsignb ymm14, ymm13, ymm13
vpsignb ymm13, ymm11, ymm13
vpmaddubsw ymm13, ymm14, ymm13
vpmaddwd ymm13, ymm13, ymm2
vcvtdq2ps ymm13, ymm13
vfmadd231ps ymm9, ymm12, ymm13
vpermps ymm12, ymm5, ymm20
vinserti32x4 ymm13, ymm18, xmm19, 1
vpand ymm13, ymm13, ymm1
vpshufb ymm13, ymm8, ymm13
vpsignb ymm14, ymm13, ymm13
vpsignb ymm11, ymm11, ymm13
vpmaddubsw ymm11, ymm14, ymm11
vpmaddwd ymm11, ymm11, ymm2
vcvtdq2ps ymm11, ymm11
vfmadd231ps ymm6, ymm12, ymm11
}
_R9 += 18LL;
_R12 += 34LL;
--v47;
}
while ( v47 );
__asm
{
vmovaps [rsp+128h+var_A8], ymm10
vmovaps [rsp+128h+var_88], ymm9
vmovaps [rsp+128h+var_68], ymm6
}
}
__asm { vmovaps [rsp+128h+var_C8], ymm7 }
result = v106 + 4 * v105 * v33 + 4 * v34;
for ( _RCX = 0LL; _RCX != 16; _RCX += 4LL )
{
__asm
{
vmovaps xmm6, xmmword ptr [rsp+rcx*8+128h+var_C8+10h]
vaddps xmm6, xmm6, xmmword ptr [rsp+rcx*8+128h+var_C8]
vshufpd xmm7, xmm6, xmm6, 1
vaddps xmm6, xmm6, xmm7
vhaddps xmm6, xmm6, xmm6
vmovss dword ptr [rax+rcx], xmm6
}
}
++v23;
}
while ( v23 != v107 );
}
__asm { vzeroupper }
return result;
}
| gemm4xN<1>:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
AND RSP,-0x20
SUB RSP,0x100
MOV qword ptr [RSP + 0x48],RSI
SUB RDX,RSI
LEA R9,[RDX + 0x3]
TEST RDX,RDX
CMOVNS R9,RDX
SAR R9,0x2
MOV qword ptr [RSP + 0x50],RCX
SUB R8,RCX
MOV qword ptr [RSP + 0x58],R8
IMUL R9,R8
MOVSXD RSI,dword ptr [RDI + 0x3c]
LEA RAX,[R9 + RSI*0x1]
DEC RAX
CQO
IDIV RSI
MOV qword ptr [RSP + 0x10],RDI
MOVSXD R10,dword ptr [RDI + 0x38]
IMUL R10,RAX
ADD RAX,R10
CMP RAX,R9
CMOVGE RAX,R9
MOV qword ptr [RSP + 0x40],RAX
CMP R10,RAX
JGE 0x0016603f
MOV RDX,qword ptr [RSP + 0x10]
MOV R8,qword ptr [RDX + 0x18]
MOV RAX,qword ptr [RDX + 0x20]
MOV RDI,qword ptr [RDX]
MOV R9,qword ptr [RDX + 0x8]
MOV RCX,qword ptr [RDX + 0x28]
MOV RSI,qword ptr [RDX + 0x10]
MOV qword ptr [RSP + 0x38],RSI
MOV RDX,qword ptr [RDX + 0x30]
MOV qword ptr [RSP + 0x30],RDX
ADD RAX,RAX
LEA RSI,[RAX + RAX*0x8]
ADD RDI,0x2
MOV qword ptr [RSP + 0x28],RDI
ADD R9,0x2
MOV qword ptr [RSP + 0x20],R9
MOV RAX,RCX
SHL RAX,0x5
LEA RAX,[RAX + RCX*0x2]
MOV qword ptr [RSP + 0x18],RAX
VXORPS XMM0,XMM0,XMM0
MOV RBX,qword ptr [0x0017cf60]
VPBROADCASTB YMM1,byte ptr [0x00173b68]
VPBROADCASTW YMM2,word ptr [0x00173b6a]
VBROADCASTSS YMM3,dword ptr [0x00168d9c]
VBROADCASTSS YMM4,dword ptr [0x00168da0]
VBROADCASTSS YMM5,dword ptr [0x00168d78]
LAB_00165df6:
MOV RAX,R10
CQO
IDIV qword ptr [RSP + 0x58]
ADD RDX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x48]
LEA RAX,[RCX + RAX*0x4]
LEA RCX,[RSP + 0x80]
VMOVAPS ymmword ptr [RCX + 0x40],YMM0
VMOVAPS ymmword ptr [RCX + 0x20],YMM0
VMOVAPS ymmword ptr [RCX],YMM0
VXORPS XMM7,XMM7,XMM7
TEST R8,R8
JLE 0x00165fee
LEA R15,[RAX + 0x3]
LEA RDI,[RAX + 0x2]
MOV RCX,qword ptr [RSP + 0x10]
VMOVDQA XMM7,xmmword ptr [RCX + 0x40]
LEA RCX,[RAX + 0x1]
IMUL R15,RSI
IMUL RDI,RSI
IMUL RCX,RSI
MOV R14,RSI
IMUL R14,RAX
MOV R12,qword ptr [RSP + 0x18]
IMUL R12,RDX
ADD R12,qword ptr [RSP + 0x20]
VXORPS XMM6,XMM6,XMM6
VINSERTI128 YMM8,YMM7,XMM7,0x1
MOV R9,qword ptr [RSP + 0x28]
MOV R11,R8
VXORPS XMM9,XMM9,XMM9
VXORPS XMM10,XMM10,XMM10
VPXOR XMM7,XMM7,XMM7
LAB_00165e88:
MOVZX R13D,word ptr [R9 + R14*0x1 + -0x2]
VMOVD XMM11,R13D
VPINSRW XMM11,XMM11,word ptr [R9 + RCX*0x1 + -0x2],0x1
VPINSRW XMM11,XMM11,word ptr [R9 + RDI*0x1 + -0x2],0x2
VPINSRW XMM11,XMM11,word ptr [R9 + R15*0x1 + -0x2],0x3
VCVTPH2PS XMM11,XMM11
VMOVDQU XMM12,xmmword ptr [R9 + R14*0x1]
VPSRLW XMM13,XMM12,0x4
VMOVDQU XMM14,xmmword ptr [R9 + RCX*0x1]
VPSRLW XMM15,XMM14,0x4
VMOVDQU64 XMM0,xmmword ptr [R9 + RDI*0x1]
VPSRLW XMM1,XMM0,0x4
VMOVDQU64 XMM2,xmmword ptr [R9 + R15*0x1]
VPSRLW XMM3,XMM2,0x4
MOVZX R13D,word ptr [R12 + -0x2]
VMULPS XMM4,XMM11,dword ptr [RBX + R13*0x4]
VBROADCASTSS YMM5,XMM4
VINSERTI128 YMM11,YMM12,XMM13,0x1
VPAND YMM11,YMM11,YMM1
VPSHUFB YMM12,YMM8,YMM11
VPSIGNB YMM13,YMM12,YMM12
VMOVDQU YMM11,ymmword ptr [R12]
VPSIGNB YMM12,YMM11,YMM12
VPMADDUBSW YMM12,YMM13,YMM12
VPMADDWD YMM12,YMM12,YMM2
VCVTDQ2PS YMM12,YMM12
VFMADD231PS YMM7,YMM5,YMM12
VPERMPS YMM12,YMM3,YMM4
VINSERTI128 YMM13,YMM14,XMM15,0x1
VPAND YMM13,YMM13,YMM1
VPSHUFB YMM13,YMM8,YMM13
VPSIGNB YMM14,YMM13,YMM13
VPSIGNB YMM13,YMM11,YMM13
VPMADDUBSW YMM13,YMM14,YMM13
VPMADDWD YMM13,YMM13,YMM2
VCVTDQ2PS YMM13,YMM13
VFMADD231PS YMM10,YMM12,YMM13
VPERMPS YMM12,YMM4,YMM4
VINSERTI32X4 YMM13,YMM0,XMM1,0x1
VPAND YMM13,YMM13,YMM1
VPSHUFB YMM13,YMM8,YMM13
VPSIGNB YMM14,YMM13,YMM13
VPSIGNB YMM13,YMM11,YMM13
VPMADDUBSW YMM13,YMM14,YMM13
VPMADDWD YMM13,YMM13,YMM2
VCVTDQ2PS YMM13,YMM13
VFMADD231PS YMM9,YMM12,YMM13
VPERMPS YMM12,YMM5,YMM4
VINSERTI32X4 YMM13,YMM2,XMM3,0x1
VPAND YMM13,YMM13,YMM1
VPSHUFB YMM13,YMM8,YMM13
VPSIGNB YMM14,YMM13,YMM13
VPSIGNB YMM11,YMM11,YMM13
VPMADDUBSW YMM11,YMM14,YMM11
VPMADDWD YMM11,YMM11,YMM2
VCVTDQ2PS YMM11,YMM11
VFMADD231PS YMM6,YMM12,YMM11
ADD R9,0x12
ADD R12,0x22
DEC R11
JNZ 0x00165e88
VMOVAPS ymmword ptr [RSP + 0x80],YMM10
VMOVAPS ymmword ptr [RSP + 0xa0],YMM9
VMOVAPS ymmword ptr [RSP + 0xc0],YMM6
LAB_00165fee:
VMOVAPS ymmword ptr [RSP + 0x60],YMM7
IMUL RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
LEA RCX,[RCX + RDX*0x4]
LEA RAX,[RCX + RAX*0x4]
XOR ECX,ECX
LAB_00166009:
VMOVAPS XMM6,xmmword ptr [RSP + RCX*0x8 + 0x70]
VADDPS XMM6,XMM6,xmmword ptr [RSP + RCX*0x8 + 0x60]
VSHUFPD XMM7,XMM6,XMM6,0x1
VADDPS XMM6,XMM6,XMM7
VHADDPS XMM6,XMM6,XMM6
VMOVSS dword ptr [RAX + RCX*0x1],XMM6
ADD RCX,0x4
CMP RCX,0x10
JNZ 0x00166009
INC R10
CMP R10,qword ptr [RSP + 0x40]
JNZ 0x00165df6
LAB_0016603f:
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
VZEROUPPER
RET
|
/* void (anonymous namespace)::tinyBLAS_Q0_AVX<block_iq4_nl, block_q8_0, float>::gemm4xN<1>(long,
long, long, long) */
void __thiscall
(anonymous_namespace)::tinyBLAS_Q0_AVX<block_iq4_nl,block_q8_0,float>::gemm4xN<1>
(tinyBLAS_Q0_AVX<block_iq4_nl,block_q8_0,float> *this,long param_1,long param_2,
long param_3,long param_4)
{
long lVar1;
int4 uVar2;
int1 auVar3 [16];
long lVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
int1 auVar9 [16];
int1 auVar10 [32];
int1 auVar11 [16];
long lVar12;
int *puVar13;
long lVar14;
long lVar15;
long lVar16;
long lVar17;
long lVar18;
long lVar19;
long lVar20;
long lVar21;
long lVar22;
int1 (*pauVar23) [32];
long lVar24;
int1 auVar25 [16];
int1 auVar26 [16];
int1 auVar27 [16];
int1 auVar28 [16];
int1 auVar29 [16];
int1 auVar30 [32];
int1 auVar31 [32];
int1 auVar32 [32];
int1 auVar33 [32];
int1 auVar34 [64];
int1 auVar35 [32];
int1 auVar36 [32];
int1 auVar37 [16];
int1 auVar38 [16];
int1 auVar39 [64];
int1 auVar40 [16];
int8 uVar41;
int8 uVar42;
int1 auVar43 [16];
int1 auVar44 [32];
int1 auVar45 [16];
int1 auVar46 [16];
int1 local_e0 [4];
float afStack_dc [7];
int1 local_c0 [32];
int1 local_a0 [32];
int1 local_80 [32];
puVar13 = PTR_ggml_table_f32_f16_0017cf60;
lVar16 = param_2 - param_1;
lVar14 = lVar16 + 3;
if (-1 < lVar16) {
lVar14 = lVar16;
}
lVar16 = param_4 - param_3;
lVar19 = (lVar14 >> 2) * lVar16;
lVar14 = (lVar19 + *(int *)(this + 0x3c) + -1) / (long)*(int *)(this + 0x3c);
lVar21 = *(int *)(this + 0x38) * lVar14;
lVar14 = lVar14 + lVar21;
if (lVar19 <= lVar14) {
lVar14 = lVar19;
}
if (lVar21 < lVar14) {
lVar19 = *(long *)(this + 0x18);
lVar4 = *(long *)this;
lVar5 = *(long *)(this + 8);
lVar6 = *(long *)(this + 0x28);
lVar7 = *(long *)(this + 0x10);
lVar8 = *(long *)(this + 0x30);
lVar12 = *(long *)(this + 0x20) * 0x12;
auVar34 = ZEXT1664(ZEXT816(0) << 0x40);
do {
lVar17 = lVar21 % lVar16 + param_3;
lVar1 = param_1 + (lVar21 / lVar16) * 4;
local_80 = auVar34._0_32_;
local_a0 = local_80;
local_c0 = local_80;
_local_e0 = ZEXT832(0) << 0x40;
if (0 < lVar19) {
auVar43 = *(int1 (*) [16])(this + 0x40);
lVar24 = (lVar1 + 3) * lVar12;
lVar18 = (lVar1 + 2) * lVar12;
lVar15 = (lVar1 + 1) * lVar12;
pauVar23 = (int1 (*) [32])(lVar6 * 0x22 * lVar17 + lVar5 + 2);
auVar37 = ZEXT816(0) << 0x40;
auVar40 = ZEXT116(0) * auVar43 + ZEXT116(1) * auVar43;
auVar43 = ZEXT116(1) * auVar43;
uVar41 = auVar43._0_8_;
uVar42 = auVar43._8_8_;
auVar38 = ZEXT816(0) << 0x40;
auVar43 = ZEXT816(0) << 0x40;
auVar39 = ZEXT1664((int1 [16])0x0);
lVar20 = lVar4 + 2;
lVar22 = lVar19;
do {
auVar9 = vpinsrw_avx(ZEXT216(*(ushort *)(lVar20 + -2 + lVar12 * lVar1)),
(uint)*(ushort *)(lVar20 + -2 + lVar15),1);
auVar9 = vpinsrw_avx(auVar9,(uint)*(ushort *)(lVar20 + -2 + lVar18),2);
auVar9 = vpinsrw_avx(auVar9,(uint)*(ushort *)(lVar20 + -2 + lVar24),3);
auVar29 = vcvtph2ps_f16c(auVar9);
auVar9 = *(int1 (*) [16])(lVar20 + lVar12 * lVar1);
auVar45 = vpsrlw_avx(auVar9,4);
auVar3 = *(int1 (*) [16])(lVar20 + lVar15);
auVar46 = vpsrlw_avx(auVar3,4);
auVar25 = vmovdqu64_avx512vl(*(int1 (*) [16])(lVar20 + lVar18));
auVar34 = ZEXT1664(auVar25);
auVar26 = vpsrlw_avx512vl(auVar25,4);
auVar27 = vmovdqu64_avx512vl(*(int1 (*) [16])(lVar20 + lVar24));
auVar28 = vpsrlw_avx512vl(auVar27,4);
uVar2 = *(int4 *)(puVar13 + (ulong)*(ushort *)(pauVar23[-1] + 0x1e) * 4);
auVar11._4_4_ = uVar2;
auVar11._0_4_ = uVar2;
auVar11._8_4_ = uVar2;
auVar11._12_4_ = uVar2;
auVar29 = vmulps_avx512vl(auVar29,auVar11);
auVar30 = vbroadcastss_avx512vl(auVar29);
auVar44._0_16_ = ZEXT116(0) * auVar45 + ZEXT116(1) * auVar9;
auVar44._16_16_ = ZEXT116(1) * auVar45;
auVar44 = vpand_avx2(auVar44,ZEXT1632(auVar26));
auVar33._16_8_ = uVar41;
auVar33._0_16_ = auVar40;
auVar33._24_8_ = uVar42;
auVar33 = vpshufb_avx2(auVar33,auVar44);
auVar10 = vpsignb_avx2(auVar33,auVar33);
auVar44 = *pauVar23;
auVar33 = vpsignb_avx2(auVar44,auVar33);
auVar33 = vpmaddubsw_avx2(auVar10,auVar33);
auVar35 = ZEXT1632(auVar27);
auVar33 = vpmaddwd_avx2(auVar33,auVar35);
auVar33 = vcvtdq2ps_avx(auVar33);
_local_e0 = vfmadd231ps_avx512vl(auVar39._0_32_,auVar30,auVar33);
auVar39 = ZEXT3264(_local_e0);
auVar36 = ZEXT1632(auVar29);
auVar31 = vpermps_avx512vl(ZEXT1632(auVar28),auVar36);
auVar32._0_16_ = ZEXT116(0) * auVar46 + ZEXT116(1) * auVar3;
auVar32._16_16_ = ZEXT116(1) * auVar46;
auVar33 = vpand_avx2(auVar32,ZEXT1632(auVar26));
auVar10._16_8_ = uVar41;
auVar10._0_16_ = auVar40;
auVar10._24_8_ = uVar42;
auVar33 = vpshufb_avx2(auVar10,auVar33);
auVar10 = vpsignb_avx2(auVar33,auVar33);
auVar33 = vpsignb_avx2(auVar44,auVar33);
auVar33 = vpmaddubsw_avx2(auVar10,auVar33);
auVar33 = vpmaddwd_avx2(auVar33,auVar35);
auVar33 = vcvtdq2ps_avx(auVar33);
auVar43 = vfmadd231ps_fma(ZEXT1632(auVar43),auVar31,auVar33);
auVar32 = vpermps_avx512vl(auVar36,auVar36);
auVar33 = vinserti32x4_avx512vl(ZEXT1632(auVar25),auVar26,1);
auVar33 = vpand_avx2(auVar33,ZEXT1632(auVar26));
auVar31._16_8_ = uVar41;
auVar31._0_16_ = auVar40;
auVar31._24_8_ = uVar42;
auVar33 = vpshufb_avx2(auVar31,auVar33);
auVar10 = vpsignb_avx2(auVar33,auVar33);
auVar33 = vpsignb_avx2(auVar44,auVar33);
auVar33 = vpmaddubsw_avx2(auVar10,auVar33);
auVar33 = vpmaddwd_avx2(auVar33,auVar35);
auVar33 = vcvtdq2ps_avx(auVar33);
auVar38 = vfmadd231ps_fma(ZEXT1632(auVar38),auVar32,auVar33);
auVar31 = vpermps_avx512vl(auVar30,auVar36);
auVar33 = vinserti32x4_avx512vl(auVar35,auVar28,1);
auVar33 = vpand_avx2(auVar33,ZEXT1632(auVar26));
auVar30._16_8_ = uVar41;
auVar30._0_16_ = auVar40;
auVar30._24_8_ = uVar42;
auVar33 = vpshufb_avx2(auVar30,auVar33);
auVar10 = vpsignb_avx2(auVar33,auVar33);
auVar44 = vpsignb_avx2(auVar44,auVar33);
auVar44 = vpmaddubsw_avx2(auVar10,auVar44);
auVar44 = vpmaddwd_avx2(auVar44,ZEXT1632(auVar27));
auVar44 = vcvtdq2ps_avx(auVar44);
auVar37 = vfmadd231ps_fma(ZEXT1632(auVar37),auVar31,auVar44);
lVar20 = lVar20 + 0x12;
pauVar23 = (int1 (*) [32])(pauVar23[1] + 2);
lVar22 = lVar22 + -1;
} while (lVar22 != 0);
local_c0 = ZEXT1632(auVar43);
local_a0 = ZEXT1632(auVar38);
local_80 = ZEXT1632(auVar37);
}
lVar20 = 0;
do {
lVar22 = lVar20 * 8;
lVar15 = lVar20 * 8;
auVar38._0_4_ = *(float *)(local_e0 + lVar22 + 0x10) + *(float *)(local_e0 + lVar15);
auVar38._4_4_ = *(float *)(local_c0 + lVar22 + -0xc) + *(float *)(local_e0 + lVar15 + 4);
auVar38._8_4_ = *(float *)(local_c0 + lVar22 + -8) + *(float *)(local_e0 + lVar15 + 8);
auVar38._12_4_ = *(float *)(local_c0 + lVar22 + -4) + *(float *)(local_e0 + lVar15 + 0xc);
auVar43 = vshufpd_avx(auVar38,auVar38,1);
auVar37._0_4_ = auVar38._0_4_ + auVar43._0_4_;
auVar37._4_4_ = auVar38._4_4_ + auVar43._4_4_;
auVar37._8_4_ = auVar38._8_4_ + auVar43._8_4_;
auVar37._12_4_ = auVar38._12_4_ + auVar43._12_4_;
auVar43 = vhaddps_avx(auVar37,auVar37);
*(int *)(lVar7 + lVar17 * lVar8 * 4 + lVar1 * 4 + lVar20) = auVar43._0_4_;
lVar20 = lVar20 + 4;
} while (lVar20 != 0x10);
lVar21 = lVar21 + 1;
} while (lVar21 != lVar14);
}
return;
}
|
|
6,433 | instance_utgarde_pinnacle::instance_utgarde_pinnacle_InstanceMapScript::GetData(unsigned int) const | SylCore-WoTLK/src/server/scripts/Northrend/UtgardeKeep/UtgardePinnacle/instance_utgarde_pinnacle.cpp | uint32 GetData(uint32 type) const override
{
switch (type)
{
case DATA_SVALA_SORROWGRAVE:
return Encounters[0];
case DATA_GORTOK_PALEHOOF:
return Encounters[1];
case DATA_SKADI_THE_RUTHLESS:
return Encounters[2];
case DATA_KING_YMIRON:
return Encounters[3];
case SKADI_HITS:
return SkadiHits;
case SKADI_IN_RANGE:
return SkadiInRange;
}
return 0;
} | O3 | cpp | instance_utgarde_pinnacle::instance_utgarde_pinnacle_InstanceMapScript::GetData(unsigned int) const:
cmpl $0x3, %esi
ja 0x72f268
movl %esi, %eax
leaq 0xb0823c(%rip), %rcx # 0x1237494
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x308(%rdi), %eax
retq
cmpl $0x1e, %esi
je 0x72f27c
xorl %eax, %eax
cmpl $0x1f, %esi
jne 0x72f283
movzbl 0x319(%rdi), %eax
retq
movzbl 0x318(%rdi), %eax
retq
movl 0x310(%rdi), %eax
retq
movl 0x314(%rdi), %eax
retq
movl 0x30c(%rdi), %eax
retq
nop
| _ZNK25instance_utgarde_pinnacle43instance_utgarde_pinnacle_InstanceMapScript7GetDataEj:
cmp esi, 3; switch 4 cases
ja short def_72F25F; jumptable 000000000072F25F default case
mov eax, esi
lea rcx, jpt_72F25F
movsxd rax, ds:(jpt_72F25F - 1237494h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_72F261:
mov eax, [rdi+308h]; jumptable 000000000072F25F case 0
retn
def_72F25F:
cmp esi, 1Eh; jumptable 000000000072F25F default case
jz short loc_72F27C
xor eax, eax
cmp esi, 1Fh
jnz short locret_72F283
movzx eax, byte ptr [rdi+319h]
retn
loc_72F27C:
movzx eax, byte ptr [rdi+318h]
locret_72F283:
retn
loc_72F284:
mov eax, [rdi+310h]; jumptable 000000000072F25F case 2
retn
loc_72F28B:
mov eax, [rdi+314h]; jumptable 000000000072F25F case 3
retn
loc_72F292:
mov eax, [rdi+30Ch]; jumptable 000000000072F25F case 1
retn
| long long instance_utgarde_pinnacle::instance_utgarde_pinnacle_InstanceMapScript::GetData(
instance_utgarde_pinnacle::instance_utgarde_pinnacle_InstanceMapScript *this,
int a2)
{
long long result; // rax
switch ( a2 )
{
case 0:
result = *((unsigned int *)this + 194);
break;
case 1:
result = *((unsigned int *)this + 195);
break;
case 2:
result = *((unsigned int *)this + 196);
break;
case 3:
result = *((unsigned int *)this + 197);
break;
default:
if ( a2 == 30 )
{
result = *((unsigned __int8 *)this + 792);
}
else
{
result = 0LL;
if ( a2 == 31 )
result = *((unsigned __int8 *)this + 793);
}
break;
}
return result;
}
| UpdateAI:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
CALL 0x0072a9ee
MOV RDI,RBX
CALL 0x00a1f646
TEST AL,AL
JZ 0x0072f289
ADD dword ptr [RBX + 0x180],EBP
MOV RAX,qword ptr [RBX + 0x120]
TEST byte ptr [RAX + 0x2781],0x80
JNZ 0x0072f289
MOV RDI,RBX
CALL 0x0072ae8e
TEST AL,AL
JZ 0x0072f294
LAB_0072f289:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0072f294:
LEA R14,[RBX + 0x180]
MOV RDI,R14
CALL 0x011837a8
DEC EAX
CMP EAX,0x6
JA 0x0072f5b3
LEA RCX,[0x131bc54]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX + 0x120]
MOV ESI,0x3b
MOV EDX,0x200000
CALL 0x00b998da
TEST AL,AL
JNZ 0x0072f5a6
MOVSS XMM0,dword ptr [0x0121b118]
MOV RDI,RBX
CALL 0x0072c158
CMP EAX,0x3
JC 0x0072f5a6
MOV RDI,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RDI + 0x568]
LEA RAX,[0x137fde0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP],RAX
MOV EDX,0x101a3
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00c5010e
MOV ESI,0x1770
MOV EDX,0x2710
JMP 0x0072f604
caseD_5:
MOV RDI,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RDI + 0x568]
TEST RSI,RSI
JZ 0x0072f5a6
CALL 0x00b9d7a0
MOVSS XMM1,dword ptr [0x0121b38c]
UCOMISS XMM1,XMM0
JBE 0x0072f5a6
MOV RDI,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RDI + 0x568]
CALL 0x00b9d7a0
UCOMISS XMM0,dword ptr [0x0121b118]
JBE 0x0072f5a6
MOV RDI,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RDI + 0x568]
LEA RAX,[0x137fde0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP],RAX
MOV EDX,0x10282
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00c5010e
MOV ESI,0x7530
JMP 0x0072f4cc
caseD_3:
MOV R15,qword ptr [RBX + 0x120]
MOV RDI,R15
MOV ESI,0x18
CALL 0x00b96762
MOV EBP,EAX
MOV RDI,R15
MOV ESI,0x20
CALL 0x00b96762
MOV EAX,EAX
CVTSI2SS XMM0,RAX
MULSS XMM0,dword ptr [0x0121b030]
DIVSS XMM0,dword ptr [0x0121b034]
CVTTSS2SI RAX,XMM0
CMP EBP,EAX
JNC 0x0072f5c5
MOV RDI,qword ptr [RBX + 0x120]
LEA RAX,[0x137fde0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP],RAX
MOV RSI,RDI
MOV EDX,0x101a9
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00c5010e
MOV ESI,0x15f90
JMP 0x0072f4cc
caseD_4:
MOV RDI,qword ptr [RBX + 0x120]
MOV ESI,0x3b
MOV EDX,0x200000
CALL 0x00b998da
TEST AL,AL
JNZ 0x0072f5a6
MOV RDI,qword ptr [RBX + 0x120]
LEA RAX,[0x137fde0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP],RAX
MOV RSI,RDI
MOV EDX,0x101a4
JMP 0x0072f4ba
caseD_2:
MOVSS XMM0,dword ptr [0x0121b020]
MOV RDI,RBX
MOV ESI,0x2
XOR EDX,EDX
MOV ECX,0x1
MOV R8D,0x1
XOR R9D,R9D
CALL 0x00a22f3a
TEST RAX,RAX
JZ 0x0072f5a6
MOV RDI,qword ptr [RBX + 0x120]
LEA RCX,[0x137fde0]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RSP],RCX
MOV RSI,RAX
MOV EDX,0x101a8
LAB_0072f4ba:
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00c5010e
MOV ESI,0x1d4c0
LAB_0072f4cc:
MOV RDI,R14
CALL 0x01183756
LAB_0072f4d4:
MOV RDI,R14
MOV ESI,0x5dc
XOR EDX,EDX
CALL 0x01183914
JMP 0x0072f5b3
caseD_6:
MOV RDI,qword ptr [RBX + 0x120]
MOV ESI,0x3b
MOV EDX,0x200000
CALL 0x00b998da
TEST AL,AL
JNZ 0x0072f5a6
MOV RDI,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RDI + 0x568]
TEST RSI,RSI
JZ 0x0072f5a6
CALL 0x00b9d7a0
MOVSS XMM1,dword ptr [0x0121b1b4]
UCOMISS XMM1,XMM0
JC 0x0072f5a6
MOV RDI,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RDI + 0x568]
LEA RAX,[0x137fde0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP],RAX
MOV EDX,0x101a2
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00c5010e
MOV ESI,0x1388
JMP 0x0072f4cc
caseD_7:
MOV RDI,qword ptr [RBX + 0x120]
MOV ESI,0x3b
MOV EDX,0x200000
CALL 0x00b998da
TEST AL,AL
JNZ 0x0072f5a6
MOV RDI,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RDI + 0x568]
TEST RSI,RSI
JZ 0x0072f5a6
CALL 0x00b9d7a0
MOVSS XMM1,dword ptr [0x0121b1b4]
UCOMISS XMM1,XMM0
JNC 0x0072f5cc
LAB_0072f5a6:
MOV ESI,0x1388
LAB_0072f5ab:
MOV RDI,R14
CALL 0x01183756
default:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00a22c66
LAB_0072f5c5:
MOV ESI,0x1770
JMP 0x0072f5ab
LAB_0072f5cc:
MOV RDI,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RDI + 0x568]
LEA RAX,[0x137fde0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP],RAX
MOV EDX,0x101a5
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00c5010e
MOV ESI,0x3a98
MOV EDX,0x61a8
LAB_0072f604:
MOV RDI,R14
CALL 0x01183776
JMP 0x0072f4d4
|
/* npc_toc_rogue::npc_toc_rogueAI::UpdateAI(unsigned int) */
void __thiscall npc_toc_rogue::npc_toc_rogueAI::UpdateAI(npc_toc_rogueAI *this,uint param_1)
{
EventMap *this_00;
Object *this_01;
WorldObject *pWVar1;
char cVar2;
int4 uVar3;
uint uVar4;
uint uVar5;
long lVar6;
int8 uVar7;
int8 uVar8;
long lVar9;
float fVar10;
boss_faction_championsAI::UpdateAI((boss_faction_championsAI *)this,param_1);
cVar2 = CreatureAI::UpdateVictim((CreatureAI *)this);
if (((cVar2 == '\0') ||
(*(uint *)(this + 0x180) = *(int *)(this + 0x180) + param_1,
(*(byte *)(*(long *)(this + 0x120) + 0x2781) & 0x80) != 0)) ||
(cVar2 = boss_faction_championsAI::IsCCed((boss_faction_championsAI *)this), cVar2 != '\0')) {
return;
}
this_00 = (EventMap *)(this + 0x180);
uVar3 = EventMap::ExecuteEvent(this_00);
switch(uVar3) {
case 1:
cVar2 = Object::HasFlag(*(Object **)(this + 0x120),0x3b,0x200000);
if ((cVar2 == '\0') &&
(uVar4 = boss_faction_championsAI::EnemiesInRange
((boss_faction_championsAI *)this,DAT_0121b118), 2 < uVar4)) {
Unit::CastSpell(*(long *)(this + 0x120),*(int8 *)(*(long *)(this + 0x120) + 0x568),
0x101a3,0,0,0,ObjectGuid::Empty);
uVar8 = 6000;
uVar7 = 10000;
LAB_0072f604:
EventMap::Repeat(this_00,uVar8,uVar7);
LAB_0072f4d4:
EventMap::DelayEventsToMax(this_00,0x5dc,0);
goto switchD_0072f2bc_default;
}
break;
case 2:
lVar6 = UnitAI::SelectTarget(DAT_0121b020,this,2,0,1,1,0);
if (lVar6 != 0) {
lVar9 = *(long *)(this + 0x120);
uVar7 = 0x101a8;
LAB_0072f4ba:
Unit::CastSpell(lVar9,lVar6,uVar7,0,0,0,ObjectGuid::Empty);
uVar7 = 120000;
LAB_0072f4cc:
EventMap::Repeat(this_00,uVar7);
goto LAB_0072f4d4;
}
break;
case 3:
this_01 = *(Object **)(this + 0x120);
uVar4 = Object::GetUInt32Value(this_01,0x18);
uVar5 = Object::GetUInt32Value(this_01,0x20);
if (uVar4 < (uint)(long)(((float)uVar5 * DAT_0121b030) / DAT_0121b034)) {
Unit::CastSpell(*(int8 *)(this + 0x120),*(int8 *)(this + 0x120),0x101a9,0,0,0,
ObjectGuid::Empty);
uVar7 = 90000;
goto LAB_0072f4cc;
}
uVar7 = 6000;
goto LAB_0072f5ab;
case 4:
cVar2 = Object::HasFlag(*(Object **)(this + 0x120),0x3b,0x200000);
if (cVar2 == '\0') {
lVar6 = *(long *)(this + 0x120);
uVar7 = 0x101a4;
lVar9 = lVar6;
goto LAB_0072f4ba;
}
break;
case 5:
pWVar1 = *(WorldObject **)(*(WorldObject **)(this + 0x120) + 0x568);
if (((pWVar1 != (WorldObject *)0x0) &&
(fVar10 = (float)WorldObject::GetDistance2d(*(WorldObject **)(this + 0x120),pWVar1),
fVar10 < DAT_0121b38c)) &&
(fVar10 = (float)WorldObject::GetDistance2d
(*(WorldObject **)(this + 0x120),
*(WorldObject **)(*(WorldObject **)(this + 0x120) + 0x568)),
DAT_0121b118 < fVar10)) {
Unit::CastSpell(*(long *)(this + 0x120),*(int8 *)(*(long *)(this + 0x120) + 0x568),
0x10282,0,0,0,ObjectGuid::Empty);
uVar7 = 30000;
goto LAB_0072f4cc;
}
break;
case 6:
cVar2 = Object::HasFlag(*(Object **)(this + 0x120),0x3b,0x200000);
if (cVar2 == '\0') {
pWVar1 = *(WorldObject **)(*(WorldObject **)(this + 0x120) + 0x568);
if ((pWVar1 != (WorldObject *)0x0) &&
(fVar10 = (float)WorldObject::GetDistance2d(*(WorldObject **)(this + 0x120),pWVar1),
fVar10 <= DAT_0121b1b4)) {
Unit::CastSpell(*(long *)(this + 0x120),*(int8 *)(*(long *)(this + 0x120) + 0x568),
0x101a2,0,0,0,ObjectGuid::Empty);
uVar7 = 5000;
goto LAB_0072f4cc;
}
}
break;
case 7:
cVar2 = Object::HasFlag(*(Object **)(this + 0x120),0x3b,0x200000);
if (cVar2 == '\0') {
pWVar1 = *(WorldObject **)(*(WorldObject **)(this + 0x120) + 0x568);
if ((pWVar1 != (WorldObject *)0x0) &&
(fVar10 = (float)WorldObject::GetDistance2d(*(WorldObject **)(this + 0x120),pWVar1),
fVar10 <= DAT_0121b1b4)) {
Unit::CastSpell(*(long *)(this + 0x120),*(int8 *)(*(long *)(this + 0x120) + 0x568),
0x101a5,0,0,0,ObjectGuid::Empty);
uVar8 = 15000;
uVar7 = 25000;
goto LAB_0072f604;
}
}
break;
default:
goto switchD_0072f2bc_default;
}
uVar7 = 5000;
LAB_0072f5ab:
EventMap::Repeat(this_00,uVar7);
switchD_0072f2bc_default:
UnitAI::DoMeleeAttackIfReady((UnitAI *)this);
return;
}
|
|
6,434 | get_charset_number | eloqsql/mysys/charset.c | uint get_charset_number(const char *charset_name, uint cs_flags, myf flags)
{
uint id;
const char *new_charset_name= flags & MY_UTF8_IS_UTF8MB3 ? "utf8mb3" :
"utf8mb4";
my_pthread_once(&charsets_initialized, init_available_charsets);
if ((id= get_charset_number_internal(charset_name, cs_flags)))
return id;
if ((charset_name= !my_strcasecmp(&my_charset_latin1, charset_name, "utf8") ?
new_charset_name : NULL))
return get_charset_number_internal(charset_name, cs_flags);
return 0;
} | O0 | c | get_charset_number:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdx
andq $0x400, %rdx # imm = 0x400
leaq 0x7816d(%rip), %rax # 0x1551b2
leaq 0x7815e(%rip), %rcx # 0x1551aa
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq 0xba6975(%rip), %rdi # 0xc839d4
leaq -0x306(%rip), %rsi # 0xdcd60
callq 0x2a240
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xdd100
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xdd087
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xdd0ea
leaq 0x289fe2(%rip), %rax # 0x367070
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rsi
leaq 0x289fcc(%rip), %rdi # 0x367070
leaq 0x7810f(%rip), %rdx # 0x1551ba
callq *%rax
cmpl $0x0, %eax
jne 0xdd0bc
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xdd0c4
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xdd0c4
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xdd0e3
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xdd100
movl %eax, -0x4(%rbp)
jmp 0xdd0ea
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| get_charset_number:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov rdx, [rbp+var_20]
and rdx, 400h
lea rax, aUtf8mb4; "utf8mb4"
lea rcx, aUtf8mb3; "utf8mb3"
cmp rdx, 0
cmovnz rax, rcx
mov [rbp+var_30], rax
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
call get_charset_number_internal
mov [rbp+var_24], eax
cmp eax, 0
jz short loc_DD087
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_DD0EA
loc_DD087:
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rsi, [rbp+var_10]
lea rdi, my_charset_latin1
lea rdx, aUtf8; "utf8"
call rax
cmp eax, 0
jnz short loc_DD0BC
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
jmp short loc_DD0C4
loc_DD0BC:
xor eax, eax
mov [rbp+var_38], rax
jmp short $+2
loc_DD0C4:
mov rax, [rbp+var_38]
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_DD0E3
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
call get_charset_number_internal
mov [rbp+var_4], eax
jmp short loc_DD0EA
loc_DD0E3:
mov [rbp+var_4], 0
loc_DD0EA:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long get_charset_number(long long a1, unsigned int a2, __int16 a3)
{
const char *v3; // rax
const char *v5; // [rsp+8h] [rbp-38h]
const char *v6; // [rsp+10h] [rbp-30h]
unsigned int charset_number_internal; // [rsp+1Ch] [rbp-24h]
v3 = "utf8mb4";
if ( (a3 & 0x400) != 0 )
v3 = "utf8mb3";
v6 = v3;
pthread_once(&charsets_initialized, init_available_charsets);
charset_number_internal = get_charset_number_internal(a1, a2);
if ( charset_number_internal )
{
return charset_number_internal;
}
else
{
if ( (*(unsigned int ( **)(void *, long long, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
a1,
"utf8") )
{
v5 = 0LL;
}
else
{
v5 = v6;
}
if ( v5 )
return (unsigned int)get_charset_number_internal(v5, a2);
else
return 0;
}
}
| get_charset_number:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV RDX,qword ptr [RBP + -0x20]
AND RDX,0x400
LEA RAX,[0x2551b2]
LEA RCX,[0x2551aa]
CMP RDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[0xd839d4]
LEA RSI,[0x1dcd60]
CALL 0x0012a240
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x001dd100
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JZ 0x001dd087
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001dd0ea
LAB_001dd087:
LEA RAX,[0x467070]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[0x467070]
LEA RDX,[0x2551ba]
CALL RAX
CMP EAX,0x0
JNZ 0x001dd0bc
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001dd0c4
LAB_001dd0bc:
XOR EAX,EAX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001dd0c4
LAB_001dd0c4:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x001dd0e3
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x001dd100
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001dd0ea
LAB_001dd0e3:
MOV dword ptr [RBP + -0x4],0x0
LAB_001dd0ea:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int get_charset_number(int8 param_1,int4 param_2,ulong param_3)
{
int iVar1;
char *local_40;
int local_c;
local_40 = "utf8mb4";
if ((param_3 & 0x400) != 0) {
local_40 = "utf8mb3";
}
pthread_once(&charsets_initialized,init_available_charsets);
local_c = get_charset_number_internal(param_1,param_2);
if (local_c == 0) {
iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_00467130 + 0x40))
(&my_charset_latin1,param_1,&DAT_002551ba);
if (iVar1 != 0) {
local_40 = (char *)0x0;
}
if (local_40 == (char *)0x0) {
local_c = 0;
}
else {
local_c = get_charset_number_internal(local_40,param_2);
}
}
return local_c;
}
|
|
6,435 | ft_make_key | eloqsql/storage/myisam/ft_update.c | uint _ft_make_key(MI_INFO *info, uint keynr, uchar *keybuf, FT_WORD *wptr,
my_off_t filepos)
{
uchar buf[HA_FT_MAXBYTELEN+16];
float weight=(float) ((filepos==HA_OFFSET_ERROR) ? 0 : wptr->weight);
DBUG_ENTER("_ft_make_key");
mi_float4store(buf,weight);
int2store(buf+HA_FT_WLEN,wptr->len);
memcpy(buf+HA_FT_WLEN+2,wptr->pos,wptr->len);
DBUG_RETURN(_mi_make_key(info,keynr,(uchar*) keybuf,buf,filepos));
} | O3 | c | ft_make_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, %r8
je 0x776c1
cvtsd2ss 0x8(%rcx), %xmm0
movd %xmm0, %eax
jmp 0x776c3
xorl %eax, %eax
bswapl %eax
leaq -0x13a(%rbp), %rdi
movl %eax, -0x6(%rdi)
movq 0x10(%rcx), %rdx
movw %dx, -0x2(%rdi)
movq (%rcx), %rsi
movl $0x108, %ecx # imm = 0x108
callq 0x293f0
leaq -0x140(%rbp), %rcx
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %rbx, %r8
callq 0x7e050
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x7771b
addq $0x120, %rsp # imm = 0x120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29240
| _ft_make_key:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 120h
mov rbx, r8
mov r14, rdx
mov r15d, esi
mov r12, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
cmp r8, 0FFFFFFFFFFFFFFFFh
jz short loc_776C1
cvtsd2ss xmm0, qword ptr [rcx+8]
movd eax, xmm0
jmp short loc_776C3
loc_776C1:
xor eax, eax
loc_776C3:
bswap eax
lea rdi, [rbp+var_13A]
mov [rdi-6], eax
mov rdx, [rcx+10h]
mov [rdi-2], dx
mov rsi, [rcx]
mov ecx, 108h
call ___memcpy_chk
lea rcx, [rbp+var_140]
mov rdi, r12
mov esi, r15d
mov rdx, r14
mov r8, rbx
call _mi_make_key
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_7771B
add rsp, 120h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_7771B:
call ___stack_chk_fail
| long long ft_make_key(long long a1, unsigned int a2, long long a3, long long a4, long long a5, __m128i a6)
{
unsigned int v8; // eax
long long v9; // rdx
unsigned __int32 v11; // [rsp+0h] [rbp-140h] BYREF
__int16 v12; // [rsp+4h] [rbp-13Ch]
_BYTE v13[274]; // [rsp+6h] [rbp-13Ah] BYREF
unsigned long long v14; // [rsp+118h] [rbp-28h]
v14 = __readfsqword(0x28u);
if ( a5 == -1 )
{
v8 = 0;
}
else
{
*(float *)a6.m128i_i32 = *(double *)(a4 + 8);
v8 = _mm_cvtsi128_si32(a6);
}
v11 = _byteswap_ulong(v8);
v9 = *(_QWORD *)(a4 + 16);
v12 = v9;
__memcpy_chk(v13, *(_QWORD *)a4, v9, 264LL);
return mi_make_key(a1, a2, a3, &v11, a5);
}
| _ft_make_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x120
MOV RBX,R8
MOV R14,RDX
MOV R15D,ESI
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
CMP R8,-0x1
JZ 0x001776c1
CVTSD2SS XMM0,qword ptr [RCX + 0x8]
MOVD EAX,XMM0
JMP 0x001776c3
LAB_001776c1:
XOR EAX,EAX
LAB_001776c3:
BSWAP EAX
LEA RDI,[RBP + -0x13a]
MOV dword ptr [RDI + -0x6],EAX
MOV RDX,qword ptr [RCX + 0x10]
MOV word ptr [RDI + -0x2],DX
MOV RSI,qword ptr [RCX]
MOV ECX,0x108
CALL 0x001293f0
LEA RCX,[RBP + -0x140]
MOV RDI,R12
MOV ESI,R15D
MOV RDX,R14
MOV R8,RBX
CALL 0x0017e050
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x0017771b
ADD RSP,0x120
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0017771b:
CALL 0x00129240
|
void _ft_make_key(int8 param_1,int4 param_2,int8 param_3,int8 *param_4,
long param_5)
{
long in_FS_OFFSET;
float fVar1;
uint local_148;
int2 local_144;
int1 local_142 [274];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_5 == -1) {
fVar1 = 0.0;
}
else {
fVar1 = (float)(double)param_4[1];
}
local_148 = (uint)fVar1 >> 0x18 | ((uint)fVar1 & 0xff0000) >> 8 | ((uint)fVar1 & 0xff00) << 8 |
(int)fVar1 << 0x18;
local_144 = (int2)param_4[2];
__memcpy_chk(local_142,*param_4,param_4[2],0x108);
_mi_make_key(param_1,param_2,param_3,&local_148,param_5);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
6,436 | my_fstat | eloqsql/mysys/my_lib.c | int my_fstat(File Filedes, MY_STAT *stat_area,
myf MyFlags __attribute__((unused)))
{
DBUG_ENTER("my_fstat");
DBUG_PRINT("my",("fd: %d MyFlags: %lu", Filedes, MyFlags));
#ifdef _WIN32
DBUG_RETURN(my_win_fstat(Filedes, stat_area));
#elif defined HAVE_valgrind
{
int s= fstat(Filedes, stat_area);
if (!s)
MSAN_STAT_WORKAROUND(stat_area);
DBUG_RETURN(s);
}
#else
DBUG_RETURN(fstat(Filedes, (struct stat *) stat_area));
#endif
} | O0 | c | my_fstat:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x65445
jmp 0x65447
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x265f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| my_fstat:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_65445:
jmp short $+2
loc_65447:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call _fstat64
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
add rsp, 20h
pop rbp
retn
| long long my_fstat(unsigned int a1, long long a2)
{
return (unsigned int)fstat64(a1, a2);
}
| my_fstat:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x00165445
LAB_00165445:
JMP 0x00165447
LAB_00165447:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001265f0
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD RSP,0x20
POP RBP
RET
|
int my_fstat(int param_1,stat64 *param_2)
{
int iVar1;
iVar1 = fstat64(param_1,param_2);
return iVar1;
}
|
|
6,437 | testing::internal::SuiteApiResolver<alaya::LinearPoolTest>::GetTearDownCaseOrSuite(char const*, int) | AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
SetUpTearDownSuiteFuncType test_suite_fp =
GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
GTEST_CHECK_(!test_case_fp || !test_suite_fp)
<< "Test can not provide both TearDownTestSuite and TearDownTestCase,"
" please make sure there is only one present at"
<< filename << ":" << line_num;
return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
#else
(void)(filename);
(void)(line_num);
return &T::TearDownTestSuite;
#endif
} | O0 | c | testing::internal::SuiteApiResolver<alaya::LinearPoolTest>::GetTearDownCaseOrSuite(char const*, int):
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
leaq 0x40ec(%rip), %rsi # 0x1ea20
movq %rsi, %rdi
callq 0x1e9c0
movq %rax, 0x50(%rsp)
leaq 0x40e8(%rip), %rsi # 0x1ea30
movq %rsi, %rdi
callq 0x1e9c0
movq %rax, 0x48(%rsp)
movb $0x1, %al
cmpq $0x0, 0x50(%rsp)
movb %al, 0x33(%rsp)
je 0x1a972
cmpq $0x0, 0x48(%rsp)
setne %al
xorb $-0x1, %al
movb %al, 0x33(%rsp)
movb 0x33(%rsp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0xb38e0
testb $0x1, %al
jne 0x1a987
jmp 0x1a98c
jmp 0x1aa48
leaq 0xf188c(%rip), %rdx # 0x10c21f
leaq 0x44(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x3, %esi
movl $0x216, %ecx # imm = 0x216
callq 0xb9070
movq 0x20(%rsp), %rdi
callq 0x1ea10
movq %rax, %rdi
leaq 0xf18db(%rip), %rsi # 0x10c29b
callq 0x146a0
movq %rax, 0x28(%rsp)
jmp 0x1a9cc
movq 0x28(%rsp), %rdi
leaq 0xf1961(%rip), %rsi # 0x10c339
callq 0x146a0
movq %rax, 0x18(%rsp)
jmp 0x1a9e4
movq 0x18(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x146a0
movq %rax, 0x10(%rsp)
jmp 0x1a9fa
movq 0x10(%rsp), %rdi
leaq 0xf958e(%rip), %rsi # 0x113f94
callq 0x146a0
movq %rax, 0x8(%rsp)
jmp 0x1aa12
movq 0x8(%rsp), %rdi
movl 0x5c(%rsp), %esi
callq 0x14c50
jmp 0x1aa22
leaq 0x44(%rsp), %rdi
callq 0xb91e0
jmp 0x1aa48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x44(%rsp), %rdi
callq 0xb91e0
jmp 0x1aa6d
cmpq $0x0, 0x50(%rsp)
je 0x1aa5b
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
jmp 0x1aa64
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x14c80
nopw (%rax,%rax)
| _ZN7testing8internal16SuiteApiResolverIN5alaya14LinearPoolTestEE22GetTearDownCaseOrSuiteEPKci:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_C], esi
lea rsi, _ZN7testing4Test16TearDownTestCaseEv; void (*)(void)
mov rdi, rsi; this
call _ZN7testing8internal19GetNotDefaultOrNullEPFvvES2_; testing::internal::GetNotDefaultOrNull(void (*)(void),void (*)(void))
mov [rsp+68h+var_18], rax
lea rsi, _ZN7testing4Test17TearDownTestSuiteEv; bool
mov rdi, rsi; this
call _ZN7testing8internal19GetNotDefaultOrNullEPFvvES2_; testing::internal::GetNotDefaultOrNull(void (*)(void),void (*)(void))
mov qword ptr [rsp+68h+var_20], rax; char
mov al, 1
cmp [rsp+68h+var_18], 0
mov [rsp+68h+var_35], al
jz short loc_1A972
cmp qword ptr [rsp+68h+var_20], 0
setnz al
xor al, 0FFh
mov [rsp+68h+var_35], al
loc_1A972:
mov al, [rsp+68h+var_35]
movzx edi, al
and edi, 1; this
call _ZN7testing8internal6IsTrueEb; testing::internal::IsTrue(bool)
test al, 1
jnz short loc_1A987
jmp short loc_1A98C
loc_1A987:
jmp loc_1AA48
loc_1A98C:
lea rdx, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+68h+var_24]; int
mov [rsp+68h+var_48], rdi; int
mov esi, 3
mov ecx, 216h
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, [rsp+68h+var_48]; this
call _ZN7testing8internal8GTestLog9GetStreamEv; testing::internal::GTestLog::GetStream(void)
mov rdi, rax
lea rsi, aConditionTestC; "Condition !test_case_fp || !test_suite_"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+68h+var_40], rax
jmp short $+2
loc_1A9CC:
mov rdi, [rsp+68h+var_40]
lea rsi, aTestCanNotProv_0; "Test can not provide both TearDownTestS"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+68h+var_50], rax
jmp short $+2
loc_1A9E4:
mov rdi, [rsp+68h+var_50]
mov rsi, [rsp+68h+var_8]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+68h+var_58], rax
jmp short $+2
loc_1A9FA:
mov rdi, [rsp+68h+var_58]
lea rsi, aTrace+6; ":"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+68h+var_60], rax
jmp short $+2
loc_1AA12:
mov rdi, [rsp+68h+var_60]
mov esi, [rsp+68h+var_C]
call __ZNSolsEi; std::ostream::operator<<(int)
jmp short $+2
loc_1AA22:
lea rdi, [rsp+68h+var_24]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_1AA48
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_3C]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_1AA6D
loc_1AA48:
cmp [rsp+68h+var_18], 0
jz short loc_1AA5B
mov rax, [rsp+68h+var_18]
mov [rsp+68h+var_68], rax
jmp short loc_1AA64
loc_1AA5B:
mov rax, qword ptr [rsp+68h+var_20]
mov [rsp+68h+var_68], rax
loc_1AA64:
mov rax, [rsp+68h+var_68]
add rsp, 68h
retn
loc_1AA6D:
mov rdi, [rsp+arg_30]
call __Unwind_Resume
| long long testing::internal::SuiteApiResolver<alaya::LinearPoolTest>::GetTearDownCaseOrSuite(
long long a1,
unsigned int a2,
void (*a3)(void))
{
void (*v3)(void); // rdx
long long Stream; // rax
int v6; // [rsp+0h] [rbp-68h]
int v8; // [rsp+8h] [rbp-60h]
long long v9; // [rsp+8h] [rbp-60h]
int v10; // [rsp+10h] [rbp-58h]
long long v11; // [rsp+10h] [rbp-58h]
int v12; // [rsp+18h] [rbp-50h]
long long v13; // [rsp+18h] [rbp-50h]
testing::internal::GTestLog *v14; // [rsp+20h] [rbp-48h]
int v15; // [rsp+28h] [rbp-40h]
long long v16; // [rsp+28h] [rbp-40h]
int v17; // [rsp+30h] [rbp-38h]
int v18; // [rsp+38h] [rbp-30h]
long long v19; // [rsp+40h] [rbp-28h] BYREF
char v20[8]; // [rsp+48h] [rbp-20h]
long long NotDefaultOrNull; // [rsp+50h] [rbp-18h]
unsigned int v22; // [rsp+5Ch] [rbp-Ch]
long long v23; // [rsp+60h] [rbp-8h]
v23 = a1;
v22 = a2;
NotDefaultOrNull = testing::internal::GetNotDefaultOrNull(
(testing::internal *)testing::Test::TearDownTestCase,
(void (*)(void))testing::Test::TearDownTestCase,
a3);
*(_QWORD *)v20 = testing::internal::GetNotDefaultOrNull(
(testing::internal *)testing::Test::TearDownTestSuite,
(void (*)(void))testing::Test::TearDownTestSuite,
v3);
HIBYTE(v17) = 1;
if ( NotDefaultOrNull )
HIBYTE(v17) = ~(*(_QWORD *)v20 != 0LL);
if ( (testing::internal::IsTrue((testing::internal *)(HIBYTE(v17) & 1), (bool)testing::Test::TearDownTestSuite) & 1) == 0 )
{
testing::internal::GTestLog::GTestLog((int)&v19 + 4, v6, v8, v10, v12, (int)&v19 + 4, v15, v17, v18, v19, v20[0]);
Stream = testing::internal::GTestLog::GetStream(v14);
v16 = std::operator<<<std::char_traits<char>>(Stream, "Condition !test_case_fp || !test_suite_fp failed. ");
v13 = std::operator<<<std::char_traits<char>>(
v16,
"Test can not provide both TearDownTestSuite and TearDownTestCase, please make sure there is only one present at");
v11 = std::operator<<<std::char_traits<char>>(v13, v23);
v9 = std::operator<<<std::char_traits<char>>(v11, ":");
std::ostream::operator<<(v9, v22);
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)((char *)&v19 + 4));
}
if ( NotDefaultOrNull )
return NotDefaultOrNull;
else
return *(_QWORD *)v20;
}
| GetTearDownCaseOrSuite:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV dword ptr [RSP + 0x5c],ESI
LEA RSI,[0x11ea20]
MOV RDI,RSI
CALL 0x0011e9c0
MOV qword ptr [RSP + 0x50],RAX
LEA RSI,[0x11ea30]
MOV RDI,RSI
CALL 0x0011e9c0
MOV qword ptr [RSP + 0x48],RAX
MOV AL,0x1
CMP qword ptr [RSP + 0x50],0x0
MOV byte ptr [RSP + 0x33],AL
JZ 0x0011a972
CMP qword ptr [RSP + 0x48],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RSP + 0x33],AL
LAB_0011a972:
MOV AL,byte ptr [RSP + 0x33]
MOVZX EDI,AL
AND EDI,0x1
CALL 0x001b38e0
TEST AL,0x1
JNZ 0x0011a987
JMP 0x0011a98c
LAB_0011a987:
JMP 0x0011aa48
LAB_0011a98c:
LEA RDX,[0x20c21f]
LEA RDI,[RSP + 0x44]
MOV qword ptr [RSP + 0x20],RDI
MOV ESI,0x3
MOV ECX,0x216
CALL 0x001b9070
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0011ea10
MOV RDI,RAX
LAB_0011a9b9:
LEA RSI,[0x20c29b]
CALL 0x001146a0
MOV qword ptr [RSP + 0x28],RAX
JMP 0x0011a9cc
LAB_0011a9cc:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x20c339]
CALL 0x001146a0
MOV qword ptr [RSP + 0x18],RAX
JMP 0x0011a9e4
LAB_0011a9e4:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x60]
CALL 0x001146a0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0011a9fa
LAB_0011a9fa:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[0x213f94]
CALL 0x001146a0
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0011aa12
LAB_0011aa12:
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSP + 0x5c]
CALL 0x00114c50
LAB_0011aa20:
JMP 0x0011aa22
LAB_0011aa22:
LEA RDI,[RSP + 0x44]
CALL 0x001b91e0
JMP 0x0011aa48
LAB_0011aa48:
CMP qword ptr [RSP + 0x50],0x0
JZ 0x0011aa5b
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP],RAX
JMP 0x0011aa64
LAB_0011aa5b:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP],RAX
LAB_0011aa64:
MOV RAX,qword ptr [RSP]
ADD RSP,0x68
RET
|
/* testing::internal::SuiteApiResolver<alaya::LinearPoolTest>::GetTearDownCaseOrSuite(char const*,
int) */
long testing::internal::SuiteApiResolver<alaya::LinearPoolTest>::GetTearDownCaseOrSuite
(char *param_1,int param_2)
{
ulong uVar1;
ostream *poVar2;
long local_68;
byte local_35;
GTestLog local_24 [4];
long local_20;
long local_18;
int local_c;
char *local_8;
local_c = param_2;
local_8 = param_1;
local_18 = GetNotDefaultOrNull(Test::TearDownTestCase,Test::TearDownTestCase);
local_20 = GetNotDefaultOrNull(Test::TearDownTestSuite,Test::TearDownTestSuite);
local_35 = 1;
if (local_18 != 0) {
local_35 = local_20 != 0 ^ 0xff;
}
uVar1 = IsTrue((bool)(local_35 & 1));
if ((uVar1 & 1) == 0) {
GTestLog::GTestLog(local_24,3,
"/workspace/llm4binary/github2025/AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h"
,0x216);
poVar2 = (ostream *)GTestLog::GetStream();
/* try { // try from 0011a9b9 to 0011aa1f has its CatchHandler @ 0011aa2e */
poVar2 = std::operator<<(poVar2,"Condition !test_case_fp || !test_suite_fp failed. ");
poVar2 = std::operator<<(poVar2,
"Test can not provide both TearDownTestSuite and TearDownTestCase, please make sure there is only one present at"
);
poVar2 = std::operator<<(poVar2,local_8);
poVar2 = std::operator<<(poVar2,":");
std::ostream::operator<<(poVar2,local_c);
GTestLog::~GTestLog(local_24);
}
if (local_18 == 0) {
local_68 = local_20;
}
else {
local_68 = local_18;
}
return local_68;
}
|
|
6,438 | testing::internal::SuiteApiResolver<FindPeaksCppTest>::GetSetUpCaseOrSuite(char const*, int) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearDownSuiteFuncType test_suite_fp =
GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);
GTEST_CHECK_(!test_case_fp || !test_suite_fp)
<< "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
"make sure there is only one present at "
<< filename << ":" << line_num;
return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
#else
(void)(filename);
(void)(line_num);
return &T::SetUpTestSuite;
#endif
} | O1 | c | testing::internal::SuiteApiResolver<FindPeaksCppTest>::GetSetUpCaseOrSuite(char const*, int):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x11be8
testb %al, %al
jne 0xd663
leaq 0x32e79(%rip), %rdx # 0x4042c
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x201, %ecx # imm = 0x201
callq 0x16e72
movq 0x4ba1a(%rip), %rdi # 0x58fe8
leaq 0x32ee6(%rip), %rsi # 0x404bb
movl $0x32, %edx
callq 0x85b0
movq 0x4ba02(%rip), %r15 # 0x58fe8
leaq 0x32f01(%rip), %rsi # 0x404ee
movl $0x6a, %edx
movq %r15, %rdi
callq 0x85b0
testq %r14, %r14
je 0xd61b
movq %r14, %rdi
callq 0x8200
movq 0x4b9da(%rip), %rdi # 0x58fe8
movq %r14, %rsi
movq %rax, %rdx
callq 0x85b0
jmp 0xd633
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x8930
movq 0x4b9ae(%rip), %rdi # 0x58fe8
leaq 0x36190(%rip), %rsi # 0x437d1
movl $0x1, %edx
callq 0x85b0
movq 0x4b996(%rip), %rdi # 0x58fe8
movl %ebx, %esi
callq 0x8950
leaq 0xc(%rsp), %rdi
callq 0x16fb4
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x16fb4
movq %rbx, %rdi
callq 0x8990
| _ZN7testing8internal16SuiteApiResolverI16FindPeaksCppTestE19GetSetUpCaseOrSuiteEPKci:
push r15
push r14
push rbx
sub rsp, 10h
mov ebx, esi
mov r14, rdi
mov edi, (offset dword_0+1); this
call _ZN7testing8internal6IsTrueEb; testing::internal::IsTrue(bool)
test al, al
jnz loc_D663
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rsp+28h+var_1C]
mov esi, 3
mov ecx, 201h
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aConditionTestC; "Condition !test_case_fp || !test_suite_"...
mov edx, 32h ; '2'
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r15, cs:_ZSt4cerr_ptr
lea rsi, aTestCanNotProv; "Test can not provide both SetUpTestSuit"...
mov edx, 6Ah ; 'j'
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
test r14, r14
jz short loc_D61B
mov rdi, r14
call _strlen
mov rdi, cs:_ZSt4cerr_ptr
mov rsi, r14
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_D633
loc_D61B:
mov rax, [r15]
mov rax, [rax-18h]
lea rdi, [r15+rax]
mov esi, [r15+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_D633:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aTrace+6; ":"
mov edx, 1
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, cs:_ZSt4cerr_ptr
mov esi, ebx
call __ZNSolsEi; std::ostream::operator<<(int)
lea rdi, [rsp+28h+var_1C]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
loc_D663:
xor eax, eax
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_4]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::SuiteApiResolver<FindPeaksCppTest>::GetSetUpCaseOrSuite(long long a1, BOOL a2)
{
long long v2; // rax
_BYTE v4[28]; // [rsp+Ch] [rbp-1Ch] BYREF
if ( !(unsigned __int8)testing::internal::IsTrue((testing::internal *)((char *)&dword_0 + 1), a2) )
{
testing::internal::GTestLog::GTestLog(
v4,
3LL,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/include/gte"
"st/internal/gtest-internal.h",
513LL);
std::__ostream_insert<char,std::char_traits<char>>(
&std::cerr,
"Condition !test_case_fp || !test_suite_fp failed. ",
50LL);
std::__ostream_insert<char,std::char_traits<char>>(
&std::cerr,
"Test can not provide both SetUpTestSuite and SetUpTestCase, please make sure there is only one present at ",
106LL);
if ( a1 )
{
v2 = strlen(a1);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, a1, v2);
}
else
{
std::ios::clear(
(char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL),
*(_DWORD *)((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL) + 32) | 1u);
}
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, ":", 1LL);
std::ostream::operator<<(&std::cerr, a2);
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)v4);
}
return 0LL;
}
| GetSetUpCaseOrSuite:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EBX,ESI
MOV R14,RDI
MOV EDI,0x1
CALL 0x00111be8
TEST AL,AL
JNZ 0x0010d663
LEA RDX,[0x14042c]
LEA RDI,[RSP + 0xc]
MOV ESI,0x3
MOV ECX,0x201
CALL 0x00116e72
LAB_0010d5c7:
MOV RDI,qword ptr [0x00158fe8]
LEA RSI,[0x1404bb]
MOV EDX,0x32
CALL 0x001085b0
MOV R15,qword ptr [0x00158fe8]
LEA RSI,[0x1404ee]
MOV EDX,0x6a
MOV RDI,R15
CALL 0x001085b0
TEST R14,R14
JZ 0x0010d61b
MOV RDI,R14
CALL 0x00108200
MOV RDI,qword ptr [0x00158fe8]
MOV RSI,R14
MOV RDX,RAX
CALL 0x001085b0
JMP 0x0010d633
LAB_0010d61b:
MOV RAX,qword ptr [R15]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[R15 + RAX*0x1]
MOV ESI,dword ptr [R15 + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00108930
LAB_0010d633:
MOV RDI,qword ptr [0x00158fe8]
LEA RSI,[0x1437d1]
MOV EDX,0x1
CALL 0x001085b0
MOV RDI,qword ptr [0x00158fe8]
MOV ESI,EBX
CALL 0x00108950
LAB_0010d659:
LEA RDI,[RSP + 0xc]
CALL 0x00116fb4
LAB_0010d663:
XOR EAX,EAX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* testing::internal::SuiteApiResolver<FindPeaksCppTest>::GetSetUpCaseOrSuite(char const*, int) */
int8
testing::internal::SuiteApiResolver<FindPeaksCppTest>::GetSetUpCaseOrSuite
(char *param_1,int param_2)
{
int *puVar1;
char cVar2;
size_t sVar3;
GTestLog local_1c [4];
cVar2 = IsTrue(true);
if (cVar2 == '\0') {
GTestLog::GTestLog(local_1c,3,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h"
,0x201);
/* try { // try from 0010d5c7 to 0010d658 has its CatchHandler @ 0010d66f */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,"Condition !test_case_fp || !test_suite_fp failed. ",
0x32);
puVar1 = PTR_cerr_00158fe8;
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,
"Test can not provide both SetUpTestSuite and SetUpTestCase, please make sure there is only one present at "
,0x6a);
if (param_1 == (char *)0x0) {
std::ios::clear(puVar1 + *(long *)(*(long *)puVar1 + -0x18),
*(uint *)(puVar1 + *(long *)(*(long *)puVar1 + -0x18) + 0x20) | 1);
}
else {
sVar3 = strlen(param_1);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_00158fe8,param_1,sVar3)
;
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_00158fe8,":",1);
std::ostream::operator<<((ostream *)PTR_cerr_00158fe8,param_2);
GTestLog::~GTestLog(local_1c);
}
return 0;
}
|
|
6,439 | wt_thd_release_self | eloqsql/storage/maria/trnman.c | static void wt_thd_release_self(TRN *trn)
{
if (trn->wt)
{
WT_RESOURCE_ID rc;
rc.type= &ma_rc_dup_unique;
rc.value= (intptr)trn;
wt_thd_release(trn->wt, & rc);
trn->wt= 0;
}
} | O0 | c | wt_thd_release_self:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x934f7
leaq 0x26b99a(%rip), %rax # 0x2fee68
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x134b20
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| wt_thd_release_self:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+8], 0
jz short loc_934F7
lea rax, ma_rc_dup_unique
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rdi, [rax+8]
lea rsi, [rbp+var_18]
call wt_thd_release
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
loc_934F7:
add rsp, 20h
pop rbp
retn
| long long wt_thd_release_self(long long a1)
{
long long result; // rax
_QWORD v2[2]; // [rsp+8h] [rbp-18h] BYREF
long long v3; // [rsp+18h] [rbp-8h]
v3 = a1;
result = a1;
if ( *(_QWORD *)(a1 + 8) )
{
v2[1] = &ma_rc_dup_unique;
v2[0] = v3;
wt_thd_release(*(_QWORD *)(v3 + 8), v2);
result = v3;
*(_QWORD *)(v3 + 8) = 0LL;
}
return result;
}
| wt_thd_release_self:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x001934f7
LEA RAX,[0x3fee68]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RBP + -0x18]
CALL 0x00234b20
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],0x0
LAB_001934f7:
ADD RSP,0x20
POP RBP
RET
|
void wt_thd_release_self(long param_1)
{
long local_20;
int1 *local_18;
long local_10;
if (*(long *)(param_1 + 8) != 0) {
local_18 = ma_rc_dup_unique;
local_20 = param_1;
local_10 = param_1;
wt_thd_release(*(int8 *)(param_1 + 8),&local_20);
*(int8 *)(local_10 + 8) = 0;
}
return;
}
|
|
6,440 | set_object_name_computed | bluesky950520[P]quickjs/quickjs.c | static void set_object_name_computed(JSParseState *s)
{
JSFunctionDef *fd = s->cur_func;
int opcode;
opcode = get_prev_opcode(fd);
if (opcode == OP_set_name) {
/* XXX: should free atom after OP_set_name? */
fd->byte_code.size = fd->last_opcode_pos;
fd->last_opcode_pos = -1;
emit_op(s, OP_set_name_computed);
} else if (opcode == OP_set_class_name) {
int define_class_pos;
define_class_pos = fd->last_opcode_pos + 1 -
get_u32(fd->byte_code.buf + fd->last_opcode_pos + 1);
assert(fd->byte_code.buf[define_class_pos] == OP_define_class);
fd->byte_code.buf[define_class_pos] = OP_define_class_computed;
fd->last_opcode_pos = -1;
}
} | O1 | c | set_object_name_computed:
movq 0x90(%rdi), %rdi
movslq 0x168(%rdi), %rax
testq %rax, %rax
js 0x6e758
movq 0x138(%rdi), %rcx
movb (%rcx,%rax), %cl
jmp 0x6e75a
xorl %ecx, %ecx
cmpb $-0x3d, %cl
je 0x6e785
movzbl %cl, %ecx
cmpl $0x4d, %ecx
jne 0x6e7a4
movq %rax, 0x140(%rdi)
movl %eax, 0x168(%rdi)
addq $0x138, %rdi # imm = 0x138
movl $0x4e, %esi
jmp 0x1f52c
movq 0x138(%rdi), %rcx
movl 0x1(%rcx,%rax), %edx
subl %edx, %eax
incl %eax
cltq
movb $0x57, (%rcx,%rax)
movl $0xffffffff, 0x168(%rdi) # imm = 0xFFFFFFFF
retq
| set_object_name_computed:
mov rdi, [rdi+90h]
movsxd rax, dword ptr [rdi+168h]
test rax, rax
js short loc_6E758
mov rcx, [rdi+138h]
mov cl, [rcx+rax]
jmp short loc_6E75A
loc_6E758:
xor ecx, ecx
loc_6E75A:
cmp cl, 0C3h
jz short loc_6E785
movzx ecx, cl
cmp ecx, 4Dh ; 'M'
jnz short locret_6E7A4
mov [rdi+140h], rax
mov [rdi+168h], eax
add rdi, 138h
mov esi, 4Eh ; 'N'
jmp dbuf_putc
loc_6E785:
mov rcx, [rdi+138h]
mov edx, [rcx+rax+1]
sub eax, edx
inc eax
cdqe
mov byte ptr [rcx+rax], 57h ; 'W'
mov dword ptr [rdi+168h], 0FFFFFFFFh
locret_6E7A4:
retn
| long long set_object_name_computed(long long a1)
{
long long v1; // rdi
long long result; // rax
char v3; // cl
long long v4; // rcx
v1 = *(_QWORD *)(a1 + 144);
result = *(int *)(v1 + 360);
if ( result < 0 )
v3 = 0;
else
v3 = *(_BYTE *)(*(_QWORD *)(v1 + 312) + result);
if ( v3 == -61 )
{
v4 = *(_QWORD *)(v1 + 312);
result = (int)result - *(_DWORD *)(v4 + result + 1) + 1;
*(_BYTE *)(v4 + (int)result) = 87;
*(_DWORD *)(v1 + 360) = -1;
}
else if ( v3 == 77 )
{
*(_QWORD *)(v1 + 320) = result;
*(_DWORD *)(v1 + 360) = result;
return dbuf_putc((_QWORD *)(v1 + 312), 78);
}
return result;
}
| set_object_name_computed:
MOV RDI,qword ptr [RDI + 0x90]
MOVSXD RAX,dword ptr [RDI + 0x168]
TEST RAX,RAX
JS 0x0016e758
MOV RCX,qword ptr [RDI + 0x138]
MOV CL,byte ptr [RCX + RAX*0x1]
JMP 0x0016e75a
LAB_0016e758:
XOR ECX,ECX
LAB_0016e75a:
CMP CL,0xc3
JZ 0x0016e785
MOVZX ECX,CL
CMP ECX,0x4d
JNZ 0x0016e7a4
MOV qword ptr [RDI + 0x140],RAX
MOV dword ptr [RDI + 0x168],EAX
ADD RDI,0x138
MOV ESI,0x4e
JMP 0x0011f52c
LAB_0016e785:
MOV RCX,qword ptr [RDI + 0x138]
MOV EDX,dword ptr [RCX + RAX*0x1 + 0x1]
SUB EAX,EDX
INC EAX
CDQE
MOV byte ptr [RCX + RAX*0x1],0x57
MOV dword ptr [RDI + 0x168],0xffffffff
LAB_0016e7a4:
RET
|
void set_object_name_computed(long param_1)
{
int iVar1;
long lVar2;
long lVar3;
char cVar4;
lVar2 = *(long *)(param_1 + 0x90);
iVar1 = *(int *)(lVar2 + 0x168);
lVar3 = (long)iVar1;
if (lVar3 < 0) {
cVar4 = '\0';
}
else {
cVar4 = *(char *)(*(long *)(lVar2 + 0x138) + lVar3);
}
if (cVar4 == -0x3d) {
*(int1 *)
(*(long *)(lVar2 + 0x138) +
(long)((iVar1 - *(int *)(*(long *)(lVar2 + 0x138) + 1 + lVar3)) + 1)) = 0x57;
*(int4 *)(lVar2 + 0x168) = 0xffffffff;
}
else if (cVar4 == 'M') {
*(long *)(lVar2 + 0x140) = lVar3;
*(int *)(lVar2 + 0x168) = iVar1;
dbuf_putc(lVar2 + 0x138,0x4e);
return;
}
return;
}
|
|
6,441 | uf_zerofill_skip_zero | eloqsql/storage/myisam/mi_packrec.c | static void uf_zerofill_skip_zero(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bzero((char*) to,(uint) (end-to));
else
{
end-=rec->space_length_bits;
decode_bytes(rec,bit_buff,to,end);
bzero((char*) end,rec->space_length_bits);
}
} | O0 | c | uf_zerofill_skip_zero:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xbdb17
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0xbdb3b
jmp 0xbdb57
movq -0x10(%rbp), %rdi
callq 0xbd670
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xbdb57
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2c0
jmp 0xbdb9b
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xbdd80
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| uf_zerofill_skip_zero_0:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_BDB17
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_BDB3B
jmp short loc_BDB57
loc_BDB17:
mov rdi, [rbp+var_10]
call fill_buffer_0
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz short loc_BDB57
loc_BDB3B:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
jmp short loc_BDB9B
loc_BDB57:
mov rax, [rbp+var_8]
mov ecx, [rax+1Ch]
mov rax, [rbp+var_20]
mov ecx, ecx
mov edx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_20], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call decode_bytes_0
mov rdi, [rbp+var_20]
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
mov edx, eax
xor esi, esi
call _memset
loc_BDB9B:
add rsp, 20h
pop rbp
retn
| long long uf_zerofill_skip_zero_0(long long a1, int *a2, long long a3, long long a4)
{
int v4; // eax
int v5; // ecx
long long v8; // [rsp+0h] [rbp-20h]
if ( a2[1] )
{
v4 = *a2;
v5 = a2[1] - 1;
a2[1] = v5;
if ( ((1 << v5) & v4) == 0 )
goto LABEL_6;
return memset(a3, 0LL, (unsigned int)(a4 - a3));
}
fill_buffer_0((long long)a2);
a2[1] = 31;
if ( *a2 < 0 )
return memset(a3, 0LL, (unsigned int)(a4 - a3));
LABEL_6:
v8 = a4 - *(unsigned int *)(a1 + 28);
decode_bytes_0(a1, a2, a3, v8);
return memset(v8, 0LL, *(unsigned int *)(a1 + 28));
}
| uf_zerofill_skip_zero:
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 qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x001bdb17
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x001bdb3b
JMP 0x001bdb57
LAB_001bdb17:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bd670
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x001bdb57
LAB_001bdb3b:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2c0
JMP 0x001bdb9b
LAB_001bdb57:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x1c]
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,ECX
MOV EDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001bdd80
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2c0
LAB_001bdb9b:
ADD RSP,0x20
POP RBP
RET
|
void uf_zerofill_skip_zero(long param_1,uint *param_2,void *param_3,long param_4)
{
uint uVar1;
void *__s;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
__s = (void *)(param_4 - (ulong)*(uint *)(param_1 + 0x1c));
decode_bytes(param_1,param_2,param_3,__s);
memset(__s,0,(ulong)*(uint *)(param_1 + 0x1c));
}
else {
memset(param_3,0,(ulong)(uint)((int)param_4 - (int)param_3));
}
return;
}
|
|
6,442 | glfwGetEGLContext | untodesu[P]riteg/build_O1/_deps/glfw-src/src/egl_context.c | GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_CONTEXT);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return EGL_NO_CONTEXT;
}
return window->context.egl.handle;
} | O1 | c | glfwGetEGLContext:
pushq %rbx
leaq 0x7c5d0(%rip), %rax # 0xa4638
cmpl $0x0, (%rax)
je 0x2807f
cmpl $0x0, 0x1f8(%rdi)
je 0x28088
movq 0x288(%rdi), %rbx
jmp 0x28098
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2808f
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq 0x19081
movq %rbx, %rax
popq %rbx
retq
| glfwGetEGLContext:
push rbx
lea rax, _glfw
cmp dword ptr [rax], 0
jz short loc_2807F
cmp dword ptr [rdi+1F8h], 0
jz short loc_28088
mov rbx, [rdi+288h]
jmp short loc_28098
loc_2807F:
xor ebx, ebx
mov edi, 10001h
jmp short loc_2808F
loc_28088:
xor ebx, ebx
mov edi, 1000Ah
loc_2808F:
xor esi, esi
xor eax, eax
call _glfwInputError
loc_28098:
mov rax, rbx
pop rbx
retn
| long long glfwGetEGLContext(long long a1)
{
long long v1; // rbx
unsigned int v2; // edi
if ( !glfw[0] )
{
v1 = 0LL;
v2 = 65537;
LABEL_6:
glfwInputError(v2, 0LL);
return v1;
}
if ( !*(_DWORD *)(a1 + 504) )
{
v1 = 0LL;
v2 = 65546;
goto LABEL_6;
}
return *(_QWORD *)(a1 + 648);
}
| glfwGetEGLContext:
PUSH RBX
LEA RAX,[0x1a4638]
CMP dword ptr [RAX],0x0
JZ 0x0012807f
CMP dword ptr [RDI + 0x1f8],0x0
JZ 0x00128088
MOV RBX,qword ptr [RDI + 0x288]
JMP 0x00128098
LAB_0012807f:
XOR EBX,EBX
MOV EDI,0x10001
JMP 0x0012808f
LAB_00128088:
XOR EBX,EBX
MOV EDI,0x1000a
LAB_0012808f:
XOR ESI,ESI
XOR EAX,EAX
CALL 0x00119081
LAB_00128098:
MOV RAX,RBX
POP RBX
RET
|
int8 glfwGetEGLContext(long param_1)
{
int8 uVar1;
if (_glfw == 0) {
uVar1 = 0x10001;
}
else {
if (*(int *)(param_1 + 0x1f8) != 0) {
return *(int8 *)(param_1 + 0x288);
}
uVar1 = 0x1000a;
}
_glfwInputError(uVar1,0);
return 0;
}
|
|
6,443 | my_uca_scanner_init_any | eloqsql/strings/ctype-uca.c | static void
my_uca_scanner_init_any(my_uca_scanner *scanner,
CHARSET_INFO *cs,
const MY_UCA_WEIGHT_LEVEL *level,
const uchar *str, size_t length)
{
/* Note, no needs to initialize scanner->wbeg */
scanner->sbeg= str;
scanner->send= str + length;
scanner->wbeg= nochar;
scanner->level= level;
scanner->cs= cs;
} | O0 | c | my_uca_scanner_init_any:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x1637d1(%rip), %rcx # 0x1c9110
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
popq %rbp
retq
nopl (%rax)
| my_uca_scanner_init_any:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov rcx, [rbp+var_20]
add rcx, [rbp+var_28]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
mov rax, [rbp+var_8]
lea rcx, nochar
mov [rax], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+18h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax+30h], rcx
pop rbp
retn
| _QWORD * my_uca_scanner_init_any(_QWORD *a1, long long a2, long long a3, long long a4, long long a5)
{
_QWORD *result; // rax
a1[1] = a4;
a1[2] = a5 + a4;
*a1 = &nochar;
a1[3] = a3;
result = a1;
a1[6] = a2;
return result;
}
| my_uca_scanner_init_any:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x2c9110]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x30],RCX
POP RBP
RET
|
void my_uca_scanner_init_any
(int8 *param_1,int8 param_2,int8 param_3,long param_4,long param_5)
{
param_1[1] = param_4;
param_1[2] = param_4 + param_5;
*param_1 = &nochar;
param_1[3] = param_3;
param_1[6] = param_2;
return;
}
|
|
6,444 | minja::SequenceNode::SequenceNode(minja::Location const&, std::vector<std::shared_ptr<minja::TemplateNode>, std::allocator<std::shared_ptr<minja::TemplateNode>>>&&) | monkey531[P]llama/common/minja.hpp | TemplateNode(const Location & location) : location_(location) {} | O1 | cpp | minja::SequenceNode::SequenceNode(minja::Location const&, std::vector<std::shared_ptr<minja::TemplateNode>, std::allocator<std::shared_ptr<minja::TemplateNode>>>&&):
leaq 0x8c47b(%rip), %rax # 0x132fc8
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xa6b7d
movq 0x8d411(%rip), %rcx # 0x133f80
cmpb $0x0, (%rcx)
je 0xa6b79
incl 0x8(%rax)
jmp 0xa6b7d
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
leaq 0x8ca8c(%rip), %rax # 0x133618
addq $0x10, %rax
movq %rax, (%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x20(%rdi)
movq 0x10(%rdx), %rax
movq %rax, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
retq
nop
| _ZN5minja12SequenceNodeC2ERKNS_8LocationEOSt6vectorISt10shared_ptrINS_12TemplateNodeEESaIS7_EE:
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rdi], rax
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_A6B7D
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_A6B79
inc dword ptr [rax+8]
jmp short loc_A6B7D
loc_A6B79:
lock inc dword ptr [rax+8]
loc_A6B7D:
mov rax, [rsi+10h]
mov [rdi+18h], rax
lea rax, _ZTVN5minja12SequenceNodeE; `vtable for'minja::SequenceNode
add rax, 10h
mov [rdi], rax
movups xmm0, xmmword ptr [rdx]
movups xmmword ptr [rdi+20h], xmm0
mov rax, [rdx+10h]
mov [rdi+30h], rax
xorps xmm0, xmm0
movups xmmword ptr [rdx], xmm0
mov qword ptr [rdx+10h], 0
retn
| long long minja::SequenceNode::SequenceNode(long long a1, _QWORD *a2, long long a3)
{
long long v3; // rax
long long result; // rax
*(_QWORD *)a1 = &`vtable for'minja::TemplateNode + 2;
*(_QWORD *)(a1 + 8) = *a2;
v3 = a2[1];
*(_QWORD *)(a1 + 16) = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v3 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v3 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &`vtable for'minja::SequenceNode + 2;
*(_OWORD *)(a1 + 32) = *(_OWORD *)a3;
result = *(_QWORD *)(a3 + 16);
*(_QWORD *)(a1 + 48) = result;
*(_OWORD *)a3 = 0LL;
*(_QWORD *)(a3 + 16) = 0LL;
return result;
}
| SequenceNode:
LEA RAX,[0x232fc8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x001a6b7d
MOV RCX,qword ptr [0x00233f80]
CMP byte ptr [RCX],0x0
JZ 0x001a6b79
INC dword ptr [RAX + 0x8]
JMP 0x001a6b7d
LAB_001a6b79:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001a6b7d:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x233618]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV RAX,qword ptr [RDX + 0x10]
MOV qword ptr [RDI + 0x30],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDX],XMM0
MOV qword ptr [RDX + 0x10],0x0
RET
|
/* minja::SequenceNode::SequenceNode(minja::Location const&,
std::vector<std::shared_ptr<minja::TemplateNode>,
std::allocator<std::shared_ptr<minja::TemplateNode> > >&&) */
void __thiscall
minja::SequenceNode::SequenceNode(SequenceNode *this,Location *param_1,vector *param_2)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR___cxa_pure_virtual_00232fd8;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_00233f80 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_render_00233628;
uVar2 = *(int8 *)(param_2 + 8);
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar2;
*(int8 *)(this + 0x30) = *(int8 *)(param_2 + 0x10);
*(int8 *)param_2 = 0;
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(param_2 + 0x10) = 0;
return;
}
|
|
6,445 | rak_string_new_from_cstr | fabiosvm[P]rak/src/string.c | RakString *rak_string_new_from_cstr(int len, const char *cstr, RakError *err)
{
RakString *str = rak_memory_alloc(sizeof(*str), err);
if (!rak_is_ok(err)) return NULL;
rak_string_init_from_cstr(str, len, cstr, err);
if (rak_is_ok(err)) return str;
rak_memory_free(str);
return NULL;
} | O3 | c | rak_string_new_from_cstr:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x18, %edi
movq %rdx, %rsi
callq 0x74a4
cmpb $0x1, (%r14)
jne 0x7ed8
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x7cd0
cmpb $0x0, (%r14)
jne 0x7eda
movq %rbx, %rdi
callq 0x7504
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| rak_string_new_from_cstr:
push rbp
push r15
push r14
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov ebp, edi
mov edi, 18h
mov rsi, rdx
call rak_memory_alloc
cmp byte ptr [r14], 1
jnz short loc_7ED8
mov rbx, rax
mov rdi, rax
mov esi, ebp
mov rdx, r15
mov rcx, r14
call rak_string_init_from_cstr
cmp byte ptr [r14], 0
jnz short loc_7EDA
mov rdi, rbx
call rak_memory_free
loc_7ED8:
xor ebx, ebx
loc_7EDA:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long rak_string_new_from_cstr(int a1, long long a2, _BYTE *a3)
{
long long v4; // rax
long long v5; // rbx
v4 = rak_memory_alloc(24LL, a3);
if ( *a3 != 1 )
return 0LL;
v5 = v4;
rak_string_init_from_cstr(v4, a1, a2, a3);
if ( !*a3 )
{
rak_memory_free(v5);
return 0LL;
}
return v5;
}
| rak_string_new_from_cstr:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV EBP,EDI
MOV EDI,0x18
MOV RSI,RDX
CALL 0x001074a4
CMP byte ptr [R14],0x1
JNZ 0x00107ed8
MOV RBX,RAX
MOV RDI,RAX
MOV ESI,EBP
MOV RDX,R15
MOV RCX,R14
CALL 0x00107cd0
CMP byte ptr [R14],0x0
JNZ 0x00107eda
MOV RDI,RBX
CALL 0x00107504
LAB_00107ed8:
XOR EBX,EBX
LAB_00107eda:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void * rak_string_new_from_cstr(int4 param_1,int8 param_2,char *param_3)
{
void *__ptr;
__ptr = (void *)rak_memory_alloc(0x18,param_3);
if (*param_3 == '\x01') {
rak_string_init_from_cstr(__ptr,param_1,param_2,param_3);
if (*param_3 != '\0') {
return __ptr;
}
rak_memory_free(__ptr);
}
return (void *)0x0;
}
|
|
6,446 | mysys_namespace::crc32c::crc32c_slow(unsigned int, char const*, unsigned long) | eloqsql/mysys/crc32/crc32c.cc | static uint32_t crc32c_slow(uint32_t crc, const char* buf, size_t size)
{
const uint8_t *p = reinterpret_cast<const uint8_t *>(buf);
const uint8_t *e = p + size;
uint64_t l = crc ^ 0xffffffffu;
// Point x at first 16-byte aligned byte in string. This might be
// just past the end of the string.
const uintptr_t pval = reinterpret_cast<uintptr_t>(p);
const uint8_t* x = reinterpret_cast<const uint8_t*>(ALIGN(pval, 4));
if (x <= e)
// Process bytes until finished or p is 16-byte aligned
while (p != x)
STEP1;
// Process bytes 16 at a time
while ((e-p) >= 16)
{
Slow_CRC32(&l, &p);
Slow_CRC32(&l, &p);
}
// Process bytes 8 at a time
while ((e-p) >= 8)
Slow_CRC32(&l, &p);
// Process the last few bytes
while (p != e)
STEP1;
return static_cast<uint32_t>(l ^ 0xffffffffu);
} | O3 | cpp | mysys_namespace::crc32c::crc32c_slow(unsigned int, char const*, unsigned long):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %eax
addq %rsi, %rdx
notl %eax
leaq 0xf(%rsi), %rdi
andq $-0x10, %rdi
cmpq %rdi, %rdx
setb %r8b
movq %rdi, %rcx
subq %rsi, %rcx
sete %r9b
orb %r8b, %r9b
je 0xa944b
movq %rsi, %rdi
jmp 0xa9476
leaq 0x38b0e(%rip), %r8 # 0xe1f60
movq %rsi, %r9
movzbl %al, %r10d
movzbl (%r9), %r11d
incq %r9
xorl %r10d, %r11d
movl (%r8,%r11,4), %r10d
shrq $0x8, %rax
xorq %r10, %rax
cmpq %rdi, %r9
jne 0xa9455
addq %rcx, %rsi
movq %rdx, %rcx
subq %rdi, %rcx
cmpq $0x10, %rcx
jl 0xa9586
movq %rdx, %rcx
subq %rsi, %rcx
movl $0xff, %edi
leaq 0x38ec8(%rip), %r8 # 0xe2360
leaq 0x392c1(%rip), %r9 # 0xe2760
movl $0x3fc, %r10d # imm = 0x3FC
leaq 0x396b4(%rip), %r11 # 0xe2b60
leaq 0x38aad(%rip), %rbx # 0xe1f60
xorl (%rsi), %eax
movl %eax, %r15d
andl %edi, %r15d
movl %eax, %r14d
shrl $0x8, %r14d
andl %edi, %r14d
movl (%r9,%r14,4), %r14d
xorl (%r8,%r15,4), %r14d
movl %eax, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %r14d
shrl $0x18, %eax
xorl (%rbx,%rax,4), %r14d
xorl 0x4(%rsi), %r14d
movl %r14d, %r15d
andl %edi, %r15d
movl %r14d, %eax
shrl $0x8, %eax
andl %edi, %eax
movl (%r9,%rax,4), %eax
xorl (%r8,%r15,4), %eax
movl %r14d, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %eax
shrl $0x18, %r14d
xorl (%rbx,%r14,4), %eax
xorl 0x8(%rsi), %eax
movl %eax, %r15d
andl %edi, %r15d
movl %eax, %r14d
shrl $0x8, %r14d
andl %edi, %r14d
movl (%r9,%r14,4), %r14d
xorl (%r8,%r15,4), %r14d
movl %eax, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %r14d
shrl $0x18, %eax
xorl (%rbx,%rax,4), %r14d
xorl 0xc(%rsi), %r14d
addq $0x10, %rsi
movl %r14d, %r15d
andl %edi, %r15d
movl %r14d, %eax
shrl $0x8, %eax
andl %edi, %eax
movl (%r9,%rax,4), %eax
xorl (%r8,%r15,4), %eax
movl %r14d, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %eax
shrl $0x18, %r14d
xorl (%rbx,%r14,4), %eax
addq $-0x10, %rcx
cmpq $0xf, %rcx
jg 0xa94b3
movl %eax, %eax
cmpq $0x8, %rcx
jl 0xa962c
movq %rdx, %rcx
subq %rsi, %rcx
movl $0xff, %edi
leaq 0x38dbe(%rip), %r8 # 0xe2360
leaq 0x391b7(%rip), %r9 # 0xe2760
movl $0x3fc, %r10d # imm = 0x3FC
leaq 0x395aa(%rip), %r11 # 0xe2b60
leaq 0x389a3(%rip), %rbx # 0xe1f60
xorl (%rsi), %eax
movl %eax, %r15d
andl %edi, %r15d
movl %eax, %r14d
shrl $0x8, %r14d
andl %edi, %r14d
movl (%r9,%r14,4), %r14d
xorl (%r8,%r15,4), %r14d
movl %eax, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %r14d
shrl $0x18, %eax
xorl (%rbx,%rax,4), %r14d
xorl 0x4(%rsi), %r14d
addq $0x8, %rsi
movl %r14d, %r15d
andl %edi, %r15d
movl %r14d, %eax
shrl $0x8, %eax
andl %edi, %eax
movl (%r9,%rax,4), %eax
xorl (%r8,%r15,4), %eax
movl %r14d, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %eax
shrl $0x18, %r14d
xorl (%rbx,%r14,4), %eax
addq $-0x8, %rcx
cmpq $0x7, %rcx
jg 0xa95bd
movl %eax, %eax
cmpq %rdx, %rsi
je 0xa9655
leaq 0x38928(%rip), %rcx # 0xe1f60
movzbl %al, %edi
movzbl (%rsi), %r8d
incq %rsi
xorl %edi, %r8d
movl (%rcx,%r8,4), %edi
shrq $0x8, %rax
xorq %rdi, %rax
cmpq %rdx, %rsi
jne 0xa9638
notl %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN15mysys_namespace6crc32cL11crc32c_slowEjPKcm:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
mov eax, edi
add rdx, rsi
not eax
lea rdi, [rsi+0Fh]
and rdi, 0FFFFFFFFFFFFFFF0h
cmp rdx, rdi
setb r8b
mov rcx, rdi
sub rcx, rsi
setz r9b
or r9b, r8b
jz short loc_A944B
mov rdi, rsi
jmp short loc_A9476
loc_A944B:
lea r8, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
mov r9, rsi
loc_A9455:
movzx r10d, al
movzx r11d, byte ptr [r9]
inc r9
xor r11d, r10d
mov r10d, [r8+r11*4]
shr rax, 8
xor rax, r10
cmp r9, rdi
jnz short loc_A9455
add rsi, rcx
loc_A9476:
mov rcx, rdx
sub rcx, rdi
cmp rcx, 10h
jl loc_A9586
mov rcx, rdx
sub rcx, rsi
mov edi, 0FFh
lea r8, _ZN15mysys_namespace6crc32cL7table3_E; mysys_namespace::crc32c::table3_
lea r9, _ZN15mysys_namespace6crc32cL7table2_E; mysys_namespace::crc32c::table2_
mov r10d, 3FCh
lea r11, _ZN15mysys_namespace6crc32cL7table1_E; mysys_namespace::crc32c::table1_
lea rbx, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
loc_A94B3:
xor eax, [rsi]
mov r15d, eax
and r15d, edi
mov r14d, eax
shr r14d, 8
and r14d, edi
mov r14d, [r9+r14*4]
xor r14d, [r8+r15*4]
mov r15d, eax
shr r15d, 0Eh
and r15d, r10d
xor r14d, [r15+r11]
shr eax, 18h
xor r14d, [rbx+rax*4]
xor r14d, [rsi+4]
mov r15d, r14d
and r15d, edi
mov eax, r14d
shr eax, 8
and eax, edi
mov eax, [r9+rax*4]
xor eax, [r8+r15*4]
mov r15d, r14d
shr r15d, 0Eh
and r15d, r10d
xor eax, [r15+r11]
shr r14d, 18h
xor eax, [rbx+r14*4]
xor eax, [rsi+8]
mov r15d, eax
and r15d, edi
mov r14d, eax
shr r14d, 8
and r14d, edi
mov r14d, [r9+r14*4]
xor r14d, [r8+r15*4]
mov r15d, eax
shr r15d, 0Eh
and r15d, r10d
xor r14d, [r15+r11]
shr eax, 18h
xor r14d, [rbx+rax*4]
xor r14d, [rsi+0Ch]
add rsi, 10h
mov r15d, r14d
and r15d, edi
mov eax, r14d
shr eax, 8
and eax, edi
mov eax, [r9+rax*4]
xor eax, [r8+r15*4]
mov r15d, r14d
shr r15d, 0Eh
and r15d, r10d
xor eax, [r15+r11]
shr r14d, 18h
xor eax, [rbx+r14*4]
add rcx, 0FFFFFFFFFFFFFFF0h
cmp rcx, 0Fh
jg loc_A94B3
mov eax, eax
loc_A9586:
cmp rcx, 8
jl loc_A962C
mov rcx, rdx
sub rcx, rsi
mov edi, 0FFh
lea r8, _ZN15mysys_namespace6crc32cL7table3_E; mysys_namespace::crc32c::table3_
lea r9, _ZN15mysys_namespace6crc32cL7table2_E; mysys_namespace::crc32c::table2_
mov r10d, 3FCh
lea r11, _ZN15mysys_namespace6crc32cL7table1_E; mysys_namespace::crc32c::table1_
lea rbx, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
loc_A95BD:
xor eax, [rsi]
mov r15d, eax
and r15d, edi
mov r14d, eax
shr r14d, 8
and r14d, edi
mov r14d, [r9+r14*4]
xor r14d, [r8+r15*4]
mov r15d, eax
shr r15d, 0Eh
and r15d, r10d
xor r14d, [r15+r11]
shr eax, 18h
xor r14d, [rbx+rax*4]
xor r14d, [rsi+4]
add rsi, 8
mov r15d, r14d
and r15d, edi
mov eax, r14d
shr eax, 8
and eax, edi
mov eax, [r9+rax*4]
xor eax, [r8+r15*4]
mov r15d, r14d
shr r15d, 0Eh
and r15d, r10d
xor eax, [r15+r11]
shr r14d, 18h
xor eax, [rbx+r14*4]
add rcx, 0FFFFFFFFFFFFFFF8h
cmp rcx, 7
jg short loc_A95BD
mov eax, eax
loc_A962C:
cmp rsi, rdx
jz short loc_A9655
lea rcx, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
loc_A9638:
movzx edi, al
movzx r8d, byte ptr [rsi]
inc rsi
xor r8d, edi
mov edi, [rcx+r8*4]
shr rax, 8
xor rax, rdi
cmp rsi, rdx
jnz short loc_A9638
loc_A9655:
not eax
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysys_namespace::crc32c::crc32c_slow(
mysys_namespace::crc32c *this,
unsigned long long a2,
const char *a3)
{
const char *v3; // rdx
unsigned long long v4; // rax
unsigned long long v5; // rdi
unsigned __int8 *v6; // r9
int v7; // r11d
long long v8; // rcx
unsigned int v9; // r14d
unsigned int v10; // eax
unsigned int v11; // r14d
long long v12; // rcx
unsigned int v13; // r14d
int v14; // r8d
v3 = &a3[a2];
v4 = (unsigned int)~(_DWORD)this;
v5 = (a2 + 15) & 0xFFFFFFFFFFFFFFF0LL;
if ( (unsigned long long)v3 < v5 || v5 == a2 )
{
v5 = a2;
}
else
{
v6 = (unsigned __int8 *)a2;
do
{
v7 = *v6++;
v4 = mysys_namespace::crc32c::table0_[(unsigned __int8)v4 ^ v7] ^ (v4 >> 8);
}
while ( v6 != (unsigned __int8 *)v5 );
a2 = (a2 + 15) & 0xFFFFFFFFFFFFFFF0LL;
}
v8 = (long long)&v3[-v5];
if ( (long long)&v3[-v5] >= 16 )
{
v8 = (long long)&v3[-a2];
do
{
v9 = *(_DWORD *)(a2 + 4) ^ mysys_namespace::crc32c::table0_[(*(_DWORD *)a2 ^ (unsigned int)v4) >> 24] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[((*(_DWORD *)a2 ^ (unsigned int)v4) >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)(*(_BYTE *)a2 ^ v4)] ^ mysys_namespace::crc32c::table2_[(unsigned __int8)((unsigned __int16)(*(_WORD *)a2 ^ v4) >> 8)];
v10 = *(_DWORD *)(a2 + 8) ^ mysys_namespace::crc32c::table0_[HIBYTE(v9)] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[(v9 >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)(*(_BYTE *)(a2 + 4) ^ LOBYTE(mysys_namespace::crc32c::table0_[(*(_DWORD *)a2 ^ (unsigned int)v4) >> 24]) ^ mysys_namespace::crc32c::table1_[((*(_DWORD *)a2 ^ (unsigned int)v4) >> 14) & 0x3FC] ^ LOBYTE(mysys_namespace::crc32c::table3_[(unsigned __int8)(*(_BYTE *)a2 ^ v4)]) ^ LOBYTE(mysys_namespace::crc32c::table2_[(unsigned __int8)((unsigned __int16)(*(_WORD *)a2 ^ v4) >> 8)]))] ^ mysys_namespace::crc32c::table2_[(unsigned __int8)((unsigned __int16)(*(_WORD *)(a2 + 4) ^ LOWORD(mysys_namespace::crc32c::table0_[(*(_DWORD *)a2 ^ (unsigned int)v4) >> 24]) ^ *(_WORD *)&mysys_namespace::crc32c::table1_[((*(_DWORD *)a2 ^ (unsigned int)v4) >> 14) & 0x3FC] ^ LOWORD(mysys_namespace::crc32c::table3_[(unsigned __int8)(*(_BYTE *)a2 ^ v4)]) ^ LOWORD(mysys_namespace::crc32c::table2_[(unsigned __int8)((unsigned __int16)(*(_WORD *)a2 ^ v4) >> 8)])) >> 8)];
v11 = *(_DWORD *)(a2 + 12) ^ mysys_namespace::crc32c::table0_[HIBYTE(v10)] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[(v10 >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)v10] ^ mysys_namespace::crc32c::table2_[BYTE1(v10)];
a2 += 16LL;
LODWORD(v4) = mysys_namespace::crc32c::table0_[HIBYTE(v11)] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[(v11 >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)v11] ^ mysys_namespace::crc32c::table2_[BYTE1(v11)];
v8 -= 16LL;
}
while ( v8 > 15 );
v4 = (unsigned int)v4;
}
if ( v8 >= 8 )
{
v12 = (long long)&v3[-a2];
do
{
v13 = *(_DWORD *)(a2 + 4) ^ mysys_namespace::crc32c::table0_[(*(_DWORD *)a2 ^ (unsigned int)v4) >> 24] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[((*(_DWORD *)a2 ^ (unsigned int)v4) >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)(*(_BYTE *)a2 ^ v4)] ^ mysys_namespace::crc32c::table2_[(unsigned __int8)((unsigned __int16)(*(_WORD *)a2 ^ v4) >> 8)];
a2 += 8LL;
LODWORD(v4) = mysys_namespace::crc32c::table0_[HIBYTE(v13)] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[(v13 >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)v13] ^ mysys_namespace::crc32c::table2_[BYTE1(v13)];
v12 -= 8LL;
}
while ( v12 > 7 );
v4 = (unsigned int)v4;
}
for ( ; (const char *)a2 != v3; v4 = mysys_namespace::crc32c::table0_[(unsigned __int8)v4 ^ v14] ^ (v4 >> 8) )
v14 = *(unsigned __int8 *)a2++;
return (unsigned int)~(_DWORD)v4;
}
| crc32c_slow:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
MOV EAX,EDI
ADD RDX,RSI
NOT EAX
LEA RDI,[RSI + 0xf]
AND RDI,-0x10
CMP RDX,RDI
SETC R8B
MOV RCX,RDI
SUB RCX,RSI
SETZ R9B
OR R9B,R8B
JZ 0x001a944b
MOV RDI,RSI
JMP 0x001a9476
LAB_001a944b:
LEA R8,[0x1e1f60]
MOV R9,RSI
LAB_001a9455:
MOVZX R10D,AL
MOVZX R11D,byte ptr [R9]
INC R9
XOR R11D,R10D
MOV R10D,dword ptr [R8 + R11*0x4]
SHR RAX,0x8
XOR RAX,R10
CMP R9,RDI
JNZ 0x001a9455
ADD RSI,RCX
LAB_001a9476:
MOV RCX,RDX
SUB RCX,RDI
CMP RCX,0x10
JL 0x001a9586
MOV RCX,RDX
SUB RCX,RSI
MOV EDI,0xff
LEA R8,[0x1e2360]
LEA R9,[0x1e2760]
MOV R10D,0x3fc
LEA R11,[0x1e2b60]
LEA RBX,[0x1e1f60]
LAB_001a94b3:
XOR EAX,dword ptr [RSI]
MOV R15D,EAX
AND R15D,EDI
MOV R14D,EAX
SHR R14D,0x8
AND R14D,EDI
MOV R14D,dword ptr [R9 + R14*0x4]
XOR R14D,dword ptr [R8 + R15*0x4]
MOV R15D,EAX
SHR R15D,0xe
AND R15D,R10D
XOR R14D,dword ptr [R15 + R11*0x1]
SHR EAX,0x18
XOR R14D,dword ptr [RBX + RAX*0x4]
XOR R14D,dword ptr [RSI + 0x4]
MOV R15D,R14D
AND R15D,EDI
MOV EAX,R14D
SHR EAX,0x8
AND EAX,EDI
MOV EAX,dword ptr [R9 + RAX*0x4]
XOR EAX,dword ptr [R8 + R15*0x4]
MOV R15D,R14D
SHR R15D,0xe
AND R15D,R10D
XOR EAX,dword ptr [R15 + R11*0x1]
SHR R14D,0x18
XOR EAX,dword ptr [RBX + R14*0x4]
XOR EAX,dword ptr [RSI + 0x8]
MOV R15D,EAX
AND R15D,EDI
MOV R14D,EAX
SHR R14D,0x8
AND R14D,EDI
MOV R14D,dword ptr [R9 + R14*0x4]
XOR R14D,dword ptr [R8 + R15*0x4]
MOV R15D,EAX
SHR R15D,0xe
AND R15D,R10D
XOR R14D,dword ptr [R15 + R11*0x1]
SHR EAX,0x18
XOR R14D,dword ptr [RBX + RAX*0x4]
XOR R14D,dword ptr [RSI + 0xc]
ADD RSI,0x10
MOV R15D,R14D
AND R15D,EDI
MOV EAX,R14D
SHR EAX,0x8
AND EAX,EDI
MOV EAX,dword ptr [R9 + RAX*0x4]
XOR EAX,dword ptr [R8 + R15*0x4]
MOV R15D,R14D
SHR R15D,0xe
AND R15D,R10D
XOR EAX,dword ptr [R15 + R11*0x1]
SHR R14D,0x18
XOR EAX,dword ptr [RBX + R14*0x4]
ADD RCX,-0x10
CMP RCX,0xf
JG 0x001a94b3
MOV EAX,EAX
LAB_001a9586:
CMP RCX,0x8
JL 0x001a962c
MOV RCX,RDX
SUB RCX,RSI
MOV EDI,0xff
LEA R8,[0x1e2360]
LEA R9,[0x1e2760]
MOV R10D,0x3fc
LEA R11,[0x1e2b60]
LEA RBX,[0x1e1f60]
LAB_001a95bd:
XOR EAX,dword ptr [RSI]
MOV R15D,EAX
AND R15D,EDI
MOV R14D,EAX
SHR R14D,0x8
AND R14D,EDI
MOV R14D,dword ptr [R9 + R14*0x4]
XOR R14D,dword ptr [R8 + R15*0x4]
MOV R15D,EAX
SHR R15D,0xe
AND R15D,R10D
XOR R14D,dword ptr [R15 + R11*0x1]
SHR EAX,0x18
XOR R14D,dword ptr [RBX + RAX*0x4]
XOR R14D,dword ptr [RSI + 0x4]
ADD RSI,0x8
MOV R15D,R14D
AND R15D,EDI
MOV EAX,R14D
SHR EAX,0x8
AND EAX,EDI
MOV EAX,dword ptr [R9 + RAX*0x4]
XOR EAX,dword ptr [R8 + R15*0x4]
MOV R15D,R14D
SHR R15D,0xe
AND R15D,R10D
XOR EAX,dword ptr [R15 + R11*0x1]
SHR R14D,0x18
XOR EAX,dword ptr [RBX + R14*0x4]
ADD RCX,-0x8
CMP RCX,0x7
JG 0x001a95bd
MOV EAX,EAX
LAB_001a962c:
CMP RSI,RDX
JZ 0x001a9655
LEA RCX,[0x1e1f60]
LAB_001a9638:
MOVZX EDI,AL
MOVZX R8D,byte ptr [RSI]
INC RSI
XOR R8D,EDI
MOV EDI,dword ptr [RCX + R8*0x4]
SHR RAX,0x8
XOR RAX,RDI
CMP RSI,RDX
JNZ 0x001a9638
LAB_001a9655:
NOT EAX
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* mysys_namespace::crc32c::crc32c_slow(unsigned int, char const*, unsigned long) */
uint __thiscall
mysys_namespace::crc32c::crc32c_slow(crc32c *this,uint param_1,char *param_2,ulong param_3)
{
uint uVar1;
ulong uVar2;
long lVar3;
uint *puVar4;
int4 in_register_00000034;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
puVar5 = (uint *)CONCAT44(in_register_00000034,param_1);
puVar4 = (uint *)(param_2 + (long)puVar5);
uVar2 = (ulong)~(uint)this;
puVar6 = (uint *)((ulong)((long)puVar5 + 0xfU) & 0xfffffffffffffff0);
puVar7 = puVar5;
if ((long)puVar6 - (long)puVar5 != 0 && puVar6 <= puVar4) {
do {
puVar8 = (uint *)((long)puVar7 + 1);
uVar2 = uVar2 >> 8 ^
(ulong)*(uint *)(table0_ + (ulong)((uint)(byte)*puVar7 ^ (uint)uVar2 & 0xff) * 4);
puVar7 = puVar8;
} while (puVar8 != puVar6);
puVar5 = (uint *)((long)puVar5 + ((long)puVar6 - (long)puVar5));
puVar7 = puVar6;
}
lVar3 = (long)puVar4 - (long)puVar7;
if (0xf < lVar3) {
lVar3 = (long)puVar4 - (long)puVar5;
do {
uVar1 = (uint)uVar2 ^ *puVar5;
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4) ^ puVar5[1];
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4) ^ puVar5[2];
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4) ^ puVar5[3];
puVar5 = puVar5 + 4;
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4);
uVar2 = (ulong)uVar1;
lVar3 = lVar3 + -0x10;
} while (0xf < lVar3);
uVar2 = (ulong)uVar1;
}
if (7 < lVar3) {
lVar3 = (long)puVar4 - (long)puVar5;
do {
uVar1 = (uint)uVar2 ^ *puVar5;
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4) ^ puVar5[1];
puVar5 = puVar5 + 2;
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4);
uVar2 = (ulong)uVar1;
lVar3 = lVar3 + -8;
} while (7 < lVar3);
uVar2 = (ulong)uVar1;
}
for (; puVar5 != puVar4; puVar5 = (uint *)((long)puVar5 + 1)) {
uVar2 = uVar2 >> 8 ^
(ulong)*(uint *)(table0_ + (ulong)((uint)(byte)*puVar5 ^ (uint)uVar2 & 0xff) * 4);
}
return ~(uint)uVar2;
}
|
|
6,447 | ImPlot3D::PopStyleColor(int) | zkingston[P]unknot/build_O0/_deps/implot3d-src/implot3d.cpp | void PopStyleColor(int count) {
ImPlot3DContext& gp = *GImPlot3D;
IM_ASSERT_USER_ERROR(count <= gp.ColorModifiers.Size, "You can't pop more modifiers than have been pushed!");
while (count > 0) {
ImGuiColorMod& backup = gp.ColorModifiers.back();
gp.Style.Colors[backup.Col] = backup.BackupValue;
gp.ColorModifiers.pop_back();
count--;
}
} | O0 | cpp | ImPlot3D::PopStyleColor(int):
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq 0x5b93f9(%rip), %rax # 0x68f638
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x1d8(%rcx), %eax
jle 0xd6269
leaq 0x4fc646(%rip), %rdi # 0x5d28a2
callq 0x4f7220
testb $0x1, %al
jne 0xd6267
jmp 0xd6269
jmp 0xd6269
jmp 0xd626b
jmp 0xd626d
cmpl $0x0, 0x14(%rsp)
jle 0xd62d7
movq 0x8(%rsp), %rdi
addq $0x1d8, %rdi # imm = 0x1D8
callq 0xd9b20
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
addq $0x94, %rax
addq $0x4c, %rax
movq (%rsp), %rdx
movslq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x4(%rcx), %rdx
movq %rdx, (%rax)
movq 0xc(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
addq $0x1d8, %rdi # imm = 0x1D8
callq 0xd9b40
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xd626d
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN8ImPlot3D13PopStyleColorEi:
sub rsp, 18h
mov [rsp+18h+var_4], edi
mov rax, cs:_ZN8ImPlot3D9GImPlot3DE; ImPlot3D::GImPlot3D
mov [rsp+18h+var_10], rax
mov eax, [rsp+18h+var_4]
mov rcx, [rsp+18h+var_10]
cmp eax, [rcx+1D8h]
jle short loc_D6269
lea rdi, aYouCanTPopMore; "You can't pop more modifiers than have "...
call _ZN5ImGui8ErrorLogEPKc; ImGui::ErrorLog(char const*)
test al, 1
jnz short loc_D6267
jmp short loc_D6269
loc_D6267:
jmp short $+2
loc_D6269:
jmp short $+2
loc_D626B:
jmp short $+2
loc_D626D:
cmp [rsp+18h+var_4], 0
jle short loc_D62D7
mov rdi, [rsp+18h+var_10]
add rdi, 1D8h
call _ZN8ImVectorI13ImGuiColorModE4backEv; ImVector<ImGuiColorMod>::back(void)
mov [rsp+18h+var_18], rax
mov rcx, [rsp+18h+var_18]
mov rax, [rsp+18h+var_10]
add rax, 94h
add rax, 4Ch ; 'L'
mov rdx, [rsp+18h+var_18]
movsxd rdx, dword ptr [rdx]
shl rdx, 4
add rax, rdx
mov rdx, [rcx+4]
mov [rax], rdx
mov rcx, [rcx+0Ch]
mov [rax+8], rcx
mov rdi, [rsp+18h+var_10]
add rdi, 1D8h
call _ZN8ImVectorI13ImGuiColorModE8pop_backEv; ImVector<ImGuiColorMod>::pop_back(void)
mov eax, [rsp+18h+var_4]
add eax, 0FFFFFFFFh
mov [rsp+18h+var_4], eax
jmp short loc_D626D
loc_D62D7:
add rsp, 18h
retn
| long long ImPlot3D::PopStyleColor(ImPlot3D *this, const char *a2)
{
long long result; // rax
int *v3; // rcx
_QWORD *v4; // rax
long long v5; // [rsp+8h] [rbp-10h]
int v6; // [rsp+14h] [rbp-4h]
v6 = (int)this;
v5 = ImPlot3D::GImPlot3D;
result = (unsigned int)this;
if ( (int)this > *(_DWORD *)(ImPlot3D::GImPlot3D + 472) )
result = ImGui::ErrorLog((ImGui *)"You can't pop more modifiers than have been pushed!", a2);
while ( v6 > 0 )
{
v3 = (int *)ImVector<ImGuiColorMod>::back(v5 + 472);
v4 = (_QWORD *)(16LL * *v3 + v5 + 224);
*v4 = *(_QWORD *)(v3 + 1);
v4[1] = *(_QWORD *)(v3 + 3);
ImVector<ImGuiColorMod>::pop_back(v5 + 472);
result = (unsigned int)--v6;
}
return result;
}
| PopStyleColor:
SUB RSP,0x18
MOV dword ptr [RSP + 0x14],EDI
MOV RAX,qword ptr [0x0078f638]
MOV qword ptr [RSP + 0x8],RAX
MOV EAX,dword ptr [RSP + 0x14]
MOV RCX,qword ptr [RSP + 0x8]
CMP EAX,dword ptr [RCX + 0x1d8]
JLE 0x001d6269
LEA RDI,[0x6d28a2]
CALL 0x005f7220
TEST AL,0x1
JNZ 0x001d6267
JMP 0x001d6269
LAB_001d6267:
JMP 0x001d6269
LAB_001d6269:
JMP 0x001d626b
LAB_001d626b:
JMP 0x001d626d
LAB_001d626d:
CMP dword ptr [RSP + 0x14],0x0
JLE 0x001d62d7
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x1d8
CALL 0x001d9b20
MOV qword ptr [RSP],RAX
MOV RCX,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x94
ADD RAX,0x4c
MOV RDX,qword ptr [RSP]
MOVSXD RDX,dword ptr [RDX]
SHL RDX,0x4
ADD RAX,RDX
MOV RDX,qword ptr [RCX + 0x4]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0xc]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x1d8
CALL 0x001d9b40
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,-0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001d626d
LAB_001d62d7:
ADD RSP,0x18
RET
|
/* ImPlot3D::PopStyleColor(int) */
void ImPlot3D::PopStyleColor(int param_1)
{
long lVar1;
int *piVar2;
int8 *puVar3;
int local_4;
lVar1 = GImPlot3D;
local_4 = param_1;
if (*(int *)(GImPlot3D + 0x1d8) < param_1) {
ImGui::ErrorLog("You can\'t pop more modifiers than have been pushed!");
}
for (; 0 < local_4; local_4 = local_4 + -1) {
piVar2 = (int *)ImVector<ImGuiColorMod>::back((ImVector<ImGuiColorMod> *)(lVar1 + 0x1d8));
puVar3 = (int8 *)(lVar1 + 0xe0 + (long)*piVar2 * 0x10);
*puVar3 = *(int8 *)(piVar2 + 1);
puVar3[1] = *(int8 *)(piVar2 + 3);
ImVector<ImGuiColorMod>::pop_back((ImVector<ImGuiColorMod> *)(lVar1 + 0x1d8));
}
return;
}
|
|
6,448 | my_wc_mb_utf8mb4_no_range | eloqsql/strings/ctype-utf8.c | static int
my_wc_mb_utf8mb4_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *r)
{
int count;
if (wc < 0x80)
count= 1;
else if (wc < 0x800)
count= 2;
else if (wc < 0x10000)
count= 3;
else if (wc < 0x200000)
count= 4;
else
return MY_CS_ILUNI;
switch (count)
{
case 4: r[3]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0x10000;
/* fall through */
case 3: r[2]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0x800;
/* fall through */
case 2: r[1]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0xc0;
/* fall through */
case 1: r[0]= (uchar) wc;
}
return count;
} | O0 | c | my_wc_mb_utf8mb4_no_range:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x80, -0x18(%rbp)
jae 0x67eb3
movl $0x1, -0x24(%rbp)
jmp 0x67efe
cmpq $0x800, -0x18(%rbp) # imm = 0x800
jae 0x67ec6
movl $0x2, -0x24(%rbp)
jmp 0x67efc
cmpq $0x10000, -0x18(%rbp) # imm = 0x10000
jae 0x67ed9
movl $0x3, -0x24(%rbp)
jmp 0x67efa
cmpq $0x200000, -0x18(%rbp) # imm = 0x200000
jae 0x67eec
movl $0x4, -0x24(%rbp)
jmp 0x67ef8
movl $0x0, -0x4(%rbp)
jmp 0x67fcb
jmp 0x67efa
jmp 0x67efc
jmp 0x67efe
movl -0x24(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0x67fc5
movq -0x30(%rbp), %rax
leaq 0x147d73(%rip), %rcx # 0x1afc90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0x10000, %rax # imm = 0x10000
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0x800, %rax # imm = 0x800
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0xc0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
| my_wc_mb_utf8mb4_no_range:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
cmp [rbp+var_18], 80h
jnb short loc_67EB3
mov [rbp+var_24], 1
jmp short loc_67EFE
loc_67EB3:
cmp [rbp+var_18], 800h
jnb short loc_67EC6
mov [rbp+var_24], 2
jmp short loc_67EFC
loc_67EC6:
cmp [rbp+var_18], 10000h
jnb short loc_67ED9
mov [rbp+var_24], 3
jmp short loc_67EFA
loc_67ED9:
cmp [rbp+var_18], offset unk_200000
jnb short loc_67EEC
mov [rbp+var_24], 4
jmp short loc_67EF8
loc_67EEC:
mov [rbp+var_4], 0
jmp loc_67FCB
loc_67EF8:
jmp short $+2
loc_67EFA:
jmp short $+2
loc_67EFC:
jmp short $+2
loc_67EFE:
mov eax, [rbp+var_24]
dec eax; switch 4 cases
mov ecx, eax
mov [rbp+var_30], rcx
sub eax, 3
ja def_67F24; jumptable 0000000000067F24 default case
mov rax, [rbp+var_30]
lea rcx, jpt_67F24
movsxd rax, ds:(jpt_67F24 - 1AFC90h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_67F26:
mov rax, [rbp+var_18]; jumptable 0000000000067F24 case 4
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+3], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 10000h
mov [rbp+var_18], rax
loc_67F57:
mov rax, [rbp+var_18]; jumptable 0000000000067F24 case 3
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+2], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 800h
mov [rbp+var_18], rax
loc_67F88:
mov rax, [rbp+var_18]; jumptable 0000000000067F24 case 2
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 0C0h
mov [rbp+var_18], rax
loc_67FB9:
mov rax, [rbp+var_18]; jumptable 0000000000067F24 case 1
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
def_67F24:
mov eax, [rbp+var_24]; jumptable 0000000000067F24 default case
mov [rbp+var_4], eax
loc_67FCB:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_wc_mb_utf8mb4_no_range(long long a1, unsigned long long a2, _BYTE *a3)
{
unsigned int v4; // [rsp+Ch] [rbp-24h]
unsigned long long v5; // [rsp+18h] [rbp-18h]
v5 = a2;
if ( a2 >= 0x80 )
{
if ( a2 >= 0x800 )
{
if ( a2 >= 0x10000 )
{
if ( a2 >= (unsigned long long)&unk_200000 )
return 0;
v4 = 4;
}
else
{
v4 = 3;
}
}
else
{
v4 = 2;
}
}
else
{
v4 = 1;
}
switch ( v4 )
{
case 1u:
goto LABEL_14;
case 2u:
goto LABEL_13;
case 3u:
goto LABEL_12;
case 4u:
a3[3] = a2 & 0x3F | 0x80;
v5 = (a2 >> 6) | 0x10000;
LABEL_12:
a3[2] = v5 & 0x3F | 0x80;
v5 = (v5 >> 6) | 0x800;
LABEL_13:
a3[1] = v5 & 0x3F | 0x80;
v5 = (v5 >> 6) | 0xC0;
LABEL_14:
*a3 = v5;
break;
default:
break;
}
return v4;
}
| my_wc_mb_utf8mb4_no_range:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
CMP qword ptr [RBP + -0x18],0x80
JNC 0x00167eb3
MOV dword ptr [RBP + -0x24],0x1
JMP 0x00167efe
LAB_00167eb3:
CMP qword ptr [RBP + -0x18],0x800
JNC 0x00167ec6
MOV dword ptr [RBP + -0x24],0x2
JMP 0x00167efc
LAB_00167ec6:
CMP qword ptr [RBP + -0x18],0x10000
JNC 0x00167ed9
MOV dword ptr [RBP + -0x24],0x3
JMP 0x00167efa
LAB_00167ed9:
CMP qword ptr [RBP + -0x18],0x200000
JNC 0x00167eec
MOV dword ptr [RBP + -0x24],0x4
JMP 0x00167ef8
LAB_00167eec:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00167fcb
LAB_00167ef8:
JMP 0x00167efa
LAB_00167efa:
JMP 0x00167efc
LAB_00167efc:
JMP 0x00167efe
LAB_00167efe:
MOV EAX,dword ptr [RBP + -0x24]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x30],RCX
SUB EAX,0x3
JA 0x00167fc5
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x2afc90]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_4:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0x10000
MOV qword ptr [RBP + -0x18],RAX
caseD_3:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0x800
MOV qword ptr [RBP + -0x18],RAX
caseD_2:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0xc0
MOV qword ptr [RBP + -0x18],RAX
caseD_1:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
default:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_00167fcb:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_utf8mb4_no_range(int8 param_1,ulong param_2,int1 *param_3)
{
int4 local_2c;
ulong local_20;
if (param_2 < 0x80) {
local_2c = 1;
}
else if (param_2 < 0x800) {
local_2c = 2;
}
else if (param_2 < 0x10000) {
local_2c = 3;
}
else {
if (0x1fffff < param_2) {
return 0;
}
local_2c = 4;
}
local_20 = param_2;
switch(local_2c) {
case 4:
param_3[3] = (byte)param_2 & 0x3f | 0x80;
local_20 = param_2 >> 6 | 0x10000;
case 3:
param_3[2] = (byte)local_20 & 0x3f | 0x80;
local_20 = local_20 >> 6 | 0x800;
case 2:
param_3[1] = (byte)local_20 & 0x3f | 0x80;
local_20 = local_20 >> 6 | 0xc0;
case 1:
*param_3 = (char)local_20;
return local_2c;
default:
return local_2c;
}
}
|
|
6,449 | usage | eloqsql/storage/maria/aria_pack.c | static void usage(void)
{
print_version();
puts("Copyright 2002-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.");
puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,");
puts("and you are welcome to modify and redistribute it under the GPL license\n");
puts("Pack a Aria-table to take much less space.");
puts("Keys are not updated, you must run aria_chk -rq on the index (.MAI) file");
puts("afterwards to update the keys.");
puts("You should give the .MAI file as the filename argument.");
puts("To unpack a packed table, run aria_chk -u on the table");
printf("\nUsage: %s [OPTIONS] filename...\n", my_progname);
my_print_help(my_long_options);
print_defaults("my", load_default_groups);
my_print_variables(my_long_options);
} | O3 | c | usage:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xbe1de3(%rip), %rbx # 0xc15890
movq (%rbx), %rdx
leaq 0xb08c8(%rip), %rsi # 0xe437f
leaq 0xb08da(%rip), %rcx # 0xe4398
leaq 0xb08d9(%rip), %r8 # 0xe439e
movl $0x1, %edi
xorl %eax, %eax
callq 0x2a850
leaq 0xb08cd(%rip), %rdi # 0xe43a5
callq 0x2a820
leaq 0xb0900(%rip), %rdi # 0xe43e4
callq 0x2a820
leaq 0xb093c(%rip), %rdi # 0xe442c
callq 0x2a820
leaq 0xb0979(%rip), %rdi # 0xe4475
callq 0x2a820
leaq 0xb0998(%rip), %rdi # 0xe44a0
callq 0x2a820
leaq 0xb09d5(%rip), %rdi # 0xe44e9
callq 0x2a820
leaq 0xb09e8(%rip), %rdi # 0xe4508
callq 0x2a820
leaq 0xb0a14(%rip), %rdi # 0xe4540
callq 0x2a820
movq (%rbx), %rdx
leaq 0xb0a3c(%rip), %rsi # 0xe4577
movl $0x1, %edi
xorl %eax, %eax
callq 0x2a850
leaq 0x35d792(%rip), %rbx # 0x3912e0
movq %rbx, %rdi
callq 0xa7d25
leaq 0xaf7cb(%rip), %rdi # 0xe3328
leaq 0x35d4ac(%rip), %rsi # 0x391010
callq 0x9af5e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa81ab
| usage:
push rbp
mov rbp, rsp
push rbx
push rax
lea rbx, my_progname
mov rdx, [rbx]
lea rsi, aSVer10ForSOnS; "%s Ver 1.0 for %s on %s\n"
lea rcx, aLinux; "Linux"
lea r8, aX8664; "x86_64"
mov edi, 1
xor eax, eax
call ___printf_chk
lea rdi, aCopyright20022; "Copyright 2002-2008 MySQL AB, 2008-2009"...
call _puts
lea rdi, aThisSoftwareCo; "This software comes with ABSOLUTELY NO "...
call _puts
lea rdi, aAndYouAreWelco; "and you are welcome to modify and redis"...
call _puts
lea rdi, aPackAAriaTable; "Pack a Aria-table to take much less spa"...
call _puts
lea rdi, aKeysAreNotUpda; "Keys are not updated, you must run aria"...
call _puts
lea rdi, aAfterwardsToUp; "afterwards to update the keys."
call _puts
lea rdi, aYouShouldGiveT; "You should give the .MAI file as the fi"...
call _puts
lea rdi, aToUnpackAPacke; "To unpack a packed table, run aria_chk "...
call _puts
mov rdx, [rbx]
lea rsi, aUsageSOptionsF; "\nUsage: %s [OPTIONS] filename...\n"
mov edi, 1
xor eax, eax
call ___printf_chk
lea rbx, my_long_options
mov rdi, rbx
call my_print_help
lea rdi, unk_E3328
lea rsi, load_default_groups
call print_defaults
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp my_print_variables
| long long usage()
{
__printf_chk(1LL, "%s Ver 1.0 for %s on %s\n", my_progname, "Linux", "x86_64");
puts("Copyright 2002-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.");
puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,");
puts("and you are welcome to modify and redistribute it under the GPL license\n");
puts("Pack a Aria-table to take much less space.");
puts("Keys are not updated, you must run aria_chk -rq on the index (.MAI) file");
puts("afterwards to update the keys.");
puts("You should give the .MAI file as the filename argument.");
puts("To unpack a packed table, run aria_chk -u on the table");
__printf_chk(1LL, "\nUsage: %s [OPTIONS] filename...\n", my_progname);
my_print_help(&my_long_options);
print_defaults(&unk_E3328, &load_default_groups);
return my_print_variables(&my_long_options);
}
| usage:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
LEA RBX,[0xd15890]
MOV RDX,qword ptr [RBX]
LEA RSI,[0x1e437f]
LEA RCX,[0x1e4398]
LEA R8,[0x1e439e]
MOV EDI,0x1
XOR EAX,EAX
CALL 0x0012a850
LEA RDI,[0x1e43a5]
CALL 0x0012a820
LEA RDI,[0x1e43e4]
CALL 0x0012a820
LEA RDI,[0x1e442c]
CALL 0x0012a820
LEA RDI,[0x1e4475]
CALL 0x0012a820
LEA RDI,[0x1e44a0]
CALL 0x0012a820
LEA RDI,[0x1e44e9]
CALL 0x0012a820
LEA RDI,[0x1e4508]
CALL 0x0012a820
LEA RDI,[0x1e4540]
CALL 0x0012a820
MOV RDX,qword ptr [RBX]
LEA RSI,[0x1e4577]
MOV EDI,0x1
XOR EAX,EAX
CALL 0x0012a850
LEA RBX,[0x4912e0]
MOV RDI,RBX
CALL 0x001a7d25
LEA RDI,[0x1e3328]
LEA RSI,[0x491010]
CALL 0x0019af5e
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001a81ab
|
void usage(void)
{
__printf_chk(1,"%s Ver 1.0 for %s on %s\n",my_progname,"Linux","x86_64");
puts("Copyright 2002-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.");
puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,");
puts("and you are welcome to modify and redistribute it under the GPL license\n");
puts("Pack a Aria-table to take much less space.");
puts("Keys are not updated, you must run aria_chk -rq on the index (.MAI) file");
puts("afterwards to update the keys.");
puts("You should give the .MAI file as the filename argument.");
puts("To unpack a packed table, run aria_chk -u on the table");
__printf_chk(1,"\nUsage: %s [OPTIONS] filename...\n",my_progname);
my_print_help(my_long_options);
print_defaults(&DAT_001e3328,load_default_groups);
my_print_variables(my_long_options);
return;
}
|
|
6,450 | nglog::GetExistingTempDirectories(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>>>>&) | ng-log[P]ng-log/src/logging.cc | NGLOG_NO_EXPORT
void GetExistingTempDirectories(vector<string>& list) {
GetTempDirectories(list);
auto i_dir = list.begin();
while (i_dir != list.end()) {
// zero arg to access means test for existence; no constant
// defined on windows
if (access(i_dir->c_str(), 0)) {
i_dir = list.erase(i_dir);
} else {
++i_dir;
}
}
} | O3 | cpp | nglog::GetExistingTempDirectories(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>>>>&):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe895
movq (%rbx), %r14
cmpq 0x8(%rbx), %r14
je 0xea20
movq (%r14), %rdi
xorl %esi, %esi
callq 0x78a0
testl %eax, %eax
je 0xea1a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20d5c
movq %rax, %r14
jmp 0xe9f6
addq $0x20, %r14
jmp 0xe9f6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN5nglog26GetExistingTempDirectoriesERSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EE:
push r14
push rbx
push rax
mov rbx, rdi
call _ZN5nglogL18GetTempDirectoriesERSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EE; nglog::GetTempDirectories(std::vector<std::string> &)
mov r14, [rbx]
loc_E9F6:
cmp r14, [rbx+8]
jz short loc_EA20
mov rdi, [r14]
xor esi, esi
call _access
test eax, eax
jz short loc_EA1A
mov rdi, rbx
mov rsi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPS5_S7_EE; std::vector<std::string>::_M_erase(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>)
mov r14, rax
jmp short loc_E9F6
loc_EA1A:
add r14, 20h ; ' '
jmp short loc_E9F6
loc_EA20:
add rsp, 8
pop rbx
pop r14
retn
| char nglog::GetExistingTempDirectories(_QWORD *a1)
{
long long v1; // rax
_QWORD *v2; // r14
LOBYTE(v1) = nglog::GetTempDirectories(a1);
v2 = (_QWORD *)*a1;
while ( v2 != (_QWORD *)a1[1] )
{
LODWORD(v1) = access(*v2, 0LL);
if ( (_DWORD)v1 )
{
v1 = std::vector<std::string>::_M_erase(a1, v2);
v2 = (_QWORD *)v1;
}
else
{
v2 += 4;
}
}
return v1;
}
| GetExistingTempDirectories:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x0010e895
MOV R14,qword ptr [RBX]
LAB_0010e9f6:
CMP R14,qword ptr [RBX + 0x8]
JZ 0x0010ea20
MOV RDI,qword ptr [R14]
XOR ESI,ESI
CALL 0x001078a0
TEST EAX,EAX
JZ 0x0010ea1a
MOV RDI,RBX
MOV RSI,R14
CALL 0x00120d5c
MOV R14,RAX
JMP 0x0010e9f6
LAB_0010ea1a:
ADD R14,0x20
JMP 0x0010e9f6
LAB_0010ea20:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nglog::GetExistingTempDirectories(std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > >&) */
void nglog::GetExistingTempDirectories(vector *param_1)
{
int iVar1;
int8 *puVar2;
GetTempDirectories(param_1);
puVar2 = *(int8 **)param_1;
while (puVar2 != *(int8 **)(param_1 + 8)) {
iVar1 = access((char *)*puVar2,0);
if (iVar1 == 0) {
puVar2 = puVar2 + 4;
}
else {
puVar2 = (int8 *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::_M_erase
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
param_1);
}
}
return;
}
|
|
6,451 | pvio_socket_is_blocking | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | my_bool pvio_socket_is_blocking(MARIADB_PVIO *pvio)
{
struct st_pvio_socket *csock= NULL;
my_bool r;
if (!pvio || !pvio->data)
return 0;
csock= (struct st_pvio_socket *)pvio->data;
r = !(csock->fcntl_mode & O_NONBLOCK);
return r;
} | O0 | c | pvio_socket_is_blocking:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42161
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x42167
movb $0x0, -0x1(%rbp)
jmp 0x42194
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x800, %eax # imm = 0x800
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
| pvio_socket_is_blocking:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], 0
cmp [rbp+var_10], 0
jz short loc_42161
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_42167
loc_42161:
mov [rbp+var_1], 0
jmp short loc_42194
loc_42167:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax+4]
and eax, 800h
cmp eax, 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
mov [rbp+var_19], al
mov al, [rbp+var_19]
mov [rbp+var_1], al
loc_42194:
mov al, [rbp+var_1]
pop rbp
retn
| bool pvio_socket_is_blocking(long long a1)
{
return a1 && *(_QWORD *)a1 && (*(_DWORD *)(*(_QWORD *)a1 + 4LL) & 0x800) == 0;
}
| pvio_socket_is_blocking:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00142161
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x00142167
LAB_00142161:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00142194
LAB_00142167:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x4]
AND EAX,0x800
CMP EAX,0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x19],AL
MOV AL,byte ptr [RBP + -0x19]
MOV byte ptr [RBP + -0x1],AL
LAB_00142194:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
byte pvio_socket_is_blocking(long *param_1)
{
int1 local_9;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_9 = 0;
}
else {
local_9 = ((*(uint *)(*param_1 + 4) & 0x800) != 0 ^ 0xffU) & 1;
}
return local_9;
}
|
|
6,452 | uf_prespace_selected | eloqsql/storage/maria/ma_packrec.c | static void uf_prespace_selected(MARIA_COLUMNDEF *rec,
MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
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);
} | O0 | c | uf_prespace_selected:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x4bbfa
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x4bc22
jmp 0x4bcda
movq -0x10(%rbp), %rdi
callq 0x4ab70
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0x4bcda
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jb 0x4bc65
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, %edx
leaq 0x2797b3(%rip), %rcx # 0x2c5410
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0x4bc78
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x4a320
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0x4bc9a
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0x4bcef
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x2a2a0
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0x4bcd8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %eax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x4aeb0
jmp 0x4bcef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4aeb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| uf_prespace_selected:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_4BBFA
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_4BC22
jmp loc_4BCDA
loc_4BBFA:
mov rdi, [rbp+var_10]
call fill_buffer
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz loc_4BCDA
loc_4BC22:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+24h]
jb short loc_4BC65
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+24h]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+24h]
mov edx, ecx
lea rcx, mask
and eax, [rcx+rdx*4]
mov [rbp+var_28], eax
jmp short loc_4BC78
loc_4BC65:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+24h]
call fill_and_get_bits
mov [rbp+var_28], eax
loc_4BC78:
mov ecx, [rbp+var_28]
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
cmp rax, [rbp+var_20]
jbe short loc_4BC9A
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_4BCEF
loc_4BC9A:
mov rdi, [rbp+var_18]
mov eax, [rbp+var_24]
mov edx, eax
mov esi, 20h ; ' '
call _memset
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_4BCD8
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov eax, [rbp+var_24]
add rdx, rax
mov rcx, [rbp+var_20]
call decode_bytes
loc_4BCD8:
jmp short loc_4BCEF
loc_4BCDA:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call decode_bytes
loc_4BCEF:
add rsp, 30h
pop rbp
retn
| long long uf_prespace_selected(long long a1, int *a2, _BYTE *a3, _BYTE *a4)
{
int v4; // eax
int v5; // ecx
unsigned int v6; // eax
int v7; // ecx
long long result; // rax
unsigned int bits; // [rsp+8h] [rbp-28h]
if ( a2[1] )
{
v4 = *a2;
v5 = a2[1] - 1;
a2[1] = v5;
if ( ((1 << v5) & v4) == 0 )
return decode_bytes(a1, (long long)a2, a3, a4);
}
else
{
fill_buffer((long long)a2);
a2[1] = 31;
if ( *a2 >= 0 )
return decode_bytes(a1, (long long)a2, a3, a4);
}
if ( (unsigned int)a2[1] < *(_DWORD *)(a1 + 36) )
{
bits = fill_and_get_bits(a2, *(_DWORD *)(a1 + 36));
}
else
{
v6 = *a2;
v7 = a2[1] - *(_DWORD *)(a1 + 36);
a2[1] = v7;
bits = mask[*(unsigned int *)(a1 + 36)] & (v6 >> v7);
}
if ( &a3[bits] <= a4 )
{
memset(a3, 32LL, bits);
result = (long long)&a3[bits];
if ( (_BYTE *)result != a4 )
return decode_bytes(a1, (long long)a2, &a3[bits], a4);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
| uf_prespace_selected:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x0014bbfa
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x0014bc22
JMP 0x0014bcda
LAB_0014bbfa:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014ab70
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x0014bcda
LAB_0014bc22:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x24]
JC 0x0014bc65
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x24]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x24]
MOV EDX,ECX
LEA RCX,[0x3c5410]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x0014bc78
LAB_0014bc65:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x24]
CALL 0x0014a320
MOV dword ptr [RBP + -0x28],EAX
LAB_0014bc78:
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0014bc9a
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x0014bcef
LAB_0014bc9a:
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
MOV ESI,0x20
CALL 0x0012a2a0
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x0014bcd8
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x0014aeb0
LAB_0014bcd8:
JMP 0x0014bcef
LAB_0014bcda:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x0014aeb0
LAB_0014bcef:
ADD RSP,0x30
POP RBP
RET
|
void uf_prespace_selected(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint local_30;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
decode_bytes(param_1,param_2,param_3,param_4);
}
else {
if (param_2[1] < *(uint *)(param_1 + 0x24)) {
local_30 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x24));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x24);
param_2[1] = uVar1;
local_30 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x24) * 4);
}
if (param_4 < (long)param_3 + (ulong)local_30) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)local_30);
if ((long)param_3 + (ulong)local_30 != param_4) {
decode_bytes(param_1,param_2,(long)param_3 + (ulong)local_30,param_4);
}
}
}
return;
}
|
|
6,453 | uf_prespace_selected | eloqsql/storage/maria/ma_packrec.c | static void uf_prespace_selected(MARIA_COLUMNDEF *rec,
MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
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_prespace_selected:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r8
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x465a0
movl (%r14), %ebx
decl %eax
movl %eax, 0x4(%r14)
btl %eax, %ebx
jb 0x465d3
jmp 0x465bd
movq %r14, %rdi
movq %r8, %rbx
callq 0x45a50
movq %rbx, %r8
movl $0x1f, 0x4(%r14)
movl (%r14), %ebx
testl %ebx, %ebx
js 0x465ce
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r8, %rcx
jmp 0x46673
movl $0x1f, %eax
movl 0x24(%r15), %r13d
movl %eax, %ecx
subl %r13d, %ecx
jae 0x46629
subl %eax, %r13d
movl %eax, %eax
leaq 0x9f726(%rip), %rcx # 0xe5d10
andl (%rcx,%rax,4), %ebx
movl %r13d, %ecx
shll %cl, %ebx
movq %r14, %rdi
movq %r15, -0x30(%rbp)
movq %r12, %r15
movq %r8, %r12
callq 0x45a50
movq %r12, %r8
movq %r15, %r12
movq -0x30(%rbp), %r15
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %eax, %ebx
jmp 0x4663d
movl %ecx, 0x4(%r14)
shrl %cl, %ebx
movl 0x24(%r15), %eax
leaq 0x9f6d6(%rip), %rcx # 0xe5d10
andl (%rcx,%rax,4), %ebx
movl %ebx, %edx
leaq (%r12,%rdx), %r13
cmpq %r8, %r13
jbe 0x46652
movl $0x1, 0x28(%r14)
jmp 0x46686
movq %r12, %rdi
movl $0x20, %esi
movq %r8, %rbx
callq 0x2a290
cmpq %rbx, %r13
je 0x46686
movq %rbx, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45c0d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| uf_prespace_selected:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r8, rcx
mov r12, rdx
mov r14, rsi
mov r15, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_465A0
mov ebx, [r14]
dec eax
mov [r14+4], eax
bt ebx, eax
jb short loc_465D3
jmp short loc_465BD
loc_465A0:
mov rdi, r14
mov rbx, r8
call fill_buffer
mov r8, rbx
mov dword ptr [r14+4], 1Fh
mov ebx, [r14]
test ebx, ebx
js short loc_465CE
loc_465BD:
mov rdi, r15
mov rsi, r14
mov rdx, r12
mov rcx, r8
jmp loc_46673
loc_465CE:
mov eax, 1Fh
loc_465D3:
mov r13d, [r15+24h]
mov ecx, eax
sub ecx, r13d
jnb short loc_46629
sub r13d, eax
mov eax, eax
lea rcx, mask
and ebx, [rcx+rax*4]
mov ecx, r13d
shl ebx, cl
mov rdi, r14
mov [rbp+var_30], r15
mov r15, r12
mov r12, r8
call fill_buffer
mov r8, r12
mov r12, r15
mov r15, [rbp+var_30]
mov eax, 20h ; ' '
sub eax, r13d
mov [r14+4], eax
mov eax, [r14]
neg r13d
mov ecx, r13d
shr eax, cl
add ebx, eax
jmp short loc_4663D
loc_46629:
mov [r14+4], ecx
shr ebx, cl
mov eax, [r15+24h]
lea rcx, mask
and ebx, [rcx+rax*4]
loc_4663D:
mov edx, ebx
lea r13, [r12+rdx]
cmp r13, r8
jbe short loc_46652
mov dword ptr [r14+28h], 1
jmp short loc_46686
loc_46652:
mov rdi, r12
mov esi, 20h ; ' '
mov rbx, r8
call _memset
cmp r13, rbx
jz short loc_46686
mov rcx, rbx
mov rdi, r15
mov rsi, r14
mov rdx, r13
loc_46673:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes
loc_46686:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long uf_prespace_selected(long long a1, unsigned int *a2, _BYTE *a3, _BYTE *a4)
{
_BYTE *v4; // r8
long long v6; // r15
unsigned int v7; // eax
unsigned int v8; // ebx
unsigned int v9; // eax
_BYTE *v11; // rdx
_BYTE *v12; // rcx
unsigned int v13; // r13d
unsigned int v14; // ecx
int v15; // r13d
int v16; // ebx
_BYTE *v17; // r15
_BYTE *v18; // r12
long long result; // rax
unsigned int v20; // ebx
long long v21; // rdx
_BYTE *v22; // r13
_BYTE *v23; // rbx
v4 = a4;
v6 = a1;
v7 = a2[1];
if ( v7 )
{
v8 = *a2;
v9 = v7 - 1;
a2[1] = v9;
if ( !_bittest((const int *)&v8, v9) )
goto LABEL_5;
}
else
{
fill_buffer((long long)a2);
v4 = a4;
a2[1] = 31;
v8 = *a2;
if ( (*a2 & 0x80000000) == 0 )
{
LABEL_5:
v11 = a3;
v12 = v4;
return (long long)decode_bytes(a1, (long long)a2, v11, v12);
}
v9 = 31;
}
v13 = *(_DWORD *)(a1 + 36);
v14 = v9 - v13;
if ( v9 >= v13 )
{
a2[1] = v14;
result = *(unsigned int *)(a1 + 36);
v20 = mask[result] & (v8 >> v14);
}
else
{
v15 = v13 - v9;
v16 = (mask[v9] & v8) << v15;
v17 = a3;
v18 = v4;
fill_buffer((long long)a2);
v4 = v18;
a3 = v17;
v6 = a1;
a2[1] = 32 - v15;
result = *a2 >> -(char)v15;
v20 = result + v16;
}
v21 = v20;
v22 = &a3[v20];
if ( v22 > v4 )
{
a2[10] = 1;
return result;
}
v23 = v4;
result = memset(a3, 32LL, v21);
if ( v22 != v23 )
{
v12 = v23;
a1 = v6;
v11 = v22;
return (long long)decode_bytes(a1, (long long)a2, v11, v12);
}
return result;
}
| uf_prespace_selected:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R8,RCX
MOV R12,RDX
MOV R14,RSI
MOV R15,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x001465a0
MOV EBX,dword ptr [R14]
DEC EAX
MOV dword ptr [R14 + 0x4],EAX
BT EBX,EAX
JC 0x001465d3
JMP 0x001465bd
LAB_001465a0:
MOV RDI,R14
MOV RBX,R8
CALL 0x00145a50
MOV R8,RBX
MOV dword ptr [R14 + 0x4],0x1f
MOV EBX,dword ptr [R14]
TEST EBX,EBX
JS 0x001465ce
LAB_001465bd:
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
MOV RCX,R8
JMP 0x00146673
LAB_001465ce:
MOV EAX,0x1f
LAB_001465d3:
MOV R13D,dword ptr [R15 + 0x24]
MOV ECX,EAX
SUB ECX,R13D
JNC 0x00146629
SUB R13D,EAX
MOV EAX,EAX
LEA RCX,[0x1e5d10]
AND EBX,dword ptr [RCX + RAX*0x4]
MOV ECX,R13D
SHL EBX,CL
MOV RDI,R14
MOV qword ptr [RBP + -0x30],R15
MOV R15,R12
MOV R12,R8
CALL 0x00145a50
MOV R8,R12
MOV R12,R15
MOV R15,qword ptr [RBP + -0x30]
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 EBX,EAX
JMP 0x0014663d
LAB_00146629:
MOV dword ptr [R14 + 0x4],ECX
SHR EBX,CL
MOV EAX,dword ptr [R15 + 0x24]
LEA RCX,[0x1e5d10]
AND EBX,dword ptr [RCX + RAX*0x4]
LAB_0014663d:
MOV EDX,EBX
LEA R13,[R12 + RDX*0x1]
CMP R13,R8
JBE 0x00146652
MOV dword ptr [R14 + 0x28],0x1
JMP 0x00146686
LAB_00146652:
MOV RDI,R12
MOV ESI,0x20
MOV RBX,R8
CALL 0x0012a290
CMP R13,RBX
JZ 0x00146686
MOV RCX,RBX
MOV RDI,R15
MOV RSI,R14
MOV RDX,R13
LAB_00146673:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00145c0d
LAB_00146686:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void uf_prespace_selected(long param_1,uint *param_2,void *param_3,void *param_4)
{
void *pvVar1;
uint uVar2;
uint uVar3;
uint uVar4;
byte bVar5;
uint uVar6;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar6 = *param_2;
if (-1 < (int)uVar6) goto LAB_00146673;
uVar4 = 0x1f;
}
else {
uVar6 = *param_2;
uVar4 = param_2[1] - 1;
param_2[1] = uVar4;
if ((uVar6 >> (uVar4 & 0x1f) & 1) == 0) goto LAB_00146673;
}
uVar2 = *(uint *)(param_1 + 0x24);
if (uVar4 < uVar2) {
uVar3 = (&mask)[uVar4];
bVar5 = (byte)(uVar2 - uVar4);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar2 - uVar4);
uVar6 = ((uVar6 & uVar3) << (bVar5 & 0x1f)) + (*param_2 >> (-bVar5 & 0x1f));
}
else {
param_2[1] = uVar4 - uVar2;
uVar6 = uVar6 >> ((byte)(uVar4 - uVar2) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x24)];
}
pvVar1 = (void *)((long)param_3 + (ulong)uVar6);
if (param_4 < pvVar1) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)uVar6);
param_3 = pvVar1;
if (pvVar1 != param_4) {
LAB_00146673:
decode_bytes(param_1,param_2,param_3,param_4);
return;
}
}
return;
}
|
|
6,454 | get_argument | eloqsql/mysys/my_default.c | static char *get_argument(const char *keyword, size_t kwlen,
char *ptr, char *name, uint line)
{
char *end;
/* Skip over "include / includedir keyword" and following whitespace */
for (ptr+= kwlen - 1;
my_isspace(&my_charset_latin1, ptr[0]);
ptr++)
{}
/*
Trim trailing whitespace from directory name
The -1 below is for the newline added by fgets()
Note that my_isspace() is true for \r and \n
*/
for (end= ptr + strlen(ptr) - 1;
my_isspace(&my_charset_latin1, *(end - 1));
end--)
{}
end[0]= 0; /* Cut off end space */
/* Print error msg if there is nothing after !include* directive */
if (end <= ptr)
{
fprintf(stderr,
"error: Wrong '!%s' directive in config file: %s at line %d\n",
keyword, name, line);
return 0;
}
return ptr;
} | O0 | c | get_argument:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x250bbd(%rip), %rax # 0x289dc0
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3922b
jmp 0x3921d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x391fc
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25130
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
leaq 0x250b6b(%rip), %rax # 0x289dc0
movq 0x40(%rax), %rax
movq -0x38(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3927e
jmp 0x39270
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3924e
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x392bd
movq 0x1a9d4a(%rip), %rax # 0x1e2fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq 0x5299c(%rip), %rsi # 0x8bc48
movb $0x0, %al
callq 0x25470
movq $0x0, -0x8(%rbp)
jmp 0x392c5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| get_argument:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
mov rax, [rbp+var_18]
sub rax, 1
add rax, [rbp+var_20]
mov [rbp+var_20], rax
loc_391FC:
lea rax, my_charset_latin1
mov rax, [rax+40h]
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_3922B
jmp short $+2
loc_3921D:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_391FC
loc_3922B:
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rdi, [rbp+var_20]
call _strlen
mov rcx, rax
mov rax, [rbp+var_40]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rax
loc_3924E:
lea rax, my_charset_latin1
mov rax, [rax+40h]
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx-1]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_3927E
jmp short $+2
loc_39270:
mov rax, [rbp+var_38]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rax
jmp short loc_3924E
loc_3927E:
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov rax, [rbp+var_38]
cmp rax, [rbp+var_20]
ja short loc_392BD
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_28]
mov r8d, [rbp+var_2C]
lea rsi, aErrorWrongSDir; "error: Wrong '!%s' directive in config "...
mov al, 0
call _fprintf
mov [rbp+var_8], 0
jmp short loc_392C5
loc_392BD:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_392C5:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| unsigned __int8 * get_argument(const char *a1, long long a2, long long a3, const char *a4, int a5)
{
unsigned __int8 *j; // [rsp+8h] [rbp-38h]
unsigned __int8 *i; // [rsp+20h] [rbp-20h]
for ( i = (unsigned __int8 *)(a3 + a2 - 1); (*(_BYTE *)(*(_QWORD *)&my_charset_latin1[16] + *i + 1LL) & 8) != 0; ++i )
;
for ( j = &i[strlen(i) - 1]; (*(_BYTE *)(*(_QWORD *)&my_charset_latin1[16] + *(j - 1) + 1LL) & 8) != 0; --j )
;
*j = 0;
if ( j > i )
return i;
fprintf(stderr, "error: Wrong '!%s' directive in config file: %s at line %d\n", a1, a4, a5);
return 0LL;
}
| get_argument:
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 qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],R8D
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x1
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x20],RAX
LAB_001391fc:
LEA RAX,[0x389dc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0013922b
JMP 0x0013921d
LAB_0013921d:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001391fc
LAB_0013922b:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00125130
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
ADD RAX,-0x1
MOV qword ptr [RBP + -0x38],RAX
LAB_0013924e:
LEA RAX,[0x389dc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + -0x1]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0013927e
JMP 0x00139270
LAB_00139270:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0013924e
LAB_0013927e:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x20]
JA 0x001392bd
MOV RAX,qword ptr [0x002e2fe0]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RBP + -0x2c]
LEA RSI,[0x18bc48]
MOV AL,0x0
CALL 0x00125470
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001392c5
LAB_001392bd:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_001392c5:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
byte * get_argument(int8 param_1,long param_2,long param_3,int8 param_4,uint param_5)
{
byte *pbVar1;
byte *pbVar2;
size_t sVar3;
byte *local_40;
byte *local_28;
byte *local_10;
local_28 = (byte *)(param_2 + -1 + param_3);
while ((PTR_ctype_latin1_00389e00[(ulong)*local_28 + 1] & 8) != 0) {
local_28 = local_28 + 1;
}
sVar3 = strlen((char *)local_28);
pbVar2 = local_28 + sVar3;
do {
local_40 = pbVar2 + -1;
pbVar1 = pbVar2 + -2;
pbVar2 = local_40;
} while ((PTR_ctype_latin1_00389e00[(ulong)*pbVar1 + 1] & 8) != 0);
*local_40 = 0;
if (local_28 < local_40) {
local_10 = local_28;
}
else {
fprintf(*(FILE **)PTR_stderr_002e2fe0,
"error: Wrong \'!%s\' directive in config file: %s at line %d\n",param_1,param_4,
(ulong)param_5);
local_10 = (byte *)0x0;
}
return local_10;
}
|
|
6,455 | Test_DeathNoAllocNewHook_logging::Test_DeathNoAllocNewHook_logging() | ng-log[P]ng-log/src/logging_unittest.cc | TEST(DeathNoAllocNewHook, logging) {
// tests that NewHook used below works
NewHook new_hook;
// Avoid unused warnings under MinGW
//
// NOTE MSVC produces warning C4551 here if we do not take the address of the
// function explicitly.
(void)&allocInt;
ASSERT_DEATH({ allocInt(); }, "unexpected new");
} | O0 | cpp | Test_DeathNoAllocNewHook_logging::Test_DeathNoAllocNewHook_logging():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x665d(%rip), %rax # 0x28fe0
movq %rax, -0x10(%rbp)
leaq 0x793ba(%rip), %rdi # 0x9bd48
leaq -0x10(%rbp), %rsi
callq 0x28fb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN32Test_DeathNoAllocNewHook_loggingC2Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
lea rax, _ZN32Test_DeathNoAllocNewHook_logging3RunEv; Test_DeathNoAllocNewHook_logging::Run(void)
mov [rbp+var_10], rax
lea rdi, _ZN5nglog10g_testlistE; nglog::g_testlist
lea rsi, [rbp+var_10]
call _ZNSt6vectorIPFvvESaIS1_EE9push_backEOS1_; std::vector<void (*)(void)>::push_back(void (*&&)(void))
add rsp, 10h
pop rbp
retn
| void Test_DeathNoAllocNewHook_logging::Test_DeathNoAllocNewHook_logging(
Test_DeathNoAllocNewHook_logging *this)
{
_QWORD v1[2]; // [rsp+0h] [rbp-10h] BYREF
v1[1] = this;
v1[0] = Test_DeathNoAllocNewHook_logging::Run;
std::vector<void (*)(void)>::push_back(&nglog::g_testlist, v1);
}
| Test_DeathNoAllocNewHook_logging:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
LEA RAX,[0x128fe0]
MOV qword ptr [RBP + -0x10],RAX
LEA RDI,[0x19bd48]
LEA RSI,[RBP + -0x10]
CALL 0x00128fb0
ADD RSP,0x10
POP RBP
RET
|
/* Test_DeathNoAllocNewHook_logging::Test_DeathNoAllocNewHook_logging() */
void __thiscall
Test_DeathNoAllocNewHook_logging::Test_DeathNoAllocNewHook_logging
(Test_DeathNoAllocNewHook_logging *this)
{
std::vector<void(*)(),std::allocator<void(*)()>>::push_back((_func_void *)nglog::g_testlist);
return;
}
|
|
6,456 | Test_DeathNoAllocNewHook_logging::Test_DeathNoAllocNewHook_logging() | ng-log[P]ng-log/src/logging_unittest.cc | TEST(DeathNoAllocNewHook, logging) {
// tests that NewHook used below works
NewHook new_hook;
// Avoid unused warnings under MinGW
//
// NOTE MSVC produces warning C4551 here if we do not take the address of the
// function explicitly.
(void)&allocInt;
ASSERT_DEATH({ allocInt(); }, "unexpected new");
} | O2 | cpp | Test_DeathNoAllocNewHook_logging::Test_DeathNoAllocNewHook_logging():
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x148de
callq 0x1024a
movq %rbx, %rdi
callq 0x14920
addq $0x30, %rsp
popq %rbx
retq
nop
| _ZN32Test_DeathNoAllocNewHook_logging3RunEv:
push rbx
sub rsp, 30h
mov rbx, rsp
mov rdi, rbx; this
call _ZN5nglog9FlagSaverC2Ev; nglog::FlagSaver::FlagSaver(void)
call _ZN32Test_DeathNoAllocNewHook_logging7RunTestEv; Test_DeathNoAllocNewHook_logging::RunTest(void)
mov rdi, rbx; this
call _ZN5nglog9FlagSaverD2Ev; nglog::FlagSaver::~FlagSaver()
add rsp, 30h
pop rbx
retn
| void Test_DeathNoAllocNewHook_logging::Run(Test_DeathNoAllocNewHook_logging *this)
{
_BYTE v1[56]; // [rsp+0h] [rbp-38h] BYREF
nglog::FlagSaver::FlagSaver((nglog::FlagSaver *)v1);
Test_DeathNoAllocNewHook_logging::RunTest((Test_DeathNoAllocNewHook_logging *)v1);
nglog::FlagSaver::~FlagSaver((nglog::FlagSaver *)v1);
}
| Run:
PUSH RBX
SUB RSP,0x30
MOV RBX,RSP
MOV RDI,RBX
CALL 0x001148de
CALL 0x0011024a
MOV RDI,RBX
CALL 0x00114920
ADD RSP,0x30
POP RBX
RET
|
/* Test_DeathNoAllocNewHook_logging::Run() */
void Test_DeathNoAllocNewHook_logging::Run(void)
{
FlagSaver aFStack_38 [48];
nglog::FlagSaver::FlagSaver(aFStack_38);
RunTest();
nglog::FlagSaver::~FlagSaver(aFStack_38);
return;
}
|
|
6,457 | my_strxfrm_pad_nweights_unicode | eloqsql/strings/ctype-utf8.c | size_t
my_strxfrm_pad_nweights_unicode(uchar *str, uchar *strend, size_t nweights)
{
uchar *str0;
DBUG_ASSERT(str && str <= strend);
for (str0= str; str < strend && nweights; nweights--)
{
*str++= 0x00;
if (str < strend)
*str++= 0x20;
}
return str - str0;
} | O0 | c | my_strxfrm_pad_nweights_unicode:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xb4442
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0xb4464
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xb446d
jmp 0xb44ab
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xb449b
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x20, (%rax)
jmp 0xb449d
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb444a
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopl (%rax,%rax)
| my_strxfrm_pad_nweights_unicode:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_B4442:
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
loc_B444A:
mov rcx, [rbp+var_8]
xor eax, eax
cmp rcx, [rbp+var_10]
mov [rbp+var_21], al
jnb short loc_B4464
cmp [rbp+var_18], 0
setnz al
mov [rbp+var_21], al
loc_B4464:
mov al, [rbp+var_21]
test al, 1
jnz short loc_B446D
jmp short loc_B44AB
loc_B446D:
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_B449B
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 20h ; ' '
loc_B449B:
jmp short $+2
loc_B449D:
mov rax, [rbp+var_18]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_18], rax
jmp short loc_B444A
loc_B44AB:
mov rax, [rbp+var_8]
mov rcx, [rbp+var_20]
sub rax, rcx
pop rbp
retn
| _BYTE * my_strxfrm_pad_nweights_unicode(_BYTE *a1, unsigned long long a2, long long a3)
{
_BYTE *v3; // rax
_BYTE *v4; // rax
bool v6; // [rsp+1h] [rbp-21h]
_BYTE *v8; // [rsp+1Ah] [rbp-8h]
v8 = a1;
while ( 1 )
{
v6 = 0;
if ( (unsigned long long)v8 < a2 )
v6 = a3 != 0;
if ( !v6 )
break;
v3 = v8++;
*v3 = 0;
if ( (unsigned long long)v8 < a2 )
{
v4 = v8++;
*v4 = 32;
}
--a3;
}
return (_BYTE *)(v8 - a1);
}
| my_strxfrm_pad_nweights_unicode:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x001b4442
LAB_001b4442:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001b444a:
MOV RCX,qword ptr [RBP + -0x8]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RBP + -0x21],AL
JNC 0x001b4464
CMP qword ptr [RBP + -0x18],0x0
SETNZ AL
MOV byte ptr [RBP + -0x21],AL
LAB_001b4464:
MOV AL,byte ptr [RBP + -0x21]
TEST AL,0x1
JNZ 0x001b446d
JMP 0x001b44ab
LAB_001b446d:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x001b449b
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x20
LAB_001b449b:
JMP 0x001b449d
LAB_001b449d:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001b444a
LAB_001b44ab:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
POP RBP
RET
|
long my_strxfrm_pad_nweights_unicode(int1 *param_1,int1 *param_2,long param_3)
{
int1 *puVar1;
long local_20;
int1 *local_10;
local_10 = param_1;
for (local_20 = param_3; local_10 < param_2 && local_20 != 0; local_20 = local_20 + -1) {
puVar1 = local_10 + 1;
*local_10 = 0;
if (puVar1 < param_2) {
*puVar1 = 0x20;
puVar1 = local_10 + 2;
}
local_10 = puVar1;
}
return (long)local_10 - (long)param_1;
}
|
|
6,458 | map_delete_record | bluesky950520[P]quickjs/quickjs.c | static void map_delete_record(JSRuntime *rt, JSMapState *s, JSMapRecord *mr)
{
if (mr->empty)
return;
list_del(&mr->hash_link);
if (s->is_weak) {
delete_map_weak_ref(rt, mr);
} else {
JS_FreeValueRT(rt, mr->key);
}
JS_FreeValueRT(rt, mr->value);
if (--mr->ref_count == 0) {
list_del(&mr->link);
js_free_rt(rt, mr);
} else {
/* keep a zombie record for iterators */
mr->empty = TRUE;
mr->key = JS_UNDEFINED;
mr->value = JS_UNDEFINED;
}
s->record_count--;
} | O0 | c | map_delete_record:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0x93283
jmp 0x93372
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x29f20
movq 0x28(%rsp), %rax
cmpl $0x0, (%rax)
je 0x932ac
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x62370
jmp 0x932c3
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
callq 0x2a000
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
callq 0x2a000
movq 0x20(%rsp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x9330a
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0x29f20
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x27c50
jmp 0x93364
movq 0x20(%rsp), %rax
movl $0x1, 0x4(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x10(%rsp)
movq $0x3, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rax
movl $0x0, (%rsp)
movq $0x3, 0x8(%rsp)
movq (%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x28(%rsp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
| map_delete_record:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_18], rdx
mov rax, [rsp+38h+var_18]
cmp dword ptr [rax+4], 0
jz short loc_93283
jmp loc_93372
loc_93283:
mov rdi, [rsp+38h+var_18]
add rdi, 20h ; ' '
call list_del_1
mov rax, [rsp+38h+var_10]
cmp dword ptr [rax], 0
jz short loc_932AC
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_18]
call delete_map_weak_ref
jmp short loc_932C3
loc_932AC:
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_18]
mov rsi, [rax+30h]
mov rdx, [rax+38h]
call JS_FreeValueRT
loc_932C3:
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_18]
mov rsi, [rax+40h]
mov rdx, [rax+48h]
call JS_FreeValueRT
mov rcx, [rsp+38h+var_18]
mov eax, [rcx]
add eax, 0FFFFFFFFh
mov [rcx], eax
cmp eax, 0
jnz short loc_9330A
mov rdi, [rsp+38h+var_18]
add rdi, 10h
call list_del_1
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_18]
call js_free_rt
jmp short loc_93364
loc_9330A:
mov rax, [rsp+38h+var_18]
mov dword ptr [rax+4], 1
mov rax, [rsp+38h+var_18]
mov dword ptr [rsp+38h+var_28], 0
mov [rsp+38h+var_20], 3
mov rcx, [rsp+38h+var_28]
mov [rax+30h], rcx
mov rcx, [rsp+38h+var_20]
mov [rax+38h], rcx
mov rax, [rsp+38h+var_18]
mov dword ptr [rsp+38h+var_38], 0
mov [rsp+38h+var_30], 3
mov rcx, [rsp+38h+var_38]
mov [rax+40h], rcx
mov rcx, [rsp+38h+var_30]
mov [rax+48h], rcx
loc_93364:
mov rax, [rsp+38h+var_10]
mov ecx, [rax+18h]
add ecx, 0FFFFFFFFh
mov [rax+18h], ecx
loc_93372:
add rsp, 38h
retn
| _DWORD * map_delete_record(long long a1, _DWORD *a2, long long a3)
{
_DWORD *result; // rax
int v4; // eax
long long v5; // [rsp+0h] [rbp-38h]
long long v6; // [rsp+10h] [rbp-28h]
result = (_DWORD *)a3;
if ( !*(_DWORD *)(a3 + 4) )
{
list_del_1((_QWORD *)(a3 + 32));
if ( *a2 )
delete_map_weak_ref(a1, a3);
else
JS_FreeValueRT(a1, *(_DWORD **)(a3 + 48), *(_QWORD *)(a3 + 56));
JS_FreeValueRT(a1, *(_DWORD **)(a3 + 64), *(_QWORD *)(a3 + 72));
v4 = *(_DWORD *)a3 - 1;
*(_DWORD *)a3 = v4;
if ( v4 )
{
*(_DWORD *)(a3 + 4) = 1;
LODWORD(v6) = 0;
*(_QWORD *)(a3 + 48) = v6;
*(_QWORD *)(a3 + 56) = 3LL;
LODWORD(v5) = 0;
*(_QWORD *)(a3 + 64) = v5;
*(_QWORD *)(a3 + 72) = 3LL;
}
else
{
list_del_1((_QWORD *)(a3 + 16));
js_free_rt(a1, a3);
}
result = a2;
--a2[6];
}
return result;
}
| map_delete_record:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x00193283
JMP 0x00193372
LAB_00193283:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x20
CALL 0x00129f20
MOV RAX,qword ptr [RSP + 0x28]
CMP dword ptr [RAX],0x0
JZ 0x001932ac
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x00162370
JMP 0x001932c3
LAB_001932ac:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x30]
MOV RDX,qword ptr [RAX + 0x38]
CALL 0x0012a000
LAB_001932c3:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x40]
MOV RDX,qword ptr [RAX + 0x48]
CALL 0x0012a000
MOV RCX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RCX]
ADD EAX,-0x1
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JNZ 0x0019330a
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x10
CALL 0x00129f20
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x00127c50
JMP 0x00193364
LAB_0019330a:
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0x4],0x1
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x3
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x3
MOV RCX,qword ptr [RSP]
MOV qword ptr [RAX + 0x40],RCX
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x48],RCX
LAB_00193364:
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RAX + 0x18]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x18],ECX
LAB_00193372:
ADD RSP,0x38
RET
|
void map_delete_record(int8 param_1,int *param_2,int *param_3)
{
int iVar1;
uint uStack_34;
uint uStack_24;
if (param_3[1] == 0) {
list_del(param_3 + 8);
if (*param_2 == 0) {
JS_FreeValueRT(param_1,*(int8 *)(param_3 + 0xc),*(int8 *)(param_3 + 0xe));
}
else {
delete_map_weak_ref(param_1,param_3);
}
JS_FreeValueRT(param_1,*(int8 *)(param_3 + 0x10),*(int8 *)(param_3 + 0x12));
iVar1 = *param_3;
*param_3 = iVar1 + -1;
if (iVar1 + -1 == 0) {
list_del(param_3 + 4);
js_free_rt(param_1,param_3);
}
else {
param_3[1] = 1;
*(ulong *)(param_3 + 0xc) = (ulong)uStack_24 << 0x20;
param_3[0xe] = 3;
param_3[0xf] = 0;
*(ulong *)(param_3 + 0x10) = (ulong)uStack_34 << 0x20;
param_3[0x12] = 3;
param_3[0x13] = 0;
}
param_2[6] = param_2[6] + -1;
}
return;
}
|
|
6,459 | rtree_find_first | eloqsql/storage/myisam/rt_index.c | int rtree_find_first(MI_INFO *info, uint keynr, uchar *key, uint key_length,
uint search_flag)
{
my_off_t root;
uint nod_cmp_flag;
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
/*
At the moment index can only properly handle the
MBR_INTERSECT, so we use it for all sorts of queries.
TODO: better searsh for CONTAINS/WITHIN.
*/
search_flag= nod_cmp_flag= MBR_INTERSECT;
if ((root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
/*
Save searched key, include data pointer.
The data pointer is required if the search_flag contains MBR_DATA.
(minimum bounding rectangle)
*/
memcpy(info->first_mbr_key, key, keyinfo->keylength);
info->last_rkey_length = key_length;
info->rtree_recursion_depth = -1;
info->buff_used = 1;
/*
TODO better search for CONTAINS/WITHIN.
nod_cmp_flag= ((search_flag & (MBR_EQUAL | MBR_WITHIN)) ?
MBR_WITHIN : MBR_INTERSECT);
*/
return rtree_find_req(info, keyinfo, search_flag, nod_cmp_flag, root, 0);
} | O0 | c | rtree_find_first:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl $0x400, -0x34(%rbp) # imm = 0x400
movl $0x400, -0x28(%rbp) # imm = 0x400
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
jne 0xca597
callq 0xfe880
movl $0x89, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca5f8
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rax
movzwl 0x12(%rax), %eax
movl %eax, %edx
callq 0x2a0b0
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1dc(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x3c0(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movb $0x1, 0x33d(%rax)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x28(%rbp), %edx
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %r8
xorl %r9d, %r9d
callq 0xca610
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| rtree_find_first:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], r8d
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_14]
imul rcx, 70h ; 'p'
add rax, rcx
mov [rbp+var_40], rax
mov [rbp+var_34], 400h
mov [rbp+var_28], 400h
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+98h]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov [rbp+var_30], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_CA597
call _my_thread_var
mov dword ptr [rax], 89h
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_CA5F8
loc_CA597:
mov rax, [rbp+var_10]
mov rdi, [rax+118h]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_40]
movzx eax, word ptr [rax+12h]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_24]
mov rax, [rbp+var_10]
mov [rax+1DCh], ecx
mov rax, [rbp+var_10]
mov dword ptr [rax+3C0h], 0FFFFFFFFh
mov rax, [rbp+var_10]
mov byte ptr [rax+33Dh], 1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_40]
mov edx, [rbp+var_28]
mov ecx, [rbp+var_34]
mov r8, [rbp+var_30]
xor r9d, r9d
call rtree_find_req
mov [rbp+var_4], eax
loc_CA5F8:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long rtree_find_first(long long a1, const char *a2, long long a3, int a4)
{
long long v5; // [rsp+0h] [rbp-40h]
long long v6; // [rsp+10h] [rbp-30h]
v5 = 112LL * (unsigned int)a2 + *(_QWORD *)(*(_QWORD *)a1 + 536LL);
v6 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 152LL) + 8LL * (unsigned int)a2);
if ( v6 == -1 )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return (unsigned int)-1;
}
else
{
memcpy(*(_QWORD *)(a1 + 280), a3, *(unsigned __int16 *)(v5 + 18));
*(_DWORD *)(a1 + 476) = a4;
*(_DWORD *)(a1 + 960) = -1;
*(_BYTE *)(a1 + 829) = 1;
return (unsigned int)rtree_find_req(a1, v5, 1024LL, 1024LL, v6, 0LL);
}
}
| rtree_find_first:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],R8D
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x34],0x400
MOV dword ptr [RBP + -0x28],0x400
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,-0x1
JNZ 0x001ca597
CALL 0x001fe880
MOV dword ptr [RAX],0x89
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001ca5f8
LAB_001ca597:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x118]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [RAX + 0x12]
MOV EDX,EAX
CALL 0x0012a0b0
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x1dc],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x3c0],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33d],0x1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x34]
MOV R8,qword ptr [RBP + -0x30]
XOR R9D,R9D
CALL 0x001ca610
MOV dword ptr [RBP + -0x4],EAX
LAB_001ca5f8:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 rtree_find_first(long *param_1,uint param_2,void *param_3,int4 param_4)
{
long lVar1;
long lVar2;
int4 *puVar3;
int4 local_c;
lVar2 = *(long *)(*param_1 + 0x218) + (ulong)param_2 * 0x70;
lVar1 = *(long *)(*(long *)(*param_1 + 0x98) + (ulong)param_2 * 8);
if (lVar1 == -1) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
local_c = 0xffffffff;
}
else {
memcpy((void *)param_1[0x23],param_3,(ulong)*(ushort *)(lVar2 + 0x12));
*(int4 *)((long)param_1 + 0x1dc) = param_4;
*(int4 *)(param_1 + 0x78) = 0xffffffff;
*(int1 *)((long)param_1 + 0x33d) = 1;
local_c = rtree_find_req(param_1,lVar2,0x400,0x400,lVar1,0);
}
return local_c;
}
|
|
6,460 | string_from[abi:cxx11](std::vector<int, std::allocator<int>> const&) | monkey531[P]llama/common/common.cpp | std::string string_from(const std::vector<int> & values) {
std::stringstream buf;
buf << "[ ";
bool first = true;
for (auto e : values) {
if (first) {
first = false;
} else {
buf << ", ";
}
buf << std::to_string(e);
}
buf << " ]";
return buf.str();
} | O1 | cpp | string_from[abi:cxx11](std::vector<int, std::allocator<int>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %rbx
movq %rdi, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x184c0
leaq 0x40(%rsp), %rdi
leaq 0x8c11d(%rip), %rsi # 0xa9e75
movl $0x2, %edx
callq 0x18770
movq (%rbx), %r12
movq 0x8(%rbx), %rax
movq %rax, 0x28(%rsp)
cmpq %rax, %r12
je 0x1de5f
movb $0x1, %r14b
movl $0xd1b71759, %r15d # imm = 0xD1B71759
movl (%r12), %r13d
testb $0x1, %r14b
je 0x1dd8f
xorl %r14d, %r14d
jmp 0x1dda5
movl $0x2, %edx
leaq 0x40(%rsp), %rdi
leaq 0x8ca7c(%rip), %rsi # 0xaa81c
callq 0x18770
movl %r13d, %ebp
negl %ebp
cmovsl %r13d, %ebp
movl $0x1, %ebx
cmpl $0xa, %ebp
jb 0x1ddf4
movl $0x4, %ebx
movl %ebp, %eax
cmpl $0x63, %eax
jbe 0x1dded
cmpl $0x3e7, %eax # imm = 0x3E7
jbe 0x1ddf2
cmpl $0x2710, %eax # imm = 0x2710
jb 0x1ddf4
movl %eax, %ecx
imulq %r15, %rcx
shrq $0x2d, %rcx
addl $0x4, %ebx
cmpl $0x1869f, %eax # imm = 0x1869F
movl %ecx, %eax
ja 0x1ddbf
addl $-0x3, %ebx
jmp 0x1ddf4
addl $-0x2, %ebx
jmp 0x1ddf4
decl %ebx
shrl $0x1f, %r13d
leal (%rbx,%r13), %esi
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rsp, %rdi
movl $0x2d, %edx
callq 0x187a0
addq (%rsp), %r13
movq %r13, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x2ac53
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x18770
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1de50
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
addq $0x4, %r12
cmpq 0x28(%rsp), %r12
jne 0x1dd80
leaq 0x8c012(%rip), %rsi # 0xa9e78
movl $0x2, %edx
leaq 0x40(%rsp), %rdi
callq 0x18770
movq 0x20(%rsp), %rbx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x18a40
movq 0xc00aa(%rip), %rsi # 0xddf38
leaq 0x30(%rsp), %rdi
callq 0x18500
leaq 0xb0(%rsp), %rdi
callq 0x18200
movq %rbx, %rax
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1dec0
jmp 0x1dec0
jmp 0x1dec0
movq %rax, %rbx
jmp 0x1dee3
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1dee3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
movq 0xc004e(%rip), %rsi # 0xddf38
leaq 0x30(%rsp), %rdi
callq 0x18500
leaq 0xb0(%rsp), %rdi
callq 0x18200
movq %rbx, %rdi
callq 0x18ba0
| _Z11string_fromB5cxx11RKSt6vectorIiSaIiEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1B8h
mov rbx, rsi
mov [rsp+1E8h+var_1C8], rdi
lea rdi, [rsp+1E8h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea rdi, [rsp+1E8h+var_1A8]
lea rsi, asc_A9E75; "[ "
mov edx, 2
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r12, [rbx]
mov rax, [rbx+8]
mov [rsp+1E8h+var_1C0], rax
cmp r12, rax
jz loc_1DE5F
mov r14b, 1
mov r15d, 0D1B71759h
loc_1DD80:
mov r13d, [r12]
test r14b, 1
jz short loc_1DD8F
xor r14d, r14d
jmp short loc_1DDA5
loc_1DD8F:
mov edx, 2
lea rdi, [rsp+1E8h+var_1A8]
lea rsi, aZuD+6; ", "
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_1DDA5:
mov ebp, r13d
neg ebp
cmovs ebp, r13d
mov ebx, 1
cmp ebp, 0Ah
jb short loc_1DDF4
mov ebx, 4
mov eax, ebp
loc_1DDBF:
cmp eax, 63h ; 'c'
jbe short loc_1DDED
cmp eax, 3E7h
jbe short loc_1DDF2
cmp eax, 2710h
jb short loc_1DDF4
mov ecx, eax
imul rcx, r15
shr rcx, 2Dh
add ebx, 4
cmp eax, 1869Fh
mov eax, ecx
ja short loc_1DDBF
add ebx, 0FFFFFFFDh
jmp short loc_1DDF4
loc_1DDED:
add ebx, 0FFFFFFFEh
jmp short loc_1DDF4
loc_1DDF2:
dec ebx
loc_1DDF4:
shr r13d, 1Fh
lea esi, [rbx+r13]
lea rax, [rsp+1E8h+var_1D8]
mov [rsp+1E8h+var_1E8], rax
mov rdi, rsp
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
add r13, [rsp+1E8h+var_1E8]
mov rdi, r13
mov esi, ebx
mov edx, ebp
call _ZNSt8__detail18__to_chars_10_implIjEEvPcjT_; std::__detail::__to_chars_10_impl<uint>(char *,uint,uint)
mov rsi, [rsp+1E8h+var_1E8]
mov rdx, [rsp+1E8h+var_1E0]
lea rdi, [rsp+1E8h+var_1A8]
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+1E8h+var_1E8]; void *
lea rax, [rsp+1E8h+var_1D8]
cmp rdi, rax
jz short loc_1DE50
mov rsi, [rsp+1E8h+var_1D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DE50:
add r12, 4
cmp r12, [rsp+1E8h+var_1C0]
jnz loc_1DD80
loc_1DE5F:
lea rsi, asc_A9E78; " ]"
mov edx, 2
lea rdi, [rsp+1E8h+var_1A8]
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+1E8h+var_1C8]
lea rsi, [rsp+1E8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1E8h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1E8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 1B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_1DEC0
jmp short loc_1DEC0
jmp short $+2
loc_1DEC0:
mov rbx, rax
jmp short loc_1DEE3
mov rbx, rax
mov rdi, [rsp+0]; void *
lea rax, [rsp+arg_8]
cmp rdi, rax
jz short loc_1DEE3
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DEE3:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_28]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+arg_A8]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long string_from[abi:cxx11](long long a1, int **a2)
{
int *v2; // r12
char v3; // r14
int v4; // r13d
unsigned int v5; // ebp
unsigned int v6; // ebx
unsigned int v7; // eax
bool v8; // cc
unsigned int v9; // r13d
long long v10; // rbx
void *v12[2]; // [rsp+0h] [rbp-1E8h] BYREF
_QWORD v13[2]; // [rsp+10h] [rbp-1D8h] BYREF
long long v14; // [rsp+20h] [rbp-1C8h]
int *v15; // [rsp+28h] [rbp-1C0h]
_BYTE v16[16]; // [rsp+30h] [rbp-1B8h] BYREF
char v17[8]; // [rsp+40h] [rbp-1A8h] BYREF
char v18[104]; // [rsp+48h] [rbp-1A0h] BYREF
char v19[312]; // [rsp+B0h] [rbp-138h] BYREF
v14 = a1;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v16);
std::__ostream_insert<char,std::char_traits<char>>(v17, "[ ", 2LL);
v2 = *a2;
v15 = a2[1];
if ( v2 != v15 )
{
v3 = 1;
do
{
v4 = *v2;
if ( (v3 & 1) != 0 )
v3 = 0;
else
std::__ostream_insert<char,std::char_traits<char>>(v17, ", ", 2LL);
v5 = -v4;
if ( v4 > 0 )
v5 = v4;
v6 = 1;
if ( v5 >= 0xA )
{
v6 = 4;
v7 = v5;
while ( 1 )
{
if ( v7 <= 0x63 )
{
v6 -= 2;
goto LABEL_17;
}
if ( v7 <= 0x3E7 )
break;
if ( v7 < 0x2710 )
goto LABEL_17;
v6 += 4;
v8 = v7 <= 0x1869F;
v7 /= 0x2710u;
if ( v8 )
{
v6 -= 3;
goto LABEL_17;
}
}
--v6;
}
LABEL_17:
v9 = (unsigned int)v4 >> 31;
v12[0] = v13;
std::string::_M_construct(v12, v6 + v9, 45LL);
std::__detail::__to_chars_10_impl<unsigned int>((char *)v12[0] + v9, v6, v5);
std::__ostream_insert<char,std::char_traits<char>>(v17, v12[0], v12[1]);
if ( v12[0] != v13 )
operator delete(v12[0], v13[0] + 1LL);
++v2;
}
while ( v2 != v15 );
}
std::__ostream_insert<char,std::char_traits<char>>(v17, " ]", 2LL);
v10 = v14;
std::stringbuf::str(v14, v18);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v16,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>);
std::ios_base::~ios_base((std::ios_base *)v19);
return v10;
}
| string_from[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1b8
MOV RBX,RSI
MOV qword ptr [RSP + 0x20],RDI
LEA RDI,[RSP + 0x30]
CALL 0x001184c0
LEA RDI,[RSP + 0x40]
LAB_0011dd51:
LEA RSI,[0x1a9e75]
MOV EDX,0x2
CALL 0x00118770
MOV R12,qword ptr [RBX]
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RSP + 0x28],RAX
CMP R12,RAX
JZ 0x0011de5f
MOV R14B,0x1
MOV R15D,0xd1b71759
LAB_0011dd80:
MOV R13D,dword ptr [R12]
TEST R14B,0x1
JZ 0x0011dd8f
XOR R14D,R14D
JMP 0x0011dda5
LAB_0011dd8f:
MOV EDX,0x2
LEA RDI,[RSP + 0x40]
LEA RSI,[0x1aa81c]
CALL 0x00118770
LAB_0011dda5:
MOV EBP,R13D
NEG EBP
CMOVS EBP,R13D
MOV EBX,0x1
CMP EBP,0xa
JC 0x0011ddf4
MOV EBX,0x4
MOV EAX,EBP
LAB_0011ddbf:
CMP EAX,0x63
JBE 0x0011dded
CMP EAX,0x3e7
JBE 0x0011ddf2
CMP EAX,0x2710
JC 0x0011ddf4
MOV ECX,EAX
IMUL RCX,R15
SHR RCX,0x2d
ADD EBX,0x4
CMP EAX,0x1869f
MOV EAX,ECX
JA 0x0011ddbf
ADD EBX,-0x3
JMP 0x0011ddf4
LAB_0011dded:
ADD EBX,-0x2
JMP 0x0011ddf4
LAB_0011ddf2:
DEC EBX
LAB_0011ddf4:
SHR R13D,0x1f
LEA ESI,[RBX + R13*0x1]
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
LAB_0011de05:
MOV RDI,RSP
MOV EDX,0x2d
CALL 0x001187a0
ADD R13,qword ptr [RSP]
MOV RDI,R13
MOV ESI,EBX
MOV EDX,EBP
CALL 0x0012ac53
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
LAB_0011de2b:
LEA RDI,[RSP + 0x40]
CALL 0x00118770
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x0011de50
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001186a0
LAB_0011de50:
ADD R12,0x4
CMP R12,qword ptr [RSP + 0x28]
JNZ 0x0011dd80
LAB_0011de5f:
LEA RSI,[0x1a9e78]
MOV EDX,0x2
LEA RDI,[RSP + 0x40]
CALL 0x00118770
MOV RBX,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0x48]
MOV RDI,RBX
CALL 0x00118a40
LAB_0011de87:
MOV RSI,qword ptr [0x001ddf38]
LEA RDI,[RSP + 0x30]
CALL 0x00118500
LEA RDI,[RSP + 0xb0]
CALL 0x00118200
MOV RAX,RBX
ADD RSP,0x1b8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_from[abi:cxx11](std::vector<int, std::allocator<int> > const&) */
vector * string_from_abi_cxx11_(vector *param_1)
{
uint uVar1;
uint uVar2;
vector *pvVar3;
uint uVar4;
uint uVar5;
ulong uVar6;
uint uVar7;
int8 *in_RSI;
uint *puVar8;
bool bVar9;
long *local_1e8;
long local_1e0;
long local_1d8 [2];
vector *local_1c8;
uint *local_1c0;
stringstream local_1b8 [16];
ostream local_1a8 [112];
ios_base local_138 [264];
local_1c8 = param_1;
std::__cxx11::stringstream::stringstream(local_1b8);
/* try { // try from 0011dd51 to 0011dd61 has its CatchHandler @ 0011deba */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"[ ",2);
puVar8 = (uint *)*in_RSI;
local_1c0 = (uint *)in_RSI[1];
if (puVar8 != local_1c0) {
bVar9 = true;
do {
uVar1 = *puVar8;
if (bVar9) {
bVar9 = false;
}
else {
/* try { // try from 0011dd8f to 0011dda4 has its CatchHandler @ 0011debe */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,", ",2);
}
uVar2 = -uVar1;
if (0 < (int)uVar1) {
uVar2 = uVar1;
}
uVar7 = 1;
if (9 < uVar2) {
uVar6 = (ulong)uVar2;
uVar4 = 4;
do {
uVar7 = uVar4;
uVar5 = (uint)uVar6;
if (uVar5 < 100) {
uVar7 = uVar7 - 2;
goto LAB_0011ddf4;
}
if (uVar5 < 1000) {
uVar7 = uVar7 - 1;
goto LAB_0011ddf4;
}
if (uVar5 < 10000) goto LAB_0011ddf4;
uVar6 = uVar6 / 10000;
uVar4 = uVar7 + 4;
} while (99999 < uVar5);
uVar7 = uVar7 + 1;
}
LAB_0011ddf4:
local_1e8 = local_1d8;
/* try { // try from 0011de05 to 0011de11 has its CatchHandler @ 0011dec0 */
std::__cxx11::string::_M_construct((ulong)&local_1e8,(char)uVar7 - (char)((int)uVar1 >> 0x1f))
;
std::__detail::__to_chars_10_impl<unsigned_int>
((char *)((long)local_1e8 + (ulong)(uVar1 >> 0x1f)),uVar7,uVar2);
/* try { // try from 0011de2b to 0011de34 has its CatchHandler @ 0011dec5 */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,(char *)local_1e8,local_1e0);
if (local_1e8 != local_1d8) {
operator_delete(local_1e8,local_1d8[0] + 1);
}
puVar8 = puVar8 + 1;
} while (puVar8 != local_1c0);
}
/* try { // try from 0011de5f to 0011de86 has its CatchHandler @ 0011debc */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8," ]",2);
pvVar3 = local_1c8;
std::__cxx11::stringbuf::str();
std::__cxx11::stringstream::~stringstream(local_1b8);
std::ios_base::~ios_base(local_138);
return pvVar3;
}
|
|
6,461 | append_stmt_result(st_dynamic_string*, st_mysql_stmt*, st_mysql_field*, unsigned int) | eloqsql/client/mysqltest.cc | void append_stmt_result(DYNAMIC_STRING *ds, MYSQL_STMT *stmt,
MYSQL_FIELD *fields, uint num_fields)
{
MYSQL_BIND *my_bind;
my_bool *is_null;
ulong *length;
uint i;
int error;
/* Allocate array with bind structs, lengths and NULL flags */
my_bind= (MYSQL_BIND*) my_malloc(PSI_NOT_INSTRUMENTED, num_fields * sizeof(MYSQL_BIND),
MYF(MY_WME | MY_FAE | MY_ZEROFILL));
length= (ulong*) my_malloc(PSI_NOT_INSTRUMENTED, num_fields * sizeof(ulong),
MYF(MY_WME | MY_FAE));
is_null= (my_bool*) my_malloc(PSI_NOT_INSTRUMENTED, num_fields * sizeof(my_bool),
MYF(MY_WME | MY_FAE));
/* Allocate data for the result of each field */
for (i= 0; i < num_fields; i++)
{
uint max_length= fields[i].max_length + 1;
my_bind[i].buffer_type= MYSQL_TYPE_STRING;
my_bind[i].buffer= my_malloc(PSI_NOT_INSTRUMENTED, max_length, MYF(MY_WME | MY_FAE));
my_bind[i].buffer_length= max_length;
my_bind[i].is_null= &is_null[i];
my_bind[i].length= &length[i];
DBUG_PRINT("bind", ("col[%d]: buffer_type: %d, buffer_length: %lu",
i, my_bind[i].buffer_type, my_bind[i].buffer_length));
}
if (mysql_stmt_bind_result(stmt, my_bind))
die("mysql_stmt_bind_result failed: %d: %s",
mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
while ((error=mysql_stmt_fetch(stmt)) == 0)
{
for (i= 0; i < num_fields; i++)
append_field(ds, i, &fields[i], (char*)my_bind[i].buffer,
*my_bind[i].length, *my_bind[i].is_null);
if (!display_result_vertically)
dynstr_append_mem(ds, "\n", 1);
}
if (error != MYSQL_NO_DATA)
die("mysql_fetch didn't end with MYSQL_NO_DATA from statement: "
"error: %d", error);
if (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
die("mysql_fetch didn't end with MYSQL_NO_DATA from statement: %d %s",
mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
for (i= 0; i < num_fields; i++)
{
/* Free data for output */
my_free(my_bind[i].buffer);
}
/* Free array with bind structs, lengths and NULL flags */
my_free(my_bind);
my_free(length);
my_free(is_null);
} | O0 | cpp | append_stmt_result(st_dynamic_string*, st_mysql_stmt*, st_mysql_field*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
imulq $0x70, %rax, %rsi
xorl %edi, %edi
movl $0x38, %edx
callq 0xc2350
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
shlq $0x3, %rsi
xorl %edi, %edi
movl $0x18, %edx
callq 0xc2350
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
shlq $0x0, %rsi
xorl %edi, %edi
movl $0x18, %edx
callq 0xc2350
movq %rax, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x6e6db
movq -0x18(%rbp), %rax
movl -0x3c(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rax
addq $0x1, %rax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl $0xfe, 0x60(%rax)
movl -0x44(%rbp), %eax
movl %eax, %esi
xorl %edi, %edi
movl $0x18, %edx
callq 0xc2350
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %edx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl -0x44(%rbp), %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %edx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x40(%rax)
movq -0x30(%rbp), %rcx
movl -0x3c(%rbp), %eax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %edx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %edx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x6e6cb
jmp 0x6e6cd
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6e617
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8dbb0
cmpb $0x0, %al
je 0x6e715
movq -0x10(%rbp), %rdi
callq 0x8e220
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8e240
movl -0x48(%rbp), %esi
movq %rax, %rdx
leaq 0xdecc7(%rip), %rdi # 0x14d3d5
movb $0x0, %al
callq 0x62b40
jmp 0x6e717
movq -0x10(%rbp), %rdi
callq 0x61bb0
movl %eax, -0x40(%rbp)
cmpl $0x0, %eax
jne 0x6e7c1
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x6e79e
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x3c(%rbp), %eax
shlq $0x7, %rax
addq %rax, %rdx
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %r8d
imulq $0x70, %r8, %r8
addq %r8, %rax
movq (%rax), %rax
movq (%rax), %r8
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %r9d
imulq $0x70, %r9, %r9
addq %r9, %rax
movq 0x8(%rax), %rax
movsbl (%rax), %r9d
callq 0x6e390
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6e733
cmpb $0x0, 0x44ce6b(%rip) # 0x4bb610
jne 0x6e7bc
movq -0x8(%rbp), %rdi
leaq 0xdeafd(%rip), %rsi # 0x14d2af
movl $0x1, %edx
callq 0xc5f40
jmp 0x6e717
cmpl $0x64, -0x40(%rbp)
je 0x6e7d8
movl -0x40(%rbp), %esi
leaq 0xdec2a(%rip), %rdi # 0x14d3fb
movb $0x0, %al
callq 0x62b40
movq -0x10(%rbp), %rdi
callq 0x61bb0
cmpl $0x64, %eax
je 0x6e80f
movq -0x10(%rbp), %rdi
callq 0x8e220
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8e240
movl -0x4c(%rbp), %esi
movq %rax, %rdx
leaq 0xdec37(%rip), %rdi # 0x14d43f
movb $0x0, %al
callq 0x62b40
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x6e840
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0xc26d0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6e816
movq -0x28(%rbp), %rdi
callq 0xc26d0
movq -0x38(%rbp), %rdi
callq 0xc26d0
movq -0x30(%rbp), %rdi
callq 0xc26d0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _Z18append_stmt_resultP17st_dynamic_stringP13st_mysql_stmtP14st_mysql_fieldj:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov eax, [rbp+var_1C]
imul rsi, rax, 70h ; 'p'
xor edi, edi
mov edx, 38h ; '8'
call my_malloc
mov [rbp+var_28], rax
mov eax, [rbp+var_1C]
mov esi, eax
shl rsi, 3
xor edi, edi
mov edx, 18h
call my_malloc
mov [rbp+var_38], rax
mov eax, [rbp+var_1C]
mov esi, eax
shl rsi, 0
xor edi, edi
mov edx, 18h
call my_malloc
mov [rbp+var_30], rax
mov [rbp+var_3C], 0
loc_6E617:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_1C]
jnb loc_6E6DB
mov rax, [rbp+var_18]
mov ecx, [rbp+var_3C]
shl rcx, 7
add rax, rcx
mov rax, [rax+40h]
add rax, 1
mov [rbp+var_44], eax
mov rax, [rbp+var_28]
mov ecx, [rbp+var_3C]
imul rcx, 70h ; 'p'
add rax, rcx
mov dword ptr [rax+60h], 0FEh
mov eax, [rbp+var_44]
mov esi, eax
xor edi, edi
mov edx, 18h
call my_malloc
mov rcx, rax
mov rax, [rbp+var_28]
mov edx, [rbp+var_3C]
imul rdx, 70h ; 'p'
add rax, rdx
mov [rax+10h], rcx
mov eax, [rbp+var_44]
mov ecx, eax
mov rax, [rbp+var_28]
mov edx, [rbp+var_3C]
imul rdx, 70h ; 'p'
add rax, rdx
mov [rax+40h], rcx
mov rcx, [rbp+var_30]
mov eax, [rbp+var_3C]
add rcx, rax
mov rax, [rbp+var_28]
mov edx, [rbp+var_3C]
imul rdx, 70h ; 'p'
add rax, rdx
mov [rax+8], rcx
mov rcx, [rbp+var_38]
mov eax, [rbp+var_3C]
shl rax, 3
add rcx, rax
mov rax, [rbp+var_28]
mov edx, [rbp+var_3C]
imul rdx, 70h ; 'p'
add rax, rdx
mov [rax], rcx
jmp short $+2
loc_6E6CB:
jmp short $+2
loc_6E6CD:
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp loc_6E617
loc_6E6DB:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call mysql_stmt_bind_result
cmp al, 0
jz short loc_6E715
mov rdi, [rbp+var_10]
call mysql_stmt_errno
mov [rbp+var_48], eax
mov rdi, [rbp+var_10]
call mysql_stmt_error
mov esi, [rbp+var_48]
mov rdx, rax
lea rdi, aMysqlStmtBindR_0; "mysql_stmt_bind_result failed: %d: %s"
mov al, 0
call _ZL3diePKcz; die(char const*,...)
loc_6E715:
jmp short $+2
loc_6E717:
mov rdi, [rbp+var_10]
call _Z21wrap_mysql_stmt_fetchP13st_mysql_stmt; wrap_mysql_stmt_fetch(st_mysql_stmt *)
mov [rbp+var_40], eax
cmp eax, 0
jnz loc_6E7C1
mov [rbp+var_3C], 0
loc_6E733:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_1C]
jnb short loc_6E79E
mov rdi, [rbp+var_8]
mov esi, [rbp+var_3C]
mov rdx, [rbp+var_18]
mov eax, [rbp+var_3C]
shl rax, 7
add rdx, rax
mov rax, [rbp+var_28]
mov ecx, [rbp+var_3C]
imul rcx, 70h ; 'p'
add rax, rcx
mov rcx, [rax+10h]
mov rax, [rbp+var_28]
mov r8d, [rbp+var_3C]
imul r8, 70h ; 'p'
add rax, r8
mov rax, [rax]
mov r8, [rax]
mov rax, [rbp+var_28]
mov r9d, [rbp+var_3C]
imul r9, 70h ; 'p'
add rax, r9
mov rax, [rax+8]
movsx r9d, byte ptr [rax]
call _Z12append_fieldP17st_dynamic_stringjP14st_mysql_fieldPcmc; append_field(st_dynamic_string *,uint,st_mysql_field *,char *,ulong,char)
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp short loc_6E733
loc_6E79E:
cmp cs:_ZL25display_result_vertically, 0; display_result_vertically
jnz short loc_6E7BC
mov rdi, [rbp+var_8]
lea rsi, aRunsATestAgain+50h; "\n"
mov edx, 1
call dynstr_append_mem
loc_6E7BC:
jmp loc_6E717
loc_6E7C1:
cmp [rbp+var_40], 64h ; 'd'
jz short loc_6E7D8
mov esi, [rbp+var_40]
lea rdi, aMysqlFetchDidn; "mysql_fetch didn't end with MYSQL_NO_DA"...
mov al, 0
call _ZL3diePKcz; die(char const*,...)
loc_6E7D8:
mov rdi, [rbp+var_10]
call _Z21wrap_mysql_stmt_fetchP13st_mysql_stmt; wrap_mysql_stmt_fetch(st_mysql_stmt *)
cmp eax, 64h ; 'd'
jz short loc_6E80F
mov rdi, [rbp+var_10]
call mysql_stmt_errno
mov [rbp+var_4C], eax
mov rdi, [rbp+var_10]
call mysql_stmt_error
mov esi, [rbp+var_4C]
mov rdx, rax
lea rdi, aMysqlFetchDidn_0; "mysql_fetch didn't end with MYSQL_NO_DA"...
mov al, 0
call _ZL3diePKcz; die(char const*,...)
loc_6E80F:
mov [rbp+var_3C], 0
loc_6E816:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_1C]
jnb short loc_6E840
mov rax, [rbp+var_28]
mov ecx, [rbp+var_3C]
imul rcx, 70h ; 'p'
add rax, rcx
mov rdi, [rax+10h]
call my_free
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp short loc_6E816
loc_6E840:
mov rdi, [rbp+var_28]
call my_free
mov rdi, [rbp+var_38]
call my_free
mov rdi, [rbp+var_30]
call my_free
add rsp, 50h
pop rbp
retn
| long long append_stmt_result(long long a1, long long a2, long long a3, unsigned int a4)
{
const char *v4; // rax
const char *v5; // rax
int v7; // [rsp+4h] [rbp-4Ch]
int v8; // [rsp+8h] [rbp-48h]
unsigned int v9; // [rsp+Ch] [rbp-44h]
int v10; // [rsp+10h] [rbp-40h]
unsigned int i; // [rsp+14h] [rbp-3Ch]
unsigned int j; // [rsp+14h] [rbp-3Ch]
unsigned int k; // [rsp+14h] [rbp-3Ch]
long long v14; // [rsp+18h] [rbp-38h]
long long v15; // [rsp+20h] [rbp-30h]
long long v16; // [rsp+28h] [rbp-28h]
v16 = my_malloc(0LL, 112LL * a4, 56LL);
v14 = my_malloc(0LL, 8LL * a4, 24LL);
v15 = my_malloc(0LL, a4, 24LL);
for ( i = 0; i < a4; ++i )
{
v9 = *(_QWORD *)(((unsigned long long)i << 7) + a3 + 64) + 1;
*(_DWORD *)(112LL * i + v16 + 96) = 254;
*(_QWORD *)(112LL * i + v16 + 16) = my_malloc(0LL, v9, 24LL);
*(_QWORD *)(112LL * i + v16 + 64) = v9;
*(_QWORD *)(112LL * i + v16 + 8) = i + v15;
*(_QWORD *)(112LL * i + v16) = 8LL * i + v14;
}
if ( (unsigned __int8)mysql_stmt_bind_result(a2, v16) )
{
v8 = mysql_stmt_errno(a2);
v4 = (const char *)mysql_stmt_error(a2);
die("mysql_stmt_bind_result failed: %d: %s", v8, v4);
}
while ( 1 )
{
v10 = wrap_mysql_stmt_fetch(a2);
if ( v10 )
break;
for ( j = 0; j < a4; ++j )
append_field(
a1,
j,
(_QWORD *)(((unsigned long long)j << 7) + a3),
*(char **)(112LL * j + v16 + 16),
**(_QWORD **)(112LL * j + v16),
**(_BYTE **)(112LL * j + v16 + 8));
if ( !display_result_vertically )
dynstr_append_mem(a1, "\n", 1LL);
}
if ( v10 != 100 )
die("mysql_fetch didn't end with MYSQL_NO_DATA from statement: error: %d", v10);
if ( (unsigned int)wrap_mysql_stmt_fetch(a2) != 100 )
{
v7 = mysql_stmt_errno(a2);
v5 = (const char *)mysql_stmt_error(a2);
die("mysql_fetch didn't end with MYSQL_NO_DATA from statement: %d %s", v7, v5);
}
for ( k = 0; k < a4; ++k )
my_free(*(_QWORD *)(112LL * k + v16 + 16));
my_free(v16);
my_free(v14);
return my_free(v15);
}
| append_stmt_result:
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 dword ptr [RBP + -0x1c],ECX
MOV EAX,dword ptr [RBP + -0x1c]
IMUL RSI,RAX,0x70
XOR EDI,EDI
MOV EDX,0x38
CALL 0x001c2350
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV ESI,EAX
SHL RSI,0x3
XOR EDI,EDI
MOV EDX,0x18
CALL 0x001c2350
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV ESI,EAX
SHL RSI,0x0
XOR EDI,EDI
MOV EDX,0x18
CALL 0x001c2350
MOV qword ptr [RBP + -0x30],RAX
MOV dword ptr [RBP + -0x3c],0x0
LAB_0016e617:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x1c]
JNC 0x0016e6db
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x3c]
SHL RCX,0x7
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x40]
ADD RAX,0x1
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV dword ptr [RAX + 0x60],0xfe
MOV EAX,dword ptr [RBP + -0x44]
MOV ESI,EAX
XOR EDI,EDI
MOV EDX,0x18
CALL 0x001c2350
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x3c]
IMUL RDX,RDX,0x70
ADD RAX,RDX
MOV qword ptr [RAX + 0x10],RCX
MOV EAX,dword ptr [RBP + -0x44]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x3c]
IMUL RDX,RDX,0x70
ADD RAX,RDX
MOV qword ptr [RAX + 0x40],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x3c]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x3c]
IMUL RDX,RDX,0x70
ADD RAX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x3c]
SHL RAX,0x3
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x3c]
IMUL RDX,RDX,0x70
ADD RAX,RDX
MOV qword ptr [RAX],RCX
JMP 0x0016e6cb
LAB_0016e6cb:
JMP 0x0016e6cd
LAB_0016e6cd:
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0016e617
LAB_0016e6db:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x0018dbb0
CMP AL,0x0
JZ 0x0016e715
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0018e220
MOV dword ptr [RBP + -0x48],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0018e240
MOV ESI,dword ptr [RBP + -0x48]
MOV RDX,RAX
LEA RDI,[0x24d3d5]
MOV AL,0x0
CALL 0x00162b40
LAB_0016e715:
JMP 0x0016e717
LAB_0016e717:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00161bb0
MOV dword ptr [RBP + -0x40],EAX
CMP EAX,0x0
JNZ 0x0016e7c1
MOV dword ptr [RBP + -0x3c],0x0
LAB_0016e733:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x1c]
JNC 0x0016e79e
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0x3c]
MOV RDX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x3c]
SHL RAX,0x7
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RBP + -0x3c]
IMUL R8,R8,0x70
ADD RAX,R8
MOV RAX,qword ptr [RAX]
MOV R8,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV R9D,dword ptr [RBP + -0x3c]
IMUL R9,R9,0x70
ADD RAX,R9
MOV RAX,qword ptr [RAX + 0x8]
MOVSX R9D,byte ptr [RAX]
CALL 0x0016e390
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0016e733
LAB_0016e79e:
CMP byte ptr [0x005bb610],0x0
JNZ 0x0016e7bc
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x24d2af]
MOV EDX,0x1
CALL 0x001c5f40
LAB_0016e7bc:
JMP 0x0016e717
LAB_0016e7c1:
CMP dword ptr [RBP + -0x40],0x64
JZ 0x0016e7d8
MOV ESI,dword ptr [RBP + -0x40]
LEA RDI,[0x24d3fb]
MOV AL,0x0
CALL 0x00162b40
LAB_0016e7d8:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00161bb0
CMP EAX,0x64
JZ 0x0016e80f
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0018e220
MOV dword ptr [RBP + -0x4c],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0018e240
MOV ESI,dword ptr [RBP + -0x4c]
MOV RDX,RAX
LEA RDI,[0x24d43f]
MOV AL,0x0
CALL 0x00162b40
LAB_0016e80f:
MOV dword ptr [RBP + -0x3c],0x0
LAB_0016e816:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x1c]
JNC 0x0016e840
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x001c26d0
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0016e816
LAB_0016e840:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001c26d0
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001c26d0
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001c26d0
ADD RSP,0x50
POP RBP
RET
|
/* append_stmt_result(st_dynamic_string*, st_mysql_stmt*, st_mysql_field*, unsigned int) */
void append_stmt_result(st_dynamic_string *param_1,st_mysql_stmt *param_2,st_mysql_field *param_3,
uint param_4)
{
char cVar1;
uint uVar2;
int iVar3;
long lVar4;
long lVar5;
long lVar6;
int8 uVar7;
uint local_44;
lVar4 = my_malloc(0,(ulong)param_4 * 0x70,0x38);
lVar5 = my_malloc(0,(ulong)param_4 << 3,0x18);
lVar6 = my_malloc(0,param_4,0x18);
for (local_44 = 0; local_44 < param_4; local_44 = local_44 + 1) {
uVar2 = (int)*(int8 *)(param_3 + (ulong)local_44 * 0x80 + 0x40) + 1;
*(int4 *)(lVar4 + (ulong)local_44 * 0x70 + 0x60) = 0xfe;
uVar7 = my_malloc(0,uVar2,0x18);
*(int8 *)(lVar4 + (ulong)local_44 * 0x70 + 0x10) = uVar7;
*(ulong *)(lVar4 + (ulong)local_44 * 0x70 + 0x40) = (ulong)uVar2;
*(ulong *)(lVar4 + (ulong)local_44 * 0x70 + 8) = lVar6 + (ulong)local_44;
*(ulong *)(lVar4 + (ulong)local_44 * 0x70) = lVar5 + (ulong)local_44 * 8;
}
cVar1 = mysql_stmt_bind_result(param_2,lVar4);
if (cVar1 != '\0') {
uVar2 = mysql_stmt_errno(param_2);
uVar7 = mysql_stmt_error(param_2);
die("mysql_stmt_bind_result failed: %d: %s",(ulong)uVar2,uVar7);
}
while (uVar2 = wrap_mysql_stmt_fetch(param_2), uVar2 == 0) {
for (local_44 = 0; local_44 < param_4; local_44 = local_44 + 1) {
append_field(param_1,local_44,param_3 + (ulong)local_44 * 0x80,
*(char **)(lVar4 + (ulong)local_44 * 0x70 + 0x10),
**(ulong **)(lVar4 + (ulong)local_44 * 0x70),
**(char **)(lVar4 + (ulong)local_44 * 0x70 + 8));
}
if (display_result_vertically == '\0') {
dynstr_append_mem(param_1,"\n",1);
}
}
if (uVar2 != 100) {
die("mysql_fetch didn\'t end with MYSQL_NO_DATA from statement: error: %d",(ulong)uVar2);
}
iVar3 = wrap_mysql_stmt_fetch(param_2);
if (iVar3 != 100) {
uVar2 = mysql_stmt_errno(param_2);
uVar7 = mysql_stmt_error(param_2);
die("mysql_fetch didn\'t end with MYSQL_NO_DATA from statement: %d %s",(ulong)uVar2,uVar7);
}
for (local_44 = 0; local_44 < param_4; local_44 = local_44 + 1) {
my_free(*(int8 *)(lVar4 + (ulong)local_44 * 0x70 + 0x10));
}
my_free(lVar4);
my_free(lVar5);
my_free(lVar6);
return;
}
|
|
6,462 | js_std_file_puts | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_puts(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
FILE *f;
int i;
const char *str;
size_t len;
if (magic == 0) {
f = stdout;
} else {
f = js_std_file_get(ctx, this_val);
if (!f)
return JS_EXCEPTION;
}
for(i = 0; i < argc; i++) {
str = JS_ToCStringLen(ctx, &len, argv[i]);
if (!str)
return JS_EXCEPTION;
fwrite(str, 1, len, f);
JS_FreeCString(ctx, str);
}
return JS_UNDEFINED;
} | O0 | c | js_std_file_puts:
subq $0x68, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x12a89
movq 0x123531(%rip), %rax # 0x135fb0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x12ac2
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x13a80
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x12ac0
movl $0x0, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
jmp 0x12b64
jmp 0x12ac2
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x12b53
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x8(%rsp), %rsi
callq 0x13b30
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x12b1b
movl $0x0, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
jmp 0x12b64
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x1, %esi
callq 0xe8c0
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x29e50
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x12aca
movl $0x0, 0x58(%rsp)
movq $0x3, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rdx
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
| js_std_file_puts:
sub rsp, 68h
mov [rsp+68h+var_20], rsi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_28], rdi
mov [rsp+68h+var_2C], ecx
mov [rsp+68h+var_38], r8
mov [rsp+68h+var_3C], r9d
cmp [rsp+68h+var_3C], 0
jnz short loc_12A89
mov rax, cs:stdout_ptr
mov rax, [rax]
mov [rsp+68h+var_48], rax
jmp short loc_12AC2
loc_12A89:
mov rdi, [rsp+68h+var_28]
mov rsi, [rsp+68h+var_20]
mov rdx, [rsp+68h+var_18]
call js_std_file_get
mov [rsp+68h+var_48], rax
cmp [rsp+68h+var_48], 0
jnz short loc_12AC0
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 6
jmp loc_12B64
loc_12AC0:
jmp short $+2
loc_12AC2:
mov [rsp+68h+var_4C], 0
loc_12ACA:
mov eax, [rsp+68h+var_4C]
cmp eax, [rsp+68h+var_2C]
jge short loc_12B53
mov rdi, [rsp+68h+var_28]
mov rax, [rsp+68h+var_38]
movsxd rcx, [rsp+68h+var_4C]
shl rcx, 4
add rax, rcx
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+68h+var_60]
call JS_ToCStringLen
mov [rsp+68h+var_58], rax
cmp [rsp+68h+var_58], 0
jnz short loc_12B1B
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 6
jmp short loc_12B64
loc_12B1B:
mov rdi, [rsp+68h+var_58]
mov rdx, [rsp+68h+var_60]
mov rcx, [rsp+68h+var_48]
mov esi, 1
call _fwrite
mov rdi, [rsp+68h+var_28]
mov rsi, [rsp+68h+var_58]
call JS_FreeCString
mov eax, [rsp+68h+var_4C]
add eax, 1
mov [rsp+68h+var_4C], eax
jmp loc_12ACA
loc_12B53:
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 3
loc_12B64:
mov rax, [rsp+68h+var_10]
mov rdx, [rsp+68h+var_8]
add rsp, 68h
retn
| long long js_std_file_puts(long long a1, long long a2, long long a3, int a4, long long a5, int a6)
{
long long v7; // [rsp+8h] [rbp-60h] BYREF
long long v8; // [rsp+10h] [rbp-58h]
int i; // [rsp+1Ch] [rbp-4Ch]
long long v10; // [rsp+20h] [rbp-48h]
int v11; // [rsp+2Ch] [rbp-3Ch]
long long v12; // [rsp+30h] [rbp-38h]
int v13; // [rsp+3Ch] [rbp-2Ch]
long long v14; // [rsp+40h] [rbp-28h]
long long v15; // [rsp+48h] [rbp-20h]
long long v16; // [rsp+50h] [rbp-18h]
long long v17; // [rsp+58h] [rbp-10h]
long long v18; // [rsp+60h] [rbp-8h]
v15 = a2;
v16 = a3;
v14 = a1;
v13 = a4;
v12 = a5;
v11 = a6;
if ( a6 )
{
v10 = js_std_file_get(v14, v15, v16);
if ( !v10 )
{
LODWORD(v17) = 0;
v18 = 6LL;
return v17;
}
}
else
{
v10 = stdout;
}
for ( i = 0; i < v13; ++i )
{
v8 = JS_ToCStringLen(v14, &v7, *(_QWORD *)(16LL * i + v12), *(_QWORD *)(16LL * i + v12 + 8));
if ( !v8 )
{
LODWORD(v17) = 0;
v18 = 6LL;
return v17;
}
fwrite(v8, 1LL, v7, v10);
JS_FreeCString(v14, v8);
}
LODWORD(v17) = 0;
v18 = 3LL;
return v17;
}
| js_std_file_puts:
SUB RSP,0x68
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x40],RDI
MOV dword ptr [RSP + 0x3c],ECX
MOV qword ptr [RSP + 0x30],R8
MOV dword ptr [RSP + 0x2c],R9D
CMP dword ptr [RSP + 0x2c],0x0
JNZ 0x00112a89
MOV RAX,qword ptr [0x00235fb0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x20],RAX
JMP 0x00112ac2
LAB_00112a89:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x00113a80
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x20],0x0
JNZ 0x00112ac0
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x6
JMP 0x00112b64
LAB_00112ac0:
JMP 0x00112ac2
LAB_00112ac2:
MOV dword ptr [RSP + 0x1c],0x0
LAB_00112aca:
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,dword ptr [RSP + 0x3c]
JGE 0x00112b53
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,dword ptr [RSP + 0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
CALL 0x00113b30
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x00112b1b
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x6
JMP 0x00112b64
LAB_00112b1b:
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x20]
MOV ESI,0x1
CALL 0x0010e8c0
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00129e50
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x00112aca
LAB_00112b53:
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x3
LAB_00112b64:
MOV RAX,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
ADD RSP,0x68
RET
|
int1 [16]
js_std_file_puts(int8 param_1,int8 param_2,int8 param_3,int param_4,long param_5,
int param_6)
{
int1 auVar1 [16];
int8 *puVar2;
size_t local_60;
void *local_58;
int local_4c;
FILE *local_48;
int local_3c;
long local_38;
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 uStack_c;
int8 local_8;
local_3c = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
if (param_6 == 0) {
local_48 = *(FILE **)PTR_stdout_00235fb0;
}
else {
local_48 = (FILE *)js_std_file_get(param_1,param_2,param_3);
if (local_48 == (FILE *)0x0) {
local_8 = 6;
goto LAB_00112b64;
}
}
for (local_4c = 0; local_4c < local_2c; local_4c = local_4c + 1) {
puVar2 = (int8 *)(local_38 + (long)local_4c * 0x10);
local_58 = (void *)JS_ToCStringLen(local_28,&local_60,*puVar2,puVar2[1]);
if (local_58 == (void *)0x0) {
local_8 = 6;
goto LAB_00112b64;
}
fwrite(local_58,1,local_60,local_48);
JS_FreeCString(local_28,local_58);
}
local_8 = 3;
LAB_00112b64:
auVar1._4_8_ = local_8;
auVar1._0_4_ = uStack_c;
auVar1._12_4_ = 0;
return auVar1 << 0x20;
}
|
|
6,463 | js_std_file_puts | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_puts(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
FILE *f;
int i;
const char *str;
size_t len;
if (magic == 0) {
f = stdout;
} else {
f = js_std_file_get(ctx, this_val);
if (!f)
return JS_EXCEPTION;
}
for(i = 0; i < argc; i++) {
str = JS_ToCStringLen(ctx, &len, argv[i]);
if (!str)
return JS_EXCEPTION;
fwrite(str, 1, len, f);
JS_FreeCString(ctx, str);
}
return JS_UNDEFINED;
} | O1 | c | js_std_file_puts:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdi, %r14
testl %r9d, %r9d
je 0x15fa6
movq %r14, %rdi
callq 0x16588
movq %rax, %r12
testq %rax, %rax
jne 0x15fb0
movl $0x6, %edx
jmp 0x1600f
movq 0xb7003(%rip), %rax # 0xccfb0
movq (%rax), %r12
movl $0x3, %edx
testl %ebp, %ebp
jle 0x1600f
movl %ebp, %r15d
shlq $0x4, %r15
xorl %r13d, %r13d
movq (%rbx,%r13), %rdx
movq 0x8(%rbx,%r13), %rcx
movq %r14, %rdi
movq %rsp, %rsi
xorl %r8d, %r8d
callq 0x20bf7
testq %rax, %rax
je 0x15f9f
movq %rax, %rbp
movq (%rsp), %rdx
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rcx
callq 0xe8d0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x20edd
addq $0x10, %r13
cmpq %r13, %r15
jne 0x15fc3
movl $0x3, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_std_file_puts:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r8
mov ebp, ecx
mov r14, rdi
test r9d, r9d
jz short loc_15FA6
mov rdi, r14
call js_std_file_get
mov r12, rax
test rax, rax
jnz short loc_15FB0
loc_15F9F:
mov edx, 6
jmp short loc_1600F
loc_15FA6:
mov rax, cs:stdout_ptr
mov r12, [rax]
loc_15FB0:
mov edx, 3
test ebp, ebp
jle short loc_1600F
mov r15d, ebp
shl r15, 4
xor r13d, r13d
loc_15FC3:
mov rdx, [rbx+r13]
mov rcx, [rbx+r13+8]
mov rdi, r14
mov rsi, rsp
xor r8d, r8d
call JS_ToCStringLen2
test rax, rax
jz short loc_15F9F
mov rbp, rax
mov rdx, [rsp+38h+var_38]
mov esi, 1
mov rdi, rax
mov rcx, r12
call _fwrite
mov rdi, r14
mov rsi, rbp
call JS_FreeCString
add r13, 10h
cmp r15, r13
jnz short loc_15FC3
mov edx, 3
loc_1600F:
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_std_file_puts(long long a1, long long a2, long long a3, int a4, long long a5, int a6)
{
long long v6; // rax
long long v9; // r12
long long v10; // r15
long long v11; // r13
long long v12; // rax
long long v13; // rbp
_QWORD v15[7]; // [rsp+0h] [rbp-38h] BYREF
v15[0] = v6;
if ( a6 )
{
v9 = js_std_file_get(a1);
if ( !v9 )
return 0LL;
}
else
{
v9 = stdout;
}
if ( a4 > 0 )
{
v10 = 16LL * (unsigned int)a4;
v11 = 0LL;
do
{
v12 = JS_ToCStringLen2(a1, v15, *(_QWORD *)(a5 + v11), *(_QWORD *)(a5 + v11 + 8), 0LL);
if ( !v12 )
break;
v13 = v12;
fwrite(v12, 1LL, v15[0], v9);
JS_FreeCString(a1, v13);
v11 += 16LL;
}
while ( v10 != v11 );
}
return 0LL;
}
| js_std_file_puts:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV EBP,ECX
MOV R14,RDI
TEST R9D,R9D
JZ 0x00115fa6
MOV RDI,R14
CALL 0x00116588
MOV R12,RAX
TEST RAX,RAX
JNZ 0x00115fb0
LAB_00115f9f:
MOV EDX,0x6
JMP 0x0011600f
LAB_00115fa6:
MOV RAX,qword ptr [0x001ccfb0]
MOV R12,qword ptr [RAX]
LAB_00115fb0:
MOV EDX,0x3
TEST EBP,EBP
JLE 0x0011600f
MOV R15D,EBP
SHL R15,0x4
XOR R13D,R13D
LAB_00115fc3:
MOV RDX,qword ptr [RBX + R13*0x1]
MOV RCX,qword ptr [RBX + R13*0x1 + 0x8]
MOV RDI,R14
MOV RSI,RSP
XOR R8D,R8D
CALL 0x00120bf7
TEST RAX,RAX
JZ 0x00115f9f
MOV RBP,RAX
MOV RDX,qword ptr [RSP]
MOV ESI,0x1
MOV RDI,RAX
MOV RCX,R12
CALL 0x0010e8d0
MOV RDI,R14
MOV RSI,RBP
CALL 0x00120edd
ADD R13,0x10
CMP R15,R13
JNZ 0x00115fc3
MOV EDX,0x3
LAB_0011600f:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_std_file_puts(int8 param_1,int8 param_2,int8 param_3,uint param_4,long param_5,
int param_6)
{
int1 auVar1 [16];
size_t in_RAX;
FILE *__s;
void *__ptr;
ulong uVar2;
long lVar3;
size_t local_38;
local_38 = in_RAX;
if (param_6 == 0) {
__s = *(FILE **)PTR_stdout_001ccfb0;
}
else {
__s = (FILE *)js_std_file_get(param_1);
if (__s == (FILE *)0x0) {
LAB_00115f9f:
uVar2 = 6;
goto LAB_0011600f;
}
}
uVar2 = 3;
if (0 < (int)param_4) {
lVar3 = 0;
do {
__ptr = (void *)JS_ToCStringLen2(param_1,&local_38,*(int8 *)(param_5 + lVar3),
*(int8 *)(param_5 + 8 + lVar3),0);
if (__ptr == (void *)0x0) goto LAB_00115f9f;
fwrite(__ptr,1,local_38,__s);
JS_FreeCString(param_1,__ptr);
lVar3 = lVar3 + 0x10;
} while ((ulong)param_4 << 4 != lVar3);
uVar2 = 3;
}
LAB_0011600f:
auVar1._8_8_ = 0;
auVar1._0_8_ = uVar2;
return auVar1 << 0x40;
}
|
|
6,464 | js_std_file_puts | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_puts(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
FILE *f;
int i;
const char *str;
size_t len;
if (magic == 0) {
f = stdout;
} else {
f = js_std_file_get(ctx, this_val);
if (!f)
return JS_EXCEPTION;
}
for(i = 0; i < argc; i++) {
str = JS_ToCStringLen(ctx, &len, argv[i]);
if (!str)
return JS_EXCEPTION;
fwrite(str, 1, len, f);
JS_FreeCString(ctx, str);
}
return JS_UNDEFINED;
} | O2 | c | js_std_file_puts:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %r15d
movq %rdi, %r12
pushq $0x6
popq %rbx
testl %r9d, %r9d
je 0x10e31
movq %r12, %rdi
callq 0x113c6
movq %rax, %r13
testq %rax, %rax
jne 0x10e3b
jmp 0x10e93
movq 0xaa178(%rip), %rax # 0xbafb0
movq (%rax), %r13
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
shlq $0x4, %r15
cmpq %rbp, %r15
je 0x10e8c
movq (%r14,%rbp), %rdx
movq 0x8(%r14,%rbp), %rcx
movq %r12, %rdi
movq %rsp, %rsi
callq 0x11421
testq %rax, %rax
je 0x10e90
movq %rax, %rbx
movq (%rsp), %rdx
movq %rax, %rdi
pushq $0x1
popq %rsi
movq %r13, %rcx
callq 0xe8f0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1b057
addq $0x10, %rbp
jmp 0x10e48
pushq $0x3
jmp 0x10e92
pushq $0x6
popq %rbx
xorl %eax, %eax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_std_file_puts:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15d, ecx
mov r12, rdi
push 6
pop rbx
test r9d, r9d
jz short loc_10E31
mov rdi, r12
call js_std_file_get
mov r13, rax
test rax, rax
jnz short loc_10E3B
jmp short loc_10E93
loc_10E31:
mov rax, cs:stdout_ptr
mov r13, [rax]
loc_10E3B:
xor ebp, ebp
test r15d, r15d
cmovle r15d, ebp
shl r15, 4
loc_10E48:
cmp r15, rbp
jz short loc_10E8C
mov rdx, [r14+rbp]
mov rcx, [r14+rbp+8]
mov rdi, r12
mov rsi, rsp
call JS_ToCStringLen
test rax, rax
jz short loc_10E90
mov rbx, rax
mov rdx, [rsp+38h+var_38]
mov rdi, rax
push 1
pop rsi
mov rcx, r13
call _fwrite
mov rdi, r12
mov rsi, rbx
call JS_FreeCString
add rbp, 10h
jmp short loc_10E48
loc_10E8C:
push 3
jmp short loc_10E92
loc_10E90:
push 6
loc_10E92:
pop rbx
loc_10E93:
xor eax, eax
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_std_file_puts(long long a1, long long a2, long long a3, unsigned int a4, long long a5, int a6)
{
long long v6; // rax
long long v8; // r15
long long v9; // r13
long long v10; // rbp
long long v11; // r15
long long v12; // rax
long long v13; // rbx
_QWORD v15[7]; // [rsp+0h] [rbp-38h] BYREF
v15[0] = v6;
v8 = a4;
if ( a6 )
{
v9 = js_std_file_get(a1);
if ( !v9 )
return 0LL;
}
else
{
v9 = stdout;
}
v10 = 0LL;
if ( (int)v8 <= 0 )
v8 = 0LL;
v11 = 16 * v8;
while ( v11 != v10 )
{
v12 = JS_ToCStringLen(a1, v15, *(_QWORD *)(a5 + v10), *(_QWORD *)(a5 + v10 + 8));
if ( !v12 )
break;
v13 = v12;
fwrite(v12, 1LL, v15[0], v9);
JS_FreeCString(a1, v13);
v10 += 16LL;
}
return 0LL;
}
| js_std_file_puts:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15D,ECX
MOV R12,RDI
PUSH 0x6
POP RBX
TEST R9D,R9D
JZ 0x00110e31
MOV RDI,R12
CALL 0x001113c6
MOV R13,RAX
TEST RAX,RAX
JNZ 0x00110e3b
JMP 0x00110e93
LAB_00110e31:
MOV RAX,qword ptr [0x001bafb0]
MOV R13,qword ptr [RAX]
LAB_00110e3b:
XOR EBP,EBP
TEST R15D,R15D
CMOVLE R15D,EBP
SHL R15,0x4
LAB_00110e48:
CMP R15,RBP
JZ 0x00110e8c
MOV RDX,qword ptr [R14 + RBP*0x1]
MOV RCX,qword ptr [R14 + RBP*0x1 + 0x8]
MOV RDI,R12
MOV RSI,RSP
CALL 0x00111421
TEST RAX,RAX
JZ 0x00110e90
MOV RBX,RAX
MOV RDX,qword ptr [RSP]
MOV RDI,RAX
PUSH 0x1
POP RSI
MOV RCX,R13
CALL 0x0010e8f0
MOV RDI,R12
MOV RSI,RBX
CALL 0x0011b057
ADD RBP,0x10
JMP 0x00110e48
LAB_00110e8c:
PUSH 0x3
JMP 0x00110e92
LAB_00110e90:
PUSH 0x6
LAB_00110e92:
POP RBX
LAB_00110e93:
XOR EAX,EAX
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_std_file_puts(int8 param_1,int8 param_2,int8 param_3,uint param_4,long param_5,
int param_6)
{
int1 auVar1 [16];
size_t in_RAX;
FILE *__s;
void *__ptr;
ulong uVar2;
ulong uVar3;
ulong uStack_40;
size_t local_38;
uStack_40 = 6;
local_38 = in_RAX;
if (param_6 == 0) {
__s = *(FILE **)PTR_stdout_001bafb0;
}
else {
__s = (FILE *)js_std_file_get(param_1);
if (__s == (FILE *)0x0) goto LAB_00110e93;
}
uVar2 = 0;
uVar3 = (ulong)param_4;
if ((int)param_4 < 1) {
uVar3 = uVar2;
}
for (; uVar3 * 0x10 != uVar2; uVar2 = uVar2 + 0x10) {
__ptr = (void *)JS_ToCStringLen(param_1,&local_38,*(int8 *)(param_5 + uVar2),
*(int8 *)(param_5 + 8 + uVar2));
if (__ptr == (void *)0x0) {
uStack_40 = 6;
goto LAB_00110e93;
}
fwrite(__ptr,1,local_38,__s);
JS_FreeCString(param_1,__ptr);
}
uStack_40 = 3;
LAB_00110e93:
auVar1._8_8_ = 0;
auVar1._0_8_ = uStack_40;
return auVar1 << 0x40;
}
|
|
6,465 | blst_p2_affine_compress | corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/e2.c | void blst_p2_affine_compress(unsigned char out[96], const POINTonE2_affine *in)
{
if (vec_is_zero(in->X, 2*sizeof(in->X))) {
bytes_zero(out, 96);
out[0] = 0xc0; /* compressed and infinity bits */
} else {
limb_t sign = POINTonE2_affine_Compress_BE(out, in);
out[0] |= (unsigned char)(0x80 | ((sign & 2) << 4));
}
} | O1 | c | blst_p2_affine_compress:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0xc0, %esi
movq %r14, %rdi
callq 0x74d40
testq %rax, %rax
je 0x60d3d
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movb $-0x40, %al
jmp 0x60d51
movq %rbx, %rdi
movq %r14, %rsi
callq 0x60d58
shlb $0x4, %al
andb $0x20, %al
orb (%rbx), %al
orb $-0x80, %al
movb %al, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| blst_p2_affine_compress:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov esi, 0C0h
mov rdi, r14
call vec_is_zero_16x
test rax, rax
jz short loc_60D3D
xorps xmm0, xmm0
movups xmmword ptr [rbx+50h], xmm0
movups xmmword ptr [rbx+40h], xmm0
movups xmmword ptr [rbx+30h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
mov al, 0C0h
jmp short loc_60D51
loc_60D3D:
mov rdi, rbx
mov rsi, r14
call POINTonE2_affine_Compress_BE
shl al, 4
and al, 20h
or al, [rbx]
or al, 80h
loc_60D51:
mov [rbx], al
pop rbx
pop r14
pop rbp
retn
| char blst_p2_affine_compress(_OWORD *a1, long long a2)
{
char result; // al
if ( vec_is_zero_16x(a2, 192LL) )
{
a1[5] = 0LL;
a1[4] = 0LL;
a1[3] = 0LL;
a1[2] = 0LL;
a1[1] = 0LL;
*a1 = 0LL;
result = -64;
}
else
{
result = *(_BYTE *)a1 | (16 * POINTonE2_affine_Compress_BE(a1, a2)) & 0x20 | 0x80;
}
*(_BYTE *)a1 = result;
return result;
}
| blst_p2_affine_compress:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV ESI,0xc0
MOV RDI,R14
CALL 0x00174d40
TEST RAX,RAX
JZ 0x00160d3d
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x50],XMM0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOV AL,0xc0
JMP 0x00160d51
LAB_00160d3d:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00160d58
SHL AL,0x4
AND AL,0x20
OR AL,byte ptr [RBX]
OR AL,0x80
LAB_00160d51:
MOV byte ptr [RBX],AL
POP RBX
POP R14
POP RBP
RET
|
void blst_p2_affine_compress(byte *param_1,int8 param_2)
{
long lVar1;
byte bVar2;
lVar1 = vec_is_zero_16x(param_2,0xc0);
if (lVar1 == 0) {
bVar2 = POINTonE2_affine_Compress_BE(param_1,param_2);
bVar2 = (bVar2 & 2) << 4 | *param_1 | 0x80;
}
else {
param_1[0x50] = 0;
param_1[0x51] = 0;
param_1[0x52] = 0;
param_1[0x53] = 0;
param_1[0x54] = 0;
param_1[0x55] = 0;
param_1[0x56] = 0;
param_1[0x57] = 0;
param_1[0x58] = 0;
param_1[0x59] = 0;
param_1[0x5a] = 0;
param_1[0x5b] = 0;
param_1[0x5c] = 0;
param_1[0x5d] = 0;
param_1[0x5e] = 0;
param_1[0x5f] = 0;
param_1[0x40] = 0;
param_1[0x41] = 0;
param_1[0x42] = 0;
param_1[0x43] = 0;
param_1[0x44] = 0;
param_1[0x45] = 0;
param_1[0x46] = 0;
param_1[0x47] = 0;
param_1[0x48] = 0;
param_1[0x49] = 0;
param_1[0x4a] = 0;
param_1[0x4b] = 0;
param_1[0x4c] = 0;
param_1[0x4d] = 0;
param_1[0x4e] = 0;
param_1[0x4f] = 0;
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;
param_1[0x38] = 0;
param_1[0x39] = 0;
param_1[0x3a] = 0;
param_1[0x3b] = 0;
param_1[0x3c] = 0;
param_1[0x3d] = 0;
param_1[0x3e] = 0;
param_1[0x3f] = 0;
param_1[0x20] = 0;
param_1[0x21] = 0;
param_1[0x22] = 0;
param_1[0x23] = 0;
param_1[0x24] = 0;
param_1[0x25] = 0;
param_1[0x26] = 0;
param_1[0x27] = 0;
param_1[0x28] = 0;
param_1[0x29] = 0;
param_1[0x2a] = 0;
param_1[0x2b] = 0;
param_1[0x2c] = 0;
param_1[0x2d] = 0;
param_1[0x2e] = 0;
param_1[0x2f] = 0;
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;
param_1[0x19] = 0;
param_1[0x1a] = 0;
param_1[0x1b] = 0;
param_1[0x1c] = 0;
param_1[0x1d] = 0;
param_1[0x1e] = 0;
param_1[0x1f] = 0;
param_1[0] = 0;
param_1[1] = 0;
param_1[2] = 0;
param_1[3] = 0;
param_1[4] = 0;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
param_1[8] = 0;
param_1[9] = 0;
param_1[10] = 0;
param_1[0xb] = 0;
param_1[0xc] = 0;
param_1[0xd] = 0;
param_1[0xe] = 0;
param_1[0xf] = 0;
bVar2 = 0xc0;
}
*param_1 = bVar2;
return;
}
|
|
6,466 | OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode const&, unsigned int*, int*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp | void
SubdivisionPlanBuilder::encodeEndCapNode(
ProtoNode const& pn, uint32_t* tree, Index* patchPoints) {
assert(pn.hasIrregularPatch);
unsigned int level = pn.levelIndex;
Index face = pn.faceIndex;
short u, v;
bool irregRoot = computeSubPatchDomain(level, face, u, v);
gatherIrregularPatchPoints(level, patchPoints + pn.firstPatchPoint);
tree += pn.treeOffset;
NodeDescriptor* descr = reinterpret_cast<NodeDescriptor*>(tree);
descr->SetEnd(level, 0, u, v);
tree[1] = pn.firstPatchPoint;
} | O1 | cpp | OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode const&, unsigned int*, int*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movzwl 0xc(%rsi), %r15d
testb $0x40, %r15b
je 0xa88f4
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
shrl $0x7, %r15d
andl $0xf, %r15d
movzwl (%rsi), %edx
leaq 0xe(%rsp), %rcx
leaq 0xc(%rsp), %r8
movl %r15d, %esi
callq 0x38e30
xorl %edx, %edx
cmpb $0x0, 0x269(%r12)
cmovneq %r15, %rdx
cmpl $0x0, 0x274(%r12)
jle 0xa88b5
movl 0x14(%r14), %eax
leaq (,%rax,4), %rax
addq %r13, %rax
leaq (%r15,%r15,4), %rcx
movl 0x11c(%r12,%rcx,4), %ecx
leaq (%rdx,%rdx,4), %rdx
leaq (%r12,%rdx,4), %rdx
addq $0x120, %rdx # imm = 0x120
xorl %esi, %esi
movl (%rdx), %edi
leal 0x1(%rdi), %r8d
movl %r8d, (%rdx)
addl %ecx, %edi
movl %edi, (%rax,%rsi,4)
incq %rsi
movslq 0x274(%r12), %rdi
cmpq %rdi, %rsi
jl 0xa8897
movl 0x10(%r14), %eax
movzwl 0xe(%rsp), %ecx
movzwl 0xc(%rsp), %edx
shll $0x16, %edx
andl $0x3ff, %ecx # imm = 0x3FF
shll $0xc, %ecx
orl %edx, %ecx
movzwl %r15w, %edx
leal (%rcx,%rdx,8), %ecx
addl $0x3, %ecx
movl %ecx, (%rbx,%rax,4)
movl 0x14(%r14), %ecx
movl %ecx, 0x4(%rbx,%rax,4)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1bbb1(%rip), %rdi # 0xc44ac
leaq 0x1b7bc(%rip), %rsi # 0xc40be
leaq 0x1bbb8(%rip), %rcx # 0xc44c1
movl $0x2a6, %edx # imm = 0x2A6
callq 0x39560
nop
| _ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder16encodeEndCapNodeERKNS2_9ProtoNodeEPjPi:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
movzx r15d, word ptr [rsi+0Ch]
test r15b, 40h
jz loc_A88F4
mov r13, rcx
mov rbx, rdx
mov r14, rsi
mov r12, rdi
shr r15d, 7
and r15d, 0Fh
movzx edx, word ptr [rsi]; int
lea rcx, [rsp+38h+var_2A]; __int16 *
lea r8, [rsp+38h+var_2C]; __int16 *
mov esi, r15d; int
call __ZNK10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder21computeSubPatchDomainEiiRsS3_; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::computeSubPatchDomain(int,int,short &,short &)
xor edx, edx
cmp byte ptr [r12+269h], 0
cmovnz rdx, r15
cmp dword ptr [r12+274h], 0
jle short loc_A88B5
mov eax, [r14+14h]
lea rax, ds:0[rax*4]
add rax, r13
lea rcx, [r15+r15*4]
mov ecx, [r12+rcx*4+11Ch]
lea rdx, [rdx+rdx*4]
lea rdx, [r12+rdx*4]
add rdx, 120h
xor esi, esi
loc_A8897:
mov edi, [rdx]
lea r8d, [rdi+1]
mov [rdx], r8d
add edi, ecx
mov [rax+rsi*4], edi
inc rsi
movsxd rdi, dword ptr [r12+274h]
cmp rsi, rdi
jl short loc_A8897
loc_A88B5:
mov eax, [r14+10h]
movzx ecx, [rsp+38h+var_2A]
movzx edx, [rsp+38h+var_2C]
shl edx, 16h
and ecx, 3FFh
shl ecx, 0Ch
or ecx, edx
movzx edx, r15w
lea ecx, [rcx+rdx*8]
add ecx, 3
mov [rbx+rax*4], ecx
mov ecx, [r14+14h]
mov [rbx+rax*4+4], ecx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_A88F4:
lea rdi, aPnHasirregular; "pn.hasIrregularPatch"
lea rsi, aWorkspaceLlm4b_52; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidOpensubdiv_159; "void OpenSubdiv::v3_6_0::Tmr::Subdivisi"...
mov edx, 2A6h
call ___assert_fail
| long long OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(
long long a1,
unsigned __int16 *a2,
long long a3,
long long a4)
{
unsigned int v4; // r15d
unsigned int v9; // r15d
long long v10; // rdx
long long v11; // rax
int v12; // ecx
_DWORD *v13; // rdx
long long v14; // rsi
int v15; // edi
long long result; // rax
__int16 v17; // [rsp+Ch] [rbp-2Ch] BYREF
__int16 v18[21]; // [rsp+Eh] [rbp-2Ah] BYREF
v4 = a2[6];
if ( (v4 & 0x40) == 0 )
__assert_fail(
"pn.hasIrregularPatch",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp",
678LL,
"void OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(const ProtoNode &, uint32_t *, Index *)");
v9 = (v4 >> 7) & 0xF;
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::computeSubPatchDomain(
(OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *)a1,
v9,
*a2,
v18,
&v17);
v10 = 0LL;
if ( *(_BYTE *)(a1 + 617) )
v10 = v9;
if ( *(int *)(a1 + 628) > 0 )
{
v11 = a4 + 4LL * *((unsigned int *)a2 + 5);
v12 = *(_DWORD *)(a1 + 20LL * v9 + 284);
v13 = (_DWORD *)(a1 + 20 * v10 + 288);
v14 = 0LL;
do
{
v15 = (*v13)++;
*(_DWORD *)(v11 + 4 * v14++) = v12 + v15;
}
while ( v14 < *(int *)(a1 + 628) );
}
result = *((unsigned int *)a2 + 4);
*(_DWORD *)(a3 + 4 * result) = (((unsigned __int16)v17 << 22) | ((v18[0] & 0x3FF) << 12))
+ 8 * (unsigned __int16)v9
+ 3;
*(_DWORD *)(a3 + 4 * result + 4) = *((_DWORD *)a2 + 5);
return result;
}
| encodeEndCapNode:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOVZX R15D,word ptr [RSI + 0xc]
TEST R15B,0x40
JZ 0x001a88f4
MOV R13,RCX
MOV RBX,RDX
MOV R14,RSI
MOV R12,RDI
SHR R15D,0x7
AND R15D,0xf
MOVZX EDX,word ptr [RSI]
LEA RCX,[RSP + 0xe]
LEA R8,[RSP + 0xc]
MOV ESI,R15D
CALL 0x00138e30
XOR EDX,EDX
CMP byte ptr [R12 + 0x269],0x0
CMOVNZ RDX,R15
CMP dword ptr [R12 + 0x274],0x0
JLE 0x001a88b5
MOV EAX,dword ptr [R14 + 0x14]
LEA RAX,[RAX*0x4]
ADD RAX,R13
LEA RCX,[R15 + R15*0x4]
MOV ECX,dword ptr [R12 + RCX*0x4 + 0x11c]
LEA RDX,[RDX + RDX*0x4]
LEA RDX,[R12 + RDX*0x4]
ADD RDX,0x120
XOR ESI,ESI
LAB_001a8897:
MOV EDI,dword ptr [RDX]
LEA R8D,[RDI + 0x1]
MOV dword ptr [RDX],R8D
ADD EDI,ECX
MOV dword ptr [RAX + RSI*0x4],EDI
INC RSI
MOVSXD RDI,dword ptr [R12 + 0x274]
CMP RSI,RDI
JL 0x001a8897
LAB_001a88b5:
MOV EAX,dword ptr [R14 + 0x10]
MOVZX ECX,word ptr [RSP + 0xe]
MOVZX EDX,word ptr [RSP + 0xc]
SHL EDX,0x16
AND ECX,0x3ff
SHL ECX,0xc
OR ECX,EDX
MOVZX EDX,R15W
LEA ECX,[RCX + RDX*0x8]
ADD ECX,0x3
MOV dword ptr [RBX + RAX*0x4],ECX
MOV ECX,dword ptr [R14 + 0x14]
MOV dword ptr [RBX + RAX*0x4 + 0x4],ECX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_001a88f4:
LEA RDI,[0x1c44ac]
LEA RSI,[0x1c40be]
LEA RCX,[0x1c44c1]
MOV EDX,0x2a6
CALL 0x00139560
|
/* OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode
const&, unsigned int*, int*) */
void __thiscall
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode
(SubdivisionPlanBuilder *this,ProtoNode *param_1,uint *param_2,int *param_3)
{
uint uVar1;
int iVar2;
int iVar3;
ulong uVar4;
long lVar5;
uint uVar6;
ushort local_2c;
ushort local_2a;
if ((*(ushort *)(param_1 + 0xc) & 0x40) != 0) {
uVar6 = *(ushort *)(param_1 + 0xc) >> 7 & 0xf;
computeSubPatchDomain(this,uVar6,(uint)*(ushort *)param_1,(short *)&local_2a,(short *)&local_2c)
;
uVar4 = 0;
if (this[0x269] != (SubdivisionPlanBuilder)0x0) {
uVar4 = (ulong)uVar6;
}
if (0 < *(int *)(this + 0x274)) {
uVar1 = *(uint *)(param_1 + 0x14);
iVar2 = *(int *)(this + (ulong)uVar6 * 0x14 + 0x11c);
lVar5 = 0;
do {
iVar3 = *(int *)(this + uVar4 * 0x14 + 0x120);
*(int *)(this + uVar4 * 0x14 + 0x120) = iVar3 + 1;
param_3[(ulong)uVar1 + lVar5] = iVar3 + iVar2;
lVar5 = lVar5 + 1;
} while (lVar5 < *(int *)(this + 0x274));
}
uVar1 = *(uint *)(param_1 + 0x10);
param_2[uVar1] = ((local_2a & 0x3ff) << 0xc | (uint)local_2c << 0x16) + uVar6 * 8 + 3;
param_2[(ulong)uVar1 + 1] = *(uint *)(param_1 + 0x14);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("pn.hasIrregularPatch",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp"
,0x2a6,
"void OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(const ProtoNode &, uint32_t *, Index *)"
);
}
|
|
6,467 | OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode const&, unsigned int*, int*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp | void
SubdivisionPlanBuilder::encodeEndCapNode(
ProtoNode const& pn, uint32_t* tree, Index* patchPoints) {
assert(pn.hasIrregularPatch);
unsigned int level = pn.levelIndex;
Index face = pn.faceIndex;
short u, v;
bool irregRoot = computeSubPatchDomain(level, face, u, v);
gatherIrregularPatchPoints(level, patchPoints + pn.firstPatchPoint);
tree += pn.treeOffset;
NodeDescriptor* descr = reinterpret_cast<NodeDescriptor*>(tree);
descr->SetEnd(level, 0, u, v);
tree[1] = pn.firstPatchPoint;
} | O2 | cpp | OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode const&, unsigned int*, int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzwl 0xc(%rsi), %ebp
testb $0x40, %bpl
je 0xb36e4
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
shrl $0x7, %ebp
andl $0xf, %ebp
movzwl (%rsi), %edx
leaq 0x6(%rsp), %r13
leaq 0x4(%rsp), %r8
movl %ebp, %esi
movq %r13, %rcx
callq 0x505f0
movl 0x14(%rbx), %eax
leaq (%r15,%rax,4), %rdx
movq %r12, %rdi
movl %ebp, %esi
callq 0x53eb0
movl 0x10(%rbx), %eax
leaq (%r14,%rax,4), %r14
movswl (%r13), %ecx
leaq 0x4(%rsp), %rax
movswl (%rax), %r8d
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x51f50
movl 0x14(%rbx), %eax
movl %eax, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ba3d(%rip), %rdi # 0xcf128
leaq 0x1b648(%rip), %rsi # 0xced3a
leaq 0x1ba44(%rip), %rcx # 0xcf13d
movl $0x2a6, %edx # imm = 0x2A6
callq 0x512a0
nop
| _ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder16encodeEndCapNodeERKNS2_9ProtoNodeEPjPi:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
movzx ebp, word ptr [rsi+0Ch]
test bpl, 40h
jz short loc_B36E4
mov r15, rcx
mov r14, rdx
mov rbx, rsi
mov r12, rdi
shr ebp, 7
and ebp, 0Fh
movzx edx, word ptr [rsi]; int
lea r13, [rsp+38h+var_32]
lea r8, [rsp+38h+var_34]; __int16 *
mov esi, ebp; int
mov rcx, r13; __int16 *
call __ZNK10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder21computeSubPatchDomainEiiRsS3_; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::computeSubPatchDomain(int,int,short &,short &)
mov eax, [rbx+14h]
lea rdx, [r15+rax*4]; int *
mov rdi, r12; this
mov esi, ebp; int
call __ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder26gatherIrregularPatchPointsEiPi; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(int,int *)
mov eax, [rbx+10h]
lea r14, [r14+rax*4]
movsx ecx, word ptr [r13+0]; __int16
lea rax, [rsp+38h+var_34]
movsx r8d, word ptr [rax]; __int16
mov rdi, r14; this
mov esi, ebp; unsigned __int8
xor edx, edx; unsigned __int8
call __ZN10OpenSubdiv6v3_6_03Tmr14NodeDescriptor6SetEndEhhss; OpenSubdiv::v3_6_0::Tmr::NodeDescriptor::SetEnd(uchar,uchar,short,short)
mov eax, [rbx+14h]
mov [r14+4], eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_B36E4:
lea rdi, aPnHasirregular; "pn.hasIrregularPatch"
lea rsi, aWorkspaceLlm4b_48; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidOpensubdiv_161; "void OpenSubdiv::v3_6_0::Tmr::Subdivisi"...
mov edx, 2A6h
call ___assert_fail
| long long OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *this,
unsigned __int16 *a2,
long long a3,
long long a4)
{
long long v4; // rax
unsigned int v5; // ebp
int v8; // ebp
OpenSubdiv::v3_6_0::Tmr::NodeDescriptor *v9; // r14
long long result; // rax
__int16 v11[26]; // [rsp+0h] [rbp-34h] BYREF
*(_DWORD *)v11 = HIDWORD(v4);
v5 = a2[6];
if ( (v5 & 0x40) == 0 )
__assert_fail(
"pn.hasIrregularPatch",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp",
678LL,
"void OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(const ProtoNode &, uint32_t *, Index *)");
v8 = (v5 >> 7) & 0xF;
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::computeSubPatchDomain(this, v8, *a2, &v11[1], v11);
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(
this,
v8,
(int *)(a4 + 4LL * *((unsigned int *)a2 + 5)));
v9 = (OpenSubdiv::v3_6_0::Tmr::NodeDescriptor *)(a3 + 4LL * *((unsigned int *)a2 + 4));
OpenSubdiv::v3_6_0::Tmr::NodeDescriptor::SetEnd(v9, v8, 0, v11[1], v11[0]);
result = *((unsigned int *)a2 + 5);
*((_DWORD *)v9 + 1) = result;
return result;
}
| encodeEndCapNode:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOVZX EBP,word ptr [RSI + 0xc]
TEST BPL,0x40
JZ 0x001b36e4
MOV R15,RCX
MOV R14,RDX
MOV RBX,RSI
MOV R12,RDI
SHR EBP,0x7
AND EBP,0xf
MOVZX EDX,word ptr [RSI]
LEA R13,[RSP + 0x6]
LEA R8,[RSP + 0x4]
MOV ESI,EBP
MOV RCX,R13
CALL 0x001505f0
MOV EAX,dword ptr [RBX + 0x14]
LEA RDX,[R15 + RAX*0x4]
MOV RDI,R12
MOV ESI,EBP
CALL 0x00153eb0
MOV EAX,dword ptr [RBX + 0x10]
LEA R14,[R14 + RAX*0x4]
MOVSX ECX,word ptr [R13]
LEA RAX,[RSP + 0x4]
MOVSX R8D,word ptr [RAX]
MOV RDI,R14
MOV ESI,EBP
XOR EDX,EDX
CALL 0x00151f50
MOV EAX,dword ptr [RBX + 0x14]
MOV dword ptr [R14 + 0x4],EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001b36e4:
LEA RDI,[0x1cf128]
LEA RSI,[0x1ced3a]
LEA RCX,[0x1cf13d]
MOV EDX,0x2a6
CALL 0x001512a0
|
/* OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode
const&, unsigned int*, int*) */
void __thiscall
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode
(SubdivisionPlanBuilder *this,ProtoNode *param_1,uint *param_2,int *param_3)
{
uint uVar1;
int8 in_RAX;
uint uVar2;
int4 local_34;
int4 uVar3;
uVar3 = (int4)((ulong)in_RAX >> 0x30);
if ((*(ushort *)(param_1 + 0xc) & 0x40) != 0) {
uVar2 = *(ushort *)(param_1 + 0xc) >> 7 & 0xf;
computeSubPatchDomain
(this,uVar2,(uint)*(ushort *)param_1,(short *)((long)&local_34 + 2),(short *)&local_34
);
local_34 = uVar3;
gatherIrregularPatchPoints(this,uVar2,param_3 + *(uint *)(param_1 + 0x14));
uVar1 = *(uint *)(param_1 + 0x10);
NodeDescriptor::SetEnd
((NodeDescriptor *)(param_2 + uVar1),(uchar)uVar2,'\0',local_34._2_2_,(short)local_34)
;
*(int4 *)((NodeDescriptor *)(param_2 + uVar1) + 4) = *(int4 *)(param_1 + 0x14);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("pn.hasIrregularPatch",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp"
,0x2a6,
"void OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::encodeEndCapNode(const ProtoNode &, uint32_t *, Index *)"
);
}
|
|
6,468 | end_slave_io_cache | eloqsql/mysys/mf_iocache.c | void end_slave_io_cache(IO_CACHE *cache)
{
/* Remove the cache from the next_file_user circular linked list. */
if (cache->next_file_user != cache)
{
IO_CACHE *p= cache->next_file_user;
while (p->next_file_user != cache)
p= p->next_file_user;
p->next_file_user= cache->next_file_user;
}
my_free(cache->buffer);
} | O0 | c | end_slave_io_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0xe5784
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0xe576e
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xe574c
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xfc410
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| end_slave_io_cache:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+0D8h]
cmp rax, [rbp+var_8]
jz short loc_E5784
mov rax, [rbp+var_8]
mov rax, [rax+0D8h]
mov [rbp+var_10], rax
loc_E574C:
mov rax, [rbp+var_10]
mov rax, [rax+0D8h]
cmp rax, [rbp+var_8]
jz short loc_E576E
mov rax, [rbp+var_10]
mov rax, [rax+0D8h]
mov [rbp+var_10], rax
jmp short loc_E574C
loc_E576E:
mov rax, [rbp+var_8]
mov rcx, [rax+0D8h]
mov rax, [rbp+var_10]
mov [rax+0D8h], rcx
loc_E5784:
mov rax, [rbp+var_8]
mov rdi, [rax+20h]
call my_free
add rsp, 10h
pop rbp
retn
| long long end_slave_io_cache(long long a1)
{
long long i; // [rsp+0h] [rbp-10h]
if ( *(_QWORD *)(a1 + 216) != a1 )
{
for ( i = *(_QWORD *)(a1 + 216); *(_QWORD *)(i + 216) != a1; i = *(_QWORD *)(i + 216) )
;
*(_QWORD *)(i + 216) = *(_QWORD *)(a1 + 216);
}
return my_free(*(_QWORD *)(a1 + 32));
}
| end_slave_io_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xd8]
CMP RAX,qword ptr [RBP + -0x8]
JZ 0x001e5784
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xd8]
MOV qword ptr [RBP + -0x10],RAX
LAB_001e574c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xd8]
CMP RAX,qword ptr [RBP + -0x8]
JZ 0x001e576e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xd8]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001e574c
LAB_001e576e:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0xd8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xd8],RCX
LAB_001e5784:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x20]
CALL 0x001fc410
ADD RSP,0x10
POP RBP
RET
|
void end_slave_io_cache(long param_1)
{
int8 local_18;
if (*(long *)(param_1 + 0xd8) != param_1) {
for (local_18 = *(long *)(param_1 + 0xd8); *(long *)(local_18 + 0xd8) != param_1;
local_18 = *(long *)(local_18 + 0xd8)) {
}
*(int8 *)(local_18 + 0xd8) = *(int8 *)(param_1 + 0xd8);
}
my_free(*(int8 *)(param_1 + 0x20));
return;
}
|
|
6,469 | end_slave_io_cache | eloqsql/mysys/mf_iocache.c | void end_slave_io_cache(IO_CACHE *cache)
{
/* Remove the cache from the next_file_user circular linked list. */
if (cache->next_file_user != cache)
{
IO_CACHE *p= cache->next_file_user;
while (p->next_file_user != cache)
p= p->next_file_user;
p->next_file_user= cache->next_file_user;
}
my_free(cache->buffer);
} | O3 | c | end_slave_io_cache:
movq 0xd8(%rdi), %rax
cmpq %rdi, %rax
je 0x9a0d1
pushq %rbp
movq %rsp, %rbp
movq %rax, %rdx
movq %rdx, %rcx
movq 0xd8(%rdx), %rdx
cmpq %rdi, %rdx
jne 0x9a0ba
movq %rax, 0xd8(%rcx)
popq %rbp
movq 0x20(%rdi), %rdi
jmp 0xa71c6
| end_slave_io_cache:
mov rax, [rdi+0D8h]
cmp rax, rdi
jz short loc_9A0D1
push rbp
mov rbp, rsp
mov rdx, rax
loc_9A0BA:
mov rcx, rdx
mov rdx, [rdx+0D8h]
cmp rdx, rdi
jnz short loc_9A0BA
mov [rcx+0D8h], rax
pop rbp
loc_9A0D1:
mov rdi, [rdi+20h]
jmp my_free
| long long end_slave_io_cache(long long a1)
{
long long v1; // rax
long long v2; // rdx
long long v3; // rcx
v1 = *(_QWORD *)(a1 + 216);
if ( v1 != a1 )
{
v2 = *(_QWORD *)(a1 + 216);
do
{
v3 = v2;
v2 = *(_QWORD *)(v2 + 216);
}
while ( v2 != a1 );
*(_QWORD *)(v3 + 216) = v1;
}
return my_free(*(_QWORD *)(a1 + 32));
}
| end_slave_io_cache:
MOV RAX,qword ptr [RDI + 0xd8]
CMP RAX,RDI
JZ 0x0019a0d1
PUSH RBP
MOV RBP,RSP
MOV RDX,RAX
LAB_0019a0ba:
MOV RCX,RDX
MOV RDX,qword ptr [RDX + 0xd8]
CMP RDX,RDI
JNZ 0x0019a0ba
MOV qword ptr [RCX + 0xd8],RAX
POP RBP
LAB_0019a0d1:
MOV RDI,qword ptr [RDI + 0x20]
JMP 0x001a71c6
|
void end_slave_io_cache(long param_1)
{
long lVar1;
long lVar2;
long lVar3;
lVar1 = *(long *)(param_1 + 0xd8);
lVar2 = lVar1;
if (lVar1 != param_1) {
do {
lVar3 = lVar2;
lVar2 = *(long *)(lVar3 + 0xd8);
} while (lVar2 != param_1);
*(long *)(lVar3 + 0xd8) = lVar1;
}
my_free(*(int8 *)(param_1 + 0x20));
return;
}
|
|
6,470 | js_resolve_module | bluesky950520[P]quickjs/quickjs.c | static int js_resolve_module(JSContext *ctx, JSModuleDef *m)
{
int i;
JSModuleDef *m1;
if (m->resolved)
return 0;
#ifdef DUMP_MODULE_RESOLVE
if (check_dump_flag(ctx->rt, DUMP_MODULE_RESOLVE)) {
char buf1[ATOM_GET_STR_BUF_SIZE];
printf("resolving module '%s':\n", JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name));
}
#endif
m->resolved = TRUE;
/* resolve each requested module */
for(i = 0; i < m->req_module_entries_count; i++) {
JSReqModuleEntry *rme = &m->req_module_entries[i];
m1 = js_host_resolve_imported_module_atom(ctx, m->module_name,
rme->module_name);
if (!m1)
return -1;
rme->module = m1;
/* already done in js_host_resolve_imported_module() except if
the module was loaded with JS_EvalBinary() */
if (js_resolve_module(ctx, m1) < 0)
return -1;
}
return 0;
} | O0 | c | js_resolve_module:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x80(%rax), %eax
shll $0x10, %eax
sarl $0x18, %eax
cmpl $0x0, %eax
je 0x51101
movl $0x0, 0x34(%rsp)
jmp 0x511c8
movq 0x20(%rsp), %rax
movl 0x80(%rax), %ecx
andl $0xffff00ff, %ecx # imm = 0xFFFF00FF
orl $0x100, %ecx # imm = 0x100
movl %ecx, 0x80(%rax)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x511c0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x8(%rsp), %rax
movl (%rax), %edx
callq 0x7dd90
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x51182
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x511c8
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x510d0
cmpl $0x0, %eax
jge 0x511ae
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x511c8
jmp 0x511b0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x51126
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| js_resolve_module:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov rax, [rsp+38h+var_18]
mov eax, [rax+80h]
shl eax, 10h
sar eax, 18h
cmp eax, 0
jz short loc_51101
mov [rsp+38h+var_4], 0
jmp loc_511C8
loc_51101:
mov rax, [rsp+38h+var_18]
mov ecx, [rax+80h]
and ecx, 0FFFF00FFh
or ecx, 100h
mov [rax+80h], ecx
mov [rsp+38h+var_1C], 0
loc_51126:
mov eax, [rsp+38h+var_1C]
mov rcx, [rsp+38h+var_18]
cmp eax, [rcx+20h]
jge loc_511C0
mov rax, [rsp+38h+var_18]
mov rax, [rax+18h]
movsxd rcx, [rsp+38h+var_1C]
shl rcx, 4
add rax, rcx
mov [rsp+38h+var_30], rax
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_18]
mov esi, [rax+4]
mov rax, [rsp+38h+var_30]
mov edx, [rax]
call js_host_resolve_imported_module_atom
mov [rsp+38h+var_28], rax
cmp [rsp+38h+var_28], 0
jnz short loc_51182
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp short loc_511C8
loc_51182:
mov rcx, [rsp+38h+var_28]
mov rax, [rsp+38h+var_30]
mov [rax+8], rcx
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_28]
call js_resolve_module
cmp eax, 0
jge short loc_511AE
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp short loc_511C8
loc_511AE:
jmp short $+2
loc_511B0:
mov eax, [rsp+38h+var_1C]
add eax, 1
mov [rsp+38h+var_1C], eax
jmp loc_51126
loc_511C0:
mov [rsp+38h+var_4], 0
loc_511C8:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long js_resolve_module(long long a1, long long a2)
{
unsigned int *v3; // [rsp+8h] [rbp-30h]
long long v4; // [rsp+10h] [rbp-28h]
int i; // [rsp+1Ch] [rbp-1Ch]
if ( (int)(*(_DWORD *)(a2 + 128) << 16) >> 24 )
{
return 0;
}
else
{
*(_DWORD *)(a2 + 128) = *(_DWORD *)(a2 + 128) & 0xFFFF00FF | 0x100;
for ( i = 0; i < *(_DWORD *)(a2 + 32); ++i )
{
v3 = (unsigned int *)(16LL * i + *(_QWORD *)(a2 + 24));
v4 = js_host_resolve_imported_module_atom(a1, *(unsigned int *)(a2 + 4), *v3);
if ( !v4 )
return (unsigned int)-1;
*((_QWORD *)v3 + 1) = v4;
if ( (int)js_resolve_module(a1, v4) < 0 )
return (unsigned int)-1;
}
return 0;
}
}
| js_resolve_module:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV RAX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RAX + 0x80]
SHL EAX,0x10
SAR EAX,0x18
CMP EAX,0x0
JZ 0x00151101
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001511c8
LAB_00151101:
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RAX + 0x80]
AND ECX,0xffff00ff
OR ECX,0x100
MOV dword ptr [RAX + 0x80],ECX
MOV dword ptr [RSP + 0x1c],0x0
LAB_00151126:
MOV EAX,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RSP + 0x20]
CMP EAX,dword ptr [RCX + 0x20]
JGE 0x001511c0
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x18]
MOVSXD RCX,dword ptr [RSP + 0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RSP + 0x8]
MOV EDX,dword ptr [RAX]
CALL 0x0017dd90
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x00151182
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x001511c8
LAB_00151182:
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x001510d0
CMP EAX,0x0
JGE 0x001511ae
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x001511c8
LAB_001511ae:
JMP 0x001511b0
LAB_001511b0:
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x00151126
LAB_001511c0:
MOV dword ptr [RSP + 0x34],0x0
LAB_001511c8:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4 js_resolve_module(int8 param_1,long param_2)
{
int iVar1;
int4 *puVar2;
long lVar3;
int local_1c;
if ((*(int *)(param_2 + 0x80) << 0x10) >> 0x18 == 0) {
*(uint *)(param_2 + 0x80) = *(uint *)(param_2 + 0x80) & 0xffff00ff | 0x100;
for (local_1c = 0; local_1c < *(int *)(param_2 + 0x20); local_1c = local_1c + 1) {
puVar2 = (int4 *)(*(long *)(param_2 + 0x18) + (long)local_1c * 0x10);
lVar3 = js_host_resolve_imported_module_atom(param_1,*(int4 *)(param_2 + 4),*puVar2);
if (lVar3 == 0) {
return 0xffffffff;
}
*(long *)(puVar2 + 2) = lVar3;
iVar1 = js_resolve_module(param_1,lVar3);
if (iVar1 < 0) {
return 0xffffffff;
}
}
}
return 0;
}
|
|
6,471 | js_resolve_module | bluesky950520[P]quickjs/quickjs.c | static int js_resolve_module(JSContext *ctx, JSModuleDef *m)
{
int i;
JSModuleDef *m1;
if (m->resolved)
return 0;
#ifdef DUMP_MODULE_RESOLVE
if (check_dump_flag(ctx->rt, DUMP_MODULE_RESOLVE)) {
char buf1[ATOM_GET_STR_BUF_SIZE];
printf("resolving module '%s':\n", JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name));
}
#endif
m->resolved = TRUE;
/* resolve each requested module */
for(i = 0; i < m->req_module_entries_count; i++) {
JSReqModuleEntry *rme = &m->req_module_entries[i];
m1 = js_host_resolve_imported_module_atom(ctx, m->module_name,
rme->module_name);
if (!m1)
return -1;
rme->module = m1;
/* already done in js_host_resolve_imported_module() except if
the module was loaded with JS_EvalBinary() */
if (js_resolve_module(ctx, m1) < 0)
return -1;
}
return 0;
} | O2 | c | js_resolve_module:
movl 0x80(%rsi), %ecx
xorl %eax, %eax
testw $0xff00, %cx # imm = 0xFF00
je 0x2d61e
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %r14
orl $0x100, %ecx # imm = 0x100
movl %ecx, 0x80(%rsi)
pushq $0x8
popq %r15
pushq $-0x1
popq %rbx
movq %rsi, 0x8(%rsp)
movslq 0x20(%r13), %rax
incq %rbx
cmpq %rax, %rbx
jge 0x2d6ec
movq 0x18(%r13), %rax
movl 0x4(%r13), %esi
movq %rax, 0x10(%rsp)
movl -0x8(%rax,%r15), %ebp
movq %r14, %rdi
callq 0x1e56f
testq %rax, %rax
je 0x2d6e7
movq %rax, %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0x1e56f
testq %rax, %rax
je 0x2d6af
movq %rax, %rbp
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3f225
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x1ec07
movq %rbp, %r12
jmp 0x2d6b2
xorl %r13d, %r13d
movq %r14, %rdi
movq %r12, %rsi
callq 0x1ec07
testq %r13, %r13
je 0x2d6e7
movq 0x10(%rsp), %rax
movq %r13, (%rax,%r15)
addq $0x10, %r15
movq %r14, %rdi
movq %r13, %rsi
callq 0x2d60e
testl %eax, %eax
movq 0x8(%rsp), %r13
jns 0x2d64a
pushq $-0x1
popq %rax
jmp 0x2d6ee
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_resolve_module:
mov ecx, [rsi+80h]
xor eax, eax
test cx, 0FF00h
jz short loc_2D61E
retn
loc_2D61E:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, rsi
mov r14, rdi
or ecx, 100h
mov [rsi+80h], ecx
push 8
pop r15
push 0FFFFFFFFFFFFFFFFh
pop rbx
mov [rsp+48h+var_40], rsi
loc_2D64A:
movsxd rax, dword ptr [r13+20h]
inc rbx
cmp rbx, rax
jge loc_2D6EC
mov rax, [r13+18h]
mov esi, [r13+4]
mov [rsp+48h+var_38], rax
mov ebp, [rax+r15-8]
mov rdi, r14
call JS_AtomToCString
test rax, rax
jz short loc_2D6E7
mov r12, rax
mov rdi, r14
mov esi, ebp
call JS_AtomToCString
test rax, rax
jz short loc_2D6AF
mov rbp, rax
mov rdi, r14
mov rsi, r12
mov rdx, rax
call js_host_resolve_imported_module
mov r13, rax
mov rdi, r14
mov rsi, r12
call JS_FreeCString
mov r12, rbp
jmp short loc_2D6B2
loc_2D6AF:
xor r13d, r13d
loc_2D6B2:
mov rdi, r14
mov rsi, r12
call JS_FreeCString
test r13, r13
jz short loc_2D6E7
mov rax, [rsp+48h+var_38]
mov [rax+r15], r13
add r15, 10h
mov rdi, r14
mov rsi, r13
call js_resolve_module
test eax, eax
mov r13, [rsp+48h+var_40]
jns loc_2D64A
loc_2D6E7:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_2D6EE
loc_2D6EC:
xor eax, eax
loc_2D6EE:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_resolve_module(long long a1, long long a2)
{
int v2; // ecx
long long result; // rax
long long v4; // r13
long long v5; // r15
long long v6; // rbx
int v7; // ebp
long long v8; // rax
long long v9; // r12
long long v10; // rax
long long v11; // rbp
long long v12; // r13
int v13; // eax
long long v14; // [rsp+8h] [rbp-38h]
v2 = *(_DWORD *)(a2 + 128);
result = 0LL;
if ( (v2 & 0xFF00) == 0 )
{
v4 = a2;
*(_DWORD *)(a2 + 128) = v2 | 0x100;
v5 = 8LL;
v6 = -1LL;
while ( ++v6 < *(int *)(v4 + 32) )
{
v14 = *(_QWORD *)(v4 + 24);
v7 = *(_DWORD *)(v14 + v5 - 8);
v8 = JS_AtomToCString(a1, *(_DWORD *)(v4 + 4));
if ( v8 )
{
v9 = v8;
v10 = JS_AtomToCString(a1, v7);
if ( v10 )
{
v11 = v10;
v12 = js_host_resolve_imported_module(a1, v9, v10);
JS_FreeCString(a1, v9);
v9 = v11;
}
else
{
v12 = 0LL;
}
JS_FreeCString(a1, v9);
if ( v12 )
{
*(_QWORD *)(v14 + v5) = v12;
v5 += 16LL;
v13 = js_resolve_module(a1, v12);
v4 = a2;
if ( v13 >= 0 )
continue;
}
}
return -1LL;
}
return 0LL;
}
return result;
}
| js_resolve_module:
MOV ECX,dword ptr [RSI + 0x80]
XOR EAX,EAX
TEST CX,0xff00
JZ 0x0012d61e
RET
LAB_0012d61e:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,RSI
MOV R14,RDI
OR ECX,0x100
MOV dword ptr [RSI + 0x80],ECX
PUSH 0x8
POP R15
PUSH -0x1
POP RBX
MOV qword ptr [RSP + 0x8],RSI
LAB_0012d64a:
MOVSXD RAX,dword ptr [R13 + 0x20]
INC RBX
CMP RBX,RAX
JGE 0x0012d6ec
MOV RAX,qword ptr [R13 + 0x18]
MOV ESI,dword ptr [R13 + 0x4]
MOV qword ptr [RSP + 0x10],RAX
MOV EBP,dword ptr [RAX + R15*0x1 + -0x8]
MOV RDI,R14
CALL 0x0011e56f
TEST RAX,RAX
JZ 0x0012d6e7
MOV R12,RAX
MOV RDI,R14
MOV ESI,EBP
CALL 0x0011e56f
TEST RAX,RAX
JZ 0x0012d6af
MOV RBP,RAX
MOV RDI,R14
MOV RSI,R12
MOV RDX,RAX
CALL 0x0013f225
MOV R13,RAX
MOV RDI,R14
MOV RSI,R12
CALL 0x0011ec07
MOV R12,RBP
JMP 0x0012d6b2
LAB_0012d6af:
XOR R13D,R13D
LAB_0012d6b2:
MOV RDI,R14
MOV RSI,R12
CALL 0x0011ec07
TEST R13,R13
JZ 0x0012d6e7
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + R15*0x1],R13
ADD R15,0x10
MOV RDI,R14
MOV RSI,R13
CALL 0x0012d60e
TEST EAX,EAX
MOV R13,qword ptr [RSP + 0x8]
JNS 0x0012d64a
LAB_0012d6e7:
PUSH -0x1
POP RAX
JMP 0x0012d6ee
LAB_0012d6ec:
XOR EAX,EAX
LAB_0012d6ee:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 js_resolve_module(int8 param_1,long param_2)
{
int4 uVar1;
long lVar2;
int iVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
if ((*(uint *)(param_2 + 0x80) & 0xff00) != 0) {
return 0;
}
*(uint *)(param_2 + 0x80) = *(uint *)(param_2 + 0x80) | 0x100;
lVar8 = 8;
lVar7 = -1;
while( true ) {
lVar7 = lVar7 + 1;
if (*(int *)(param_2 + 0x20) <= lVar7) {
return 0;
}
lVar2 = *(long *)(param_2 + 0x18);
uVar1 = *(int4 *)(lVar2 + -8 + lVar8);
lVar4 = JS_AtomToCString(param_1,*(int4 *)(param_2 + 4));
if (lVar4 == 0) break;
lVar5 = JS_AtomToCString(param_1,uVar1);
if (lVar5 == 0) {
lVar6 = 0;
}
else {
lVar6 = js_host_resolve_imported_module(param_1,lVar4,lVar5);
JS_FreeCString(param_1,lVar4);
lVar4 = lVar5;
}
JS_FreeCString(param_1,lVar4);
if (lVar6 == 0) {
return 0xffffffffffffffff;
}
*(long *)(lVar2 + lVar8) = lVar6;
lVar8 = lVar8 + 0x10;
iVar3 = js_resolve_module(param_1,lVar6);
if (iVar3 < 0) {
return 0xffffffffffffffff;
}
}
return 0xffffffffffffffff;
}
|
|
6,472 | OpenSubdiv::v3_6_0::Bfr::FaceVertex::assignUnOrderedFaceNeighbors(OpenSubdiv::v3_6_0::Bfr::FaceVertex::Edge const*, short const*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/faceVertex.cpp | void
FaceVertex::assignUnOrderedFaceNeighbors(Edge const edges[],
short const feEdges[]) {
int numFaceEdges = 2 * GetNumFaces();
for (int i = 0; i < numFaceEdges; ++i) {
assert(feEdges[i] >= 0);
Edge const & E = edges[feEdges[i]];
bool edgeIsSingular = E.nonManifold || E.boundary;
if (edgeIsSingular) {
_faceEdgeNeighbors[i] = -1;
} else {
_faceEdgeNeighbors[i] = (i & 1) ? E.nextFace : E.prevFace;
}
}
} | O1 | cpp | OpenSubdiv::v3_6_0::Bfr::FaceVertex::assignUnOrderedFaceNeighbors(OpenSubdiv::v3_6_0::Bfr::FaceVertex::Edge const*, short const*):
pushq %rax
movzwl 0x2(%rdi), %eax
testw %ax, %ax
jle 0x8843f
addl %eax, %eax
movzwl %ax, %eax
movq 0xa8(%rdi), %rcx
xorl %edi, %edi
movswq (%rdx,%rdi,2), %r8
testq %r8, %r8
js 0x88441
leaq (%r8,%r8,2), %r9
movw $0xffff, %r8w # imm = 0xFFFF
testb $0x5, 0x4(%rsi,%r9,4)
jne 0x88432
leaq (%rsi,%r9,4), %r8
movl %edi, %r9d
andl $0x1, %r9d
movzwl 0x6(%r8,%r9,2), %r8d
movw %r8w, (%rcx,%rdi,2)
incq %rdi
cmpq %rdi, %rax
jne 0x88406
popq %rax
retq
leaq 0x361e9(%rip), %rdi # 0xbe631
leaq 0x35ea2(%rip), %rsi # 0xbe2f1
leaq 0x361eb(%rip), %rcx # 0xbe641
movl $0x313, %edx # imm = 0x313
callq 0x39560
| _ZN10OpenSubdiv6v3_6_03Bfr10FaceVertex28assignUnOrderedFaceNeighborsEPKNS2_4EdgeEPKs:
push rax
movzx eax, word ptr [rdi+2]
test ax, ax
jle short loc_8843F
add eax, eax
movzx eax, ax
mov rcx, [rdi+0A8h]
xor edi, edi
loc_88406:
movsx r8, word ptr [rdx+rdi*2]
test r8, r8
js short loc_88441
lea r9, [r8+r8*2]
mov r8w, 0FFFFh
test byte ptr [rsi+r9*4+4], 5
jnz short loc_88432
lea r8, [rsi+r9*4]
mov r9d, edi
and r9d, 1
movzx r8d, word ptr [r8+r9*2+6]
loc_88432:
mov [rcx+rdi*2], r8w
inc rdi
cmp rax, rdi
jnz short loc_88406
loc_8843F:
pop rax
retn
loc_88441:
lea rdi, aFeedgesI0; "feEdges[i] >= 0"
lea rsi, aWorkspaceLlm4b_33; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidOpensubdiv_113; "void OpenSubdiv::v3_6_0::Bfr::FaceVerte"...
mov edx, 313h
call ___assert_fail
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> OpenSubdiv::v3_6_0::Bfr::FaceVertex::assignUnOrderedFaceNeighbors(
OpenSubdiv::v3_6_0::Bfr::FaceVertex *this,
const OpenSubdiv::v3_6_0::Bfr::FaceVertex::Edge *a2,
const __int16 *a3)
{
__int16 v3; // ax
long long v4; // rax
long long v5; // rcx
long long v6; // rdi
long long v7; // r8
long long v8; // r9
__int16 v9; // r8
v3 = *((_WORD *)this + 1);
if ( v3 > 0 )
{
v4 = (unsigned __int16)(2 * v3);
v5 = *((_QWORD *)this + 21);
v6 = 0LL;
do
{
v7 = a3[v6];
if ( v7 < 0 )
__assert_fail(
"feEdges[i] >= 0",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/faceVertex.cpp",
787LL,
"void OpenSubdiv::v3_6_0::Bfr::FaceVertex::assignUnOrderedFaceNeighbors(const Edge *, const short *)");
v8 = 3 * v7;
v9 = -1;
if ( (*((_BYTE *)a2 + 4 * v8 + 4) & 5) == 0 )
v9 = *((_WORD *)a2 + 2 * v8 + (v6 & 1) + 3);
*(_WORD *)(v5 + 2 * v6++) = v9;
}
while ( v4 != v6 );
}
}
| assignUnOrderedFaceNeighbors:
PUSH RAX
MOVZX EAX,word ptr [RDI + 0x2]
TEST AX,AX
JLE 0x0018843f
ADD EAX,EAX
MOVZX EAX,AX
MOV RCX,qword ptr [RDI + 0xa8]
XOR EDI,EDI
LAB_00188406:
MOVSX R8,word ptr [RDX + RDI*0x2]
TEST R8,R8
JS 0x00188441
LEA R9,[R8 + R8*0x2]
MOV R8W,0xffff
TEST byte ptr [RSI + R9*0x4 + 0x4],0x5
JNZ 0x00188432
LEA R8,[RSI + R9*0x4]
MOV R9D,EDI
AND R9D,0x1
MOVZX R8D,word ptr [R8 + R9*0x2 + 0x6]
LAB_00188432:
MOV word ptr [RCX + RDI*0x2],R8W
INC RDI
CMP RAX,RDI
JNZ 0x00188406
LAB_0018843f:
POP RAX
RET
LAB_00188441:
LEA RDI,[0x1be631]
LEA RSI,[0x1be2f1]
LEA RCX,[0x1be641]
MOV EDX,0x313
CALL 0x00139560
|
/* OpenSubdiv::v3_6_0::Bfr::FaceVertex::assignUnOrderedFaceNeighbors(OpenSubdiv::v3_6_0::Bfr::FaceVertex::Edge
const*, short const*) */
int8 __thiscall
OpenSubdiv::v3_6_0::Bfr::FaceVertex::assignUnOrderedFaceNeighbors
(FaceVertex *this,Edge *param_1,short *param_2)
{
short sVar1;
long lVar2;
int8 in_RAX;
ulong uVar3;
int2 uVar4;
long lVar5;
sVar1 = *(short *)(this + 2);
if (0 < sVar1) {
lVar2 = *(long *)(this + 0xa8);
uVar3 = 0;
do {
lVar5 = (long)param_2[uVar3];
if (lVar5 < 0) {
/* WARNING: Subroutine does not return */
__assert_fail("feEdges[i] >= 0",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/faceVertex.cpp"
,0x313,
"void OpenSubdiv::v3_6_0::Bfr::FaceVertex::assignUnOrderedFaceNeighbors(const Edge *, const short *)"
);
}
uVar4 = 0xffff;
if (((byte)param_1[lVar5 * 0xc + 4] & 5) == 0) {
uVar4 = *(int2 *)(param_1 + (ulong)((uint)uVar3 & 1) * 2 + lVar5 * 0xc + 6);
}
*(int2 *)(lVar2 + uVar3 * 2) = uVar4;
uVar3 = uVar3 + 1;
} while ((ushort)(sVar1 * 2) != uVar3);
}
return in_RAX;
}
|
|
6,473 | 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>::get_binary() const | monkey531[P]llama/common/json.hpp | const binary_t& get_binary() const
{
if (!is_binary())
{
JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
}
return *get_ptr<const binary_t*>();
} | O0 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_binary() const:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb2960
testb $0x1, %al
jne 0x17b2b2
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0x59660
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0xb2d00
movq %rax, 0x28(%rsp)
leaq 0x94799(%rip), %rsi # 0x20f9c3
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x110db0
jmp 0x17b23b
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
movl $0x12e, %esi # imm = 0x12E
leaq 0x30(%rsp), %rdx
callq 0x110c00
jmp 0x17b256
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
leaq 0x122b21(%rip), %rsi # 0x29dd88
leaq -0xc84be(%rip), %rdx # 0xb2db0
callq 0x59ac0
jmp 0x17b2cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x17b29d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5a4d8
testb $0x1, 0x1b(%rsp)
jne 0x17b2a6
jmp 0x17b2b0
movq 0x8(%rsp), %rdi
callq 0x59f20
jmp 0x17b2c1
movq 0x10(%rsp), %rdi
callq 0x17b800
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x59b80
nopl (%rax,%rax)
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv:
sub rsp, 58h
mov qword ptr [rsp+58h+var_8], rdi; char
mov rdi, qword ptr [rsp+58h+var_8]
mov qword ptr [rsp+58h+var_48], rdi; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_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>::is_binary(void)
test al, 1
jnz loc_17B2B2
mov [rsp+58h+var_3D], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, qword ptr [rsp+58h+var_48]
mov [rsp+58h+var_50], rax; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov qword ptr [rsp+58h+var_30], rax; int
lea rsi, aTypeMustBeBina; "type must be binary, but is "
lea rdi, [rsp+58h+var_28]
lea rdx, [rsp+58h+var_30]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
jmp short $+2
loc_17B23B:
mov rcx, qword ptr [rsp+58h+var_48]
mov rdi, [rsp+58h+var_50]; int
mov esi, 12Eh
lea rdx, [rsp+58h+var_28]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
jmp short $+2
loc_17B256:
mov rdi, [rsp+58h+var_50]; void *
mov [rsp+58h+var_3D], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
jmp short loc_17B2CB
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
jmp short loc_17B29D
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_17B29D:
test [rsp+arg_13], 1
jnz short loc_17B2A6
jmp short loc_17B2B0
loc_17B2A6:
mov rdi, [rsp+arg_0]; void *
call ___cxa_free_exception
loc_17B2B0:
jmp short loc_17B2C1
loc_17B2B2:
mov rdi, qword ptr [rsp+58h+var_48]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE7get_ptrIPKNS0_27byte_container_with_subtypeISC_EETnNSt9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINSt14remove_pointerISK_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalISK_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISK_EEEEv
add rsp, 58h
retn
loc_17B2C1:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
loc_17B2CB:
nop dword ptr [rax+rax+00h]
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_binary(
_BYTE *a1)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // [rsp+8h] [rbp-50h]
int v3[2]; // [rsp+28h] [rbp-30h] BYREF
char v4[32]; // [rsp+30h] [rbp-28h] BYREF
char v5[8]; // [rsp+50h] [rbp-8h]
*(_QWORD *)v5 = a1;
if ( !nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_binary(a1) )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
*(_QWORD *)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>::type_name(a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v4,
(long long)"type must be binary, but is ",
(nlohmann::json_abi_v3_11_3::detail **)v3);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302LL,
(long long)v4,
(long long)a1);
__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::type_error::~type_error);
}
return ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE7get_ptrIPKNS0_27byte_container_with_subtypeISC_EETnNSt9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINSt14remove_pointerISK_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalISK_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISK_EEEEv(a1);
}
| |||
6,474 | 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>::get_binary() const | monkey531[P]llama/common/json.hpp | const binary_t& get_binary() const
{
if (!is_binary())
{
JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
}
return *get_ptr<const binary_t*>();
} | 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>::get_binary() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x8, (%rdi)
jne 0x82357
movq 0x8(%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x23450
movq %rax, %rbx
movq %r14, %rdi
callq 0x425be
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x31c63(%rip), %rsi # 0xb3fdc
leaq 0x10(%rsp), %rdi
callq 0x6272b
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x6263e
xorl %ebp, %ebp
leaq 0x77ba4(%rip), %rsi # 0xf9f48
leaq -0x4325d(%rip), %rdx # 0x3f14e
movq %rbx, %rdi
callq 0x23e90
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x24158
testb %bpl, %bpl
jne 0x823ca
jmp 0x823d2
movq %rax, %r14
movq %rbx, %rdi
callq 0x23660
movq %r14, %rdi
callq 0x23f10
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 8
jnz short loc_82357
mov rax, [r14+8]
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_82357:
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+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeBina; "type must be binary, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],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 rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_823CA
jmp short loc_823D2
mov r14, rax
loc_823CA:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_823D2:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_binary(
long long a1)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
const char *v3; // [rsp+8h] [rbp-40h] BYREF
_BYTE v4[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 8 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
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>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v4,
(long long)"type must be binary, but is ",
&v3);
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,
(long long)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);
}
return *(_QWORD *)(a1 + 8);
}
| get_binary:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x8
JNZ 0x00182357
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00182357:
PUSH 0x20
POP RDI
CALL 0x00123450
MOV RBX,RAX
MOV RDI,R14
CALL 0x001425be
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00182372:
LEA RSI,[0x1b3fdc]
LEA RDI,[RSP + 0x10]
CALL 0x0016272b
MOV BPL,0x1
LAB_00182386:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x0016263e
XOR EBP,EBP
LEA RSI,[0x1f9f48]
LEA RDX,[0x13f14e]
MOV RDI,RBX
CALL 0x00123e90
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, 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() const */
int8 __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>
::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>
*this)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x8) {
return *(int8 *)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 00182372 to 00182382 has its CatchHandler @ 001823c7 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be binary, but is ",&local_40);
/* try { // try from 00182386 to 001823b2 has its CatchHandler @ 001823b3 */
_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,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
|
|
6,475 | mysql_stmt_fetch | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt)
{
unsigned char *row;
int rc;
if (stmt->state <= MYSQL_STMT_EXECUTED)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state < MYSQL_STMT_WAITING_USE_OR_STORE || !stmt->field_count)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
} else if (stmt->state== MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler(stmt);
}
if (stmt->state == MYSQL_STMT_FETCH_DONE)
return(MYSQL_NO_DATA);
if ((rc= stmt->mysql->methods->db_stmt_fetch(stmt, &row)))
{
stmt->state= MYSQL_STMT_FETCH_DONE;
stmt->mysql->status= MYSQL_STATUS_READY;
/* to fetch data again, stmt must be executed again */
return(rc);
}
rc= stmt->mysql->methods->db_stmt_fetch_to_bind(stmt, row);
stmt->state= MYSQL_STMT_USER_FETCHING;
CLEAR_CLIENT_ERROR(stmt->mysql);
CLEAR_CLIENT_STMT_ERROR(stmt);
return(rc);
} | O0 | c | mysql_stmt_fetch:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x50(%rax)
ja 0x299c7
jmp 0x29958
movq -0x10(%rbp), %rax
movl $0x7de, 0x108(%rax) # imm = 0x7DE
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x36598(%rip), %rax # 0x5ff10
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x3657e(%rip), %rax # 0x5ff20
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x29b95
movq -0x10(%rbp), %rax
cmpl $0x3, 0x50(%rax)
jb 0x299db
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x29a4c
jmp 0x299dd
movq -0x10(%rbp), %rax
movl $0x7de, 0x108(%rax) # imm = 0x7DE
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x36513(%rip), %rax # 0x5ff10
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x364f9(%rip), %rax # 0x5ff20
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x29b95
movq -0x10(%rbp), %rax
cmpl $0x3, 0x50(%rax)
jne 0x29a67
movq -0x10(%rbp), %rax
movq 0x358(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
jmp 0x29a69
movq -0x10(%rbp), %rax
cmpl $0x6, 0x50(%rax)
jne 0x29a7f
movl $0x64, -0x4(%rbp)
jmp 0x29b95
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x29acc
movq -0x10(%rbp), %rax
movl $0x6, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x0, 0x488(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x29b95
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl $0x5, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x0, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x21dcc(%rip), %rsi # 0x4b8eb
callq 0x133c0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x97(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x29b5b
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x2a0(%rax), %rax
movl $0x0, 0x4(%rax)
jmp 0x29b5d
jmp 0x29b5f
movq -0x10(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x21d6c(%rip), %rsi # 0x4b8eb
callq 0x133c0
movq -0x10(%rbp), %rax
movb $0x0, 0x10c(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| mysql_stmt_fetch:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 2
ja short loc_299C7
jmp short $+2
loc_29958:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 7DEh
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+70h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_4], 1
jmp loc_29B95
loc_299C7:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 3
jb short loc_299DB
mov rax, [rbp+var_10]
cmp dword ptr [rax+60h], 0
jnz short loc_29A4C
loc_299DB:
jmp short $+2
loc_299DD:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 7DEh
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+70h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_4], 1
jmp loc_29B95
loc_29A4C:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 3
jnz short loc_29A67
mov rax, [rbp+var_10]
mov rax, [rax+358h]
mov rdi, [rbp+var_10]
call rax
loc_29A67:
jmp short $+2
loc_29A69:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 6
jnz short loc_29A7F
mov [rbp+var_4], 64h ; 'd'
jmp loc_29B95
loc_29A7F:
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+68h]
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_18]
call rax
mov [rbp+var_1C], eax
cmp eax, 0
jz short loc_29ACC
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 6
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov dword ptr [rax+488h], 0
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
jmp loc_29B95
loc_29ACC:
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+70h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call rax
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 5
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 0
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
add rdi, 297h
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov byte ptr [rax+97h], 0
mov rax, [rbp+var_10]
mov rax, [rax+38h]
cmp qword ptr [rax+2A0h], 0
jz short loc_29B5B
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+2A0h]
mov dword ptr [rax+4], 0
loc_29B5B:
jmp short $+2
loc_29B5D:
jmp short $+2
loc_29B5F:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 0
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov byte ptr [rax+10Ch], 0
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
loc_29B95:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long mysql_stmt_fetch(long long a1)
{
unsigned int v2; // [rsp+4h] [rbp-1Ch]
unsigned int v3; // [rsp+4h] [rbp-1Ch]
long long v4; // [rsp+8h] [rbp-18h] BYREF
long long v5; // [rsp+10h] [rbp-10h]
v5 = a1;
if ( *(_DWORD *)(a1 + 80) > 2u && *(_DWORD *)(v5 + 80) >= 3u && *(_DWORD *)(v5 + 96) )
{
if ( *(_DWORD *)(v5 + 80) == 3 )
(*(void ( **)(long long))(v5 + 856))(v5);
if ( *(_DWORD *)(v5 + 80) == 6 )
{
return 100;
}
else
{
v2 = (*(long long ( **)(long long, long long *))(*(_QWORD *)(*(_QWORD *)(v5 + 56) + 1232LL) + 104LL))(v5, &v4);
if ( v2 )
{
*(_DWORD *)(v5 + 80) = 6;
*(_DWORD *)(*(_QWORD *)(v5 + 56) + 1160LL) = 0;
return v2;
}
else
{
v3 = (*(long long ( **)(long long, long long))(*(_QWORD *)(*(_QWORD *)(v5 + 56) + 1232LL) + 112LL))(v5, v4);
*(_DWORD *)(v5 + 80) = 5;
*(_DWORD *)(*(_QWORD *)(v5 + 56) + 144LL) = 0;
strcpy(*(_QWORD *)(v5 + 56) + 663LL, "00000");
*(_BYTE *)(*(_QWORD *)(v5 + 56) + 151LL) = 0;
if ( *(_QWORD *)(*(_QWORD *)(v5 + 56) + 672LL) )
*(_DWORD *)(*(_QWORD *)(*(_QWORD *)(v5 + 56) + 672LL) + 4LL) = 0;
*(_DWORD *)(v5 + 264) = 0;
strcpy(v5 + 781, "00000");
*(_BYTE *)(v5 + 268) = 0;
return v3;
}
}
}
else
{
*(_DWORD *)(v5 + 264) = 2014;
strncpy(v5 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v5 + 786) = 0;
strncpy(v5 + 268, client_errors[14], 512LL);
*(_BYTE *)(v5 + 779) = 0;
return 1;
}
}
| mysql_stmt_fetch:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x2
JA 0x001299c7
JMP 0x00129958
LAB_00129958:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x7de
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x15ff10]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x15ff20]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00129b95
LAB_001299c7:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x3
JC 0x001299db
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x60],0x0
JNZ 0x00129a4c
LAB_001299db:
JMP 0x001299dd
LAB_001299dd:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x7de
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x15ff10]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x15ff20]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00129b95
LAB_00129a4c:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x3
JNZ 0x00129a67
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x358]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
LAB_00129a67:
JMP 0x00129a69
LAB_00129a69:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x6
JNZ 0x00129a7f
MOV dword ptr [RBP + -0x4],0x64
JMP 0x00129b95
LAB_00129a7f:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x68]
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x18]
CALL RAX
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
JZ 0x00129acc
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x6
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x488],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00129b95
LAB_00129acc:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x70]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL RAX
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x5
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RSI,[0x14b8eb]
CALL 0x001133c0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x00129b5b
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV dword ptr [RAX + 0x4],0x0
LAB_00129b5b:
JMP 0x00129b5d
LAB_00129b5d:
JMP 0x00129b5f
LAB_00129b5f:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RSI,[0x14b8eb]
CALL 0x001133c0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x10c],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
LAB_00129b95:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int mysql_stmt_fetch(long param_1)
{
int iVar1;
int8 local_20;
long local_18;
int local_c;
local_18 = param_1;
if (*(uint *)(param_1 + 0x50) < 3) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_18 + 0x312) = 0;
strncpy((char *)(local_18 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_0015ff90,0x200);
*(int1 *)(local_18 + 0x30b) = 0;
local_c = 1;
}
else if ((*(uint *)(param_1 + 0x50) < 3) || (*(int *)(param_1 + 0x60) == 0)) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_18 + 0x312) = 0;
strncpy((char *)(local_18 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_0015ff90,0x200);
*(int1 *)(local_18 + 0x30b) = 0;
local_c = 1;
}
else {
if (*(int *)(param_1 + 0x50) == 3) {
(**(code **)(param_1 + 0x358))(param_1);
}
if (*(int *)(local_18 + 0x50) == 6) {
local_c = 100;
}
else {
local_c = (**(code **)(*(long *)(*(long *)(local_18 + 0x38) + 0x4d0) + 0x68))
(local_18,&local_20);
if (local_c == 0) {
iVar1 = (**(code **)(*(long *)(*(long *)(local_18 + 0x38) + 0x4d0) + 0x70))
(local_18,local_20);
*(int4 *)(local_18 + 0x50) = 5;
*(int4 *)(*(long *)(local_18 + 0x38) + 0x90) = 0;
strcpy((char *)(*(long *)(local_18 + 0x38) + 0x297),"00000");
*(int1 *)(*(long *)(local_18 + 0x38) + 0x97) = 0;
if (*(long *)(*(long *)(local_18 + 0x38) + 0x2a0) != 0) {
*(int4 *)(*(long *)(*(long *)(local_18 + 0x38) + 0x2a0) + 4) = 0;
}
*(int4 *)(local_18 + 0x108) = 0;
strcpy((char *)(local_18 + 0x30d),"00000");
*(int1 *)(local_18 + 0x10c) = 0;
local_c = iVar1;
}
else {
*(int4 *)(local_18 + 0x50) = 6;
*(int4 *)(*(long *)(local_18 + 0x38) + 0x488) = 0;
}
}
}
return local_c;
}
|
|
6,476 | wt_end | eloqsql/mysys/waiting_threads.c | void wt_end()
{
DBUG_ENTER("wt_end");
if (!wt_init_done)
DBUG_VOID_RETURN;
DBUG_ASSERT(reshash.count == 0);
lf_hash_destroy(&reshash);
reshash.alloc.constructor= NULL;
wt_init_done= 0;
DBUG_VOID_RETURN;
} | O3 | c | wt_end:
cmpb $0x1, 0xb6226f(%rip) # 0xc08de0
jne 0xa6b96
pushq %rbp
movq %rsp, %rbp
leaq 0xb61f52(%rip), %rdi # 0xc08ad0
callq 0xa5d26
movq $0x0, 0xb61fc2(%rip) # 0xc08b50
movb $0x0, 0xb6224b(%rip) # 0xc08de0
popq %rbp
retq
| wt_end:
cmp cs:wt_init_done, 1
jnz short locret_A6B96
push rbp
mov rbp, rsp
lea rdi, reshash
call lf_hash_destroy
mov cs:qword_C08B50, 0
mov cs:wt_init_done, 0
pop rbp
locret_A6B96:
retn
| long long wt_end()
{
long long result; // rax
if ( wt_init_done == 1 )
{
result = lf_hash_destroy((long long)&reshash);
qword_C08B50 = 0LL;
wt_init_done = 0;
}
return result;
}
| wt_end:
CMP byte ptr [0x00d08de0],0x1
JNZ 0x001a6b96
PUSH RBP
MOV RBP,RSP
LEA RDI,[0xd08ad0]
CALL 0x001a5d26
MOV qword ptr [0x00d08b50],0x0
MOV byte ptr [0x00d08de0],0x0
POP RBP
LAB_001a6b96:
RET
|
void wt_end(void)
{
if (wt_init_done == '\x01') {
lf_hash_destroy(reshash);
reshash._128_8_ = 0;
wt_init_done = '\0';
}
return;
}
|
|
6,477 | end_io_cache | eloqsql/mysys/mf_iocache.c | int end_io_cache(IO_CACHE *info)
{
int error=0;
DBUG_ENTER("end_io_cache");
DBUG_PRINT("enter",("cache: %p", info));
/*
Every thread must call remove_io_thread(). The last one destroys
the share elements.
*/
DBUG_ASSERT(!info->share || !info->share->total_threads);
if (info->alloced_buffer)
{
info->alloced_buffer=0;
if (info->file != -1) /* File doesn't exist */
error= my_b_flush_io_cache(info,1);
my_free(info->buffer);
info->buffer=info->read_pos=(uchar*) 0;
}
if (info->type == SEQ_READ_APPEND)
{
/* Destroy allocated mutex */
mysql_mutex_destroy(&info->append_buffer_lock);
}
info->share= 0;
info->type= TYPE_NOT_SET; /* Ensure that flush_io_cache() does nothing */
info->write_end= 0; /* Ensure that my_b_write() fails */
info->write_function= 0; /* my_b_write will crash if used */
DBUG_RETURN(error);
} | O3 | c | end_io_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x100(%rdi)
je 0x977d4
movq $0x0, 0x100(%rbx)
cmpl $-0x1, 0xd4(%rbx)
je 0x977d9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x967f1
movl %eax, %r14d
jmp 0x977dc
xorl %r14d, %r14d
jmp 0x977ef
xorl %r14d, %r14d
movq 0x20(%rbx), %rdi
callq 0xa1412
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rax, 0x20(%rbx)
cmpl $0x3, 0xb0(%rbx)
jne 0x97828
leaq 0x50(%rbx), %r15
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x97820
leaq 0x2f0801(%rip), %rax # 0x388010
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x90(%rbx)
movq %r15, %rdi
callq 0x290c0
xorl %eax, %eax
movq %rax, 0x98(%rbx)
movl $0x0, 0xb0(%rbx)
movq %rax, 0x48(%rbx)
movq %rax, 0xa8(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| end_io_cache:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
cmp qword ptr [rdi+100h], 0
jz short loc_977D4
mov qword ptr [rbx+100h], 0
cmp dword ptr [rbx+0D4h], 0FFFFFFFFh
jz short loc_977D9
mov rdi, rbx
mov esi, 1
call my_b_flush_io_cache
mov r14d, eax
jmp short loc_977DC
loc_977D4:
xor r14d, r14d
jmp short loc_977EF
loc_977D9:
xor r14d, r14d
loc_977DC:
mov rdi, [rbx+20h]
call my_free
xor eax, eax
mov [rbx+10h], rax
mov [rbx+20h], rax
loc_977EF:
cmp dword ptr [rbx+0B0h], 3
jnz short loc_97828
lea r15, [rbx+50h]
mov rdi, [rbx+90h]
test rdi, rdi
jz short loc_97820
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+90h], 0
loc_97820:
mov rdi, r15
call _pthread_mutex_destroy
loc_97828:
xor eax, eax
mov [rbx+98h], rax
mov dword ptr [rbx+0B0h], 0
mov [rbx+48h], rax
mov [rbx+0A8h], rax
mov eax, r14d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long end_io_cache(long long a1)
{
unsigned int v2; // r14d
long long v3; // rdi
if ( *(_QWORD *)(a1 + 256) )
{
*(_QWORD *)(a1 + 256) = 0LL;
if ( *(_DWORD *)(a1 + 212) == -1 )
v2 = 0;
else
v2 = my_b_flush_io_cache((long long *)a1, 1);
my_free(*(_QWORD *)(a1 + 32));
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 32) = 0LL;
}
else
{
v2 = 0;
}
if ( *(_DWORD *)(a1 + 176) == 3 )
{
v3 = *(_QWORD *)(a1 + 144);
if ( v3 )
{
((void ( *)(long long))PSI_server[9])(v3);
*(_QWORD *)(a1 + 144) = 0LL;
}
pthread_mutex_destroy(a1 + 80);
}
*(_QWORD *)(a1 + 152) = 0LL;
*(_DWORD *)(a1 + 176) = 0;
*(_QWORD *)(a1 + 72) = 0LL;
*(_QWORD *)(a1 + 168) = 0LL;
return v2;
}
| end_io_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP qword ptr [RDI + 0x100],0x0
JZ 0x001977d4
MOV qword ptr [RBX + 0x100],0x0
CMP dword ptr [RBX + 0xd4],-0x1
JZ 0x001977d9
MOV RDI,RBX
MOV ESI,0x1
CALL 0x001967f1
MOV R14D,EAX
JMP 0x001977dc
LAB_001977d4:
XOR R14D,R14D
JMP 0x001977ef
LAB_001977d9:
XOR R14D,R14D
LAB_001977dc:
MOV RDI,qword ptr [RBX + 0x20]
CALL 0x001a1412
XOR EAX,EAX
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [RBX + 0x20],RAX
LAB_001977ef:
CMP dword ptr [RBX + 0xb0],0x3
JNZ 0x00197828
LEA R15,[RBX + 0x50]
MOV RDI,qword ptr [RBX + 0x90]
TEST RDI,RDI
JZ 0x00197820
LEA RAX,[0x488010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x90],0x0
LAB_00197820:
MOV RDI,R15
CALL 0x001290c0
LAB_00197828:
XOR EAX,EAX
MOV qword ptr [RBX + 0x98],RAX
MOV dword ptr [RBX + 0xb0],0x0
MOV qword ptr [RBX + 0x48],RAX
MOV qword ptr [RBX + 0xa8],RAX
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 end_io_cache(long param_1)
{
int4 uVar1;
if (*(long *)(param_1 + 0x100) == 0) {
uVar1 = 0;
}
else {
*(int8 *)(param_1 + 0x100) = 0;
if (*(int *)(param_1 + 0xd4) == -1) {
uVar1 = 0;
}
else {
uVar1 = my_b_flush_io_cache(param_1,1);
}
my_free(*(int8 *)(param_1 + 0x20));
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x20) = 0;
}
if (*(int *)(param_1 + 0xb0) == 3) {
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x48))();
*(int8 *)(param_1 + 0x90) = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x50));
}
*(int8 *)(param_1 + 0x98) = 0;
*(int4 *)(param_1 + 0xb0) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0xa8) = 0;
return uVar1;
}
|
|
6,478 | minja::Value::to_str[abi:cxx11]() const | monkey531[P]llama/common/minja.hpp | std::string to_str() const {
if (is_string()) return get<std::string>();
if (is_number_integer()) return std::to_string(get<int64_t>());
if (is_number_float()) return std::to_string(get<double>());
if (is_boolean()) return get<bool>() ? "True" : "False";
if (is_null()) return "None";
return dump();
} | O2 | cpp | minja::Value::to_str[abi:cxx11]() const:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x40(%rsi), %eax
cmpl $0x3, %eax
jne 0x7021f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63934
jmp 0x702ad
leal -0x5(%rax), %ecx
cmpb $0x1, %cl
ja 0x7023c
movq %r14, %rdi
callq 0x62d48
movq %rbx, %rdi
movq %rax, %rsi
callq 0x70b28
jmp 0x702ad
cmpl $0x4, %eax
je 0x70258
cmpl $0x7, %eax
jne 0x7027b
movq %r14, %rdi
callq 0x62e1c
movq %rbx, %rdi
callq 0x70b88
jmp 0x702ad
movq %r14, %rdi
callq 0x6387e
leaq 0x43a15(%rip), %rcx # 0xb3c7c
leaq 0x43a13(%rip), %rsi # 0xb3c81
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x7(%rsp), %rdx
jmp 0x70293
movq %r14, %rdi
callq 0x634ea
testb %al, %al
je 0x7029d
leaq 0x43e0e(%rip), %rsi # 0xb409c
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
callq 0x275c8
jmp 0x702ad
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x62f00
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZNK5minja5Value6to_strB5cxx11Ev:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
movzx eax, byte ptr [rsi+40h]
cmp eax, 3
jnz short loc_7021F
mov rdi, rbx
mov rsi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
jmp loc_702AD
loc_7021F:
lea ecx, [rax-5]
cmp cl, 1
ja short loc_7023C
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rdi, rbx; this
mov rsi, rax; __int64
call _ZNSt7__cxx119to_stringEl; std::to_string(long)
jmp short loc_702AD
loc_7023C:
cmp eax, 4
jz short loc_70258
cmp eax, 7
jnz short loc_7027B
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
mov rdi, rbx; this
call _ZNSt7__cxx119to_stringEd; std::to_string(double)
jmp short loc_702AD
loc_70258:
mov rdi, r14
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
lea rcx, aTrue_0; "True"
lea rsi, aFalse; "False"
test al, al
cmovnz rsi, rcx
lea rdx, [rsp+18h+var_11]
jmp short loc_70293
loc_7027B:
mov rdi, r14; this
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jz short loc_7029D
lea rsi, aNone_0; "None"
lea rdx, [rsp+18h+var_12]
loc_70293:
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short loc_702AD
loc_7029D:
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, rbx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
loc_702AD:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| std::__cxx11 * minja::Value::to_str[abi:cxx11](std::__cxx11 *this, minja::Value *a2, double a3)
{
int v3; // eax
long long v4; // rax
char v5; // al
const char *v6; // rsi
v3 = *((unsigned __int8 *)a2 + 64);
if ( v3 == 3 )
{
minja::Value::get<std::string>((long long)this, a2);
}
else
{
if ( (unsigned __int8)(v3 - 5) > 1u )
{
if ( v3 == 4 )
{
v5 = minja::Value::get<bool>(a2);
v6 = "False";
if ( v5 )
v6 = "True";
}
else
{
if ( v3 == 7 )
{
minja::Value::get<double>(a2);
std::to_string(this, a3);
return this;
}
if ( !minja::Value::is_null(a2) )
{
minja::Value::dump[abi:cxx11]((long long)this, (long long)a2, 0xFFFFFFFF, 0);
return this;
}
v6 = "None";
}
std::string::basic_string<std::allocator<char>>(this, (long long)v6);
return this;
}
v4 = minja::Value::get<long>(a2);
std::to_string(this, v4);
}
return this;
}
| to_str[abi:cxx11]:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOVZX EAX,byte ptr [RSI + 0x40]
CMP EAX,0x3
JNZ 0x0017021f
MOV RDI,RBX
MOV RSI,R14
CALL 0x00163934
JMP 0x001702ad
LAB_0017021f:
LEA ECX,[RAX + -0x5]
CMP CL,0x1
JA 0x0017023c
MOV RDI,R14
CALL 0x00162d48
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00170b28
JMP 0x001702ad
LAB_0017023c:
CMP EAX,0x4
JZ 0x00170258
CMP EAX,0x7
JNZ 0x0017027b
MOV RDI,R14
CALL 0x00162e1c
MOV RDI,RBX
CALL 0x00170b88
JMP 0x001702ad
LAB_00170258:
MOV RDI,R14
CALL 0x0016387e
LEA RCX,[0x1b3c7c]
LEA RSI,[0x1b3c81]
TEST AL,AL
CMOVNZ RSI,RCX
LEA RDX,[RSP + 0x7]
JMP 0x00170293
LAB_0017027b:
MOV RDI,R14
CALL 0x001634ea
TEST AL,AL
JZ 0x0017029d
LEA RSI,[0x1b409c]
LEA RDX,[RSP + 0x6]
LAB_00170293:
MOV RDI,RBX
CALL 0x001275c8
JMP 0x001702ad
LAB_0017029d:
PUSH -0x1
POP RDX
MOV RDI,RBX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00162f00
LAB_001702ad:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::Value::to_str[abi:cxx11]() const */
void minja::Value::to_str_abi_cxx11_(void)
{
Value VVar1;
bool bVar2;
char cVar3;
long lVar4;
allocator *paVar5;
Value *in_RSI;
char *pcVar6;
__cxx11 *in_RDI;
double dVar7;
allocator local_12;
allocator local_11;
VVar1 = in_RSI[0x40];
if (VVar1 == (Value)0x3) {
get<std::__cxx11::string>();
}
else if ((byte)((char)VVar1 - 5U) < 2) {
lVar4 = get<long>(in_RSI);
std::__cxx11::to_string(in_RDI,lVar4);
}
else {
if (VVar1 == (Value)0x4) {
bVar2 = get<bool>(in_RSI);
pcVar6 = "False";
if (bVar2) {
pcVar6 = "True";
}
paVar5 = &local_11;
}
else {
if (VVar1 == (Value)0x7) {
dVar7 = get<double>(in_RSI);
std::__cxx11::to_string(dVar7);
return;
}
cVar3 = is_null(in_RSI);
if (cVar3 == '\0') {
dump_abi_cxx11_((int)in_RDI,SUB81(in_RSI,0));
return;
}
pcVar6 = "None";
paVar5 = &local_12;
}
std::__cxx11::string::string<std::allocator<char>>((string *)in_RDI,pcVar6,paVar5);
}
return;
}
|
|
6,479 | stmt_set_error | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | void stmt_set_error(MYSQL_STMT *stmt,
unsigned int error_nr,
const char *sqlstate,
const char *format,
...)
{
va_list ap;
const char *error= NULL;
if (error_nr >= CR_MIN_ERROR && error_nr <= CR_MYSQL_LAST_ERROR)
error= ER(error_nr);
else if (error_nr >= CER_MIN_ERROR && error_nr <= CR_MARIADB_LAST_ERROR)
error= CER(error_nr);
stmt->last_errno= error_nr;
ma_strmake(stmt->sqlstate, sqlstate, SQLSTATE_LENGTH);
va_start(ap, format);
vsnprintf(stmt->last_error, MYSQL_ERRMSG_SIZE,
format ? format : error ? error : "", ap);
va_end(ap);
return;
} | O3 | c | stmt_set_error:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r14
movq %rdx, %rcx
movq %rdi, %rbx
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x1ecc0
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leal -0x7d0(%rsi), %eax
cmpl $0x3e, %eax
jae 0x1ecd4
leaq 0x2be5e(%rip), %rdx # 0x4ab30
jmp 0x1ece6
leal -0x1388(%rsi), %eax
cmpl $0xf, %eax
ja 0x1ecee
leaq 0x2c04a(%rip), %rdx # 0x4ad30
movl %eax, %eax
movq (%rdx,%rax,8), %r15
jmp 0x1ecf1
xorl %r15d, %r15d
movl %esi, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
movl $0x5, %edx
movq %rcx, %rsi
callq 0x25a97
movabsq $0x3000000020, %rax # imm = 0x3000000020
leaq -0x30(%rbp), %r9
movq %rax, (%r9)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r9)
leaq -0xe0(%rbp), %rax
movq %rax, 0x10(%r9)
testq %r15, %r15
leaq 0x168be(%rip), %r8 # 0x355f7
cmovneq %r15, %r8
testq %r14, %r14
cmovneq %r14, %r8
addq $0x10c, %rbx # imm = 0x10C
movl $0x200, %esi # imm = 0x200
movq %rbx, %rdi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x13380
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| stmt_set_error:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 0C8h
mov r14, rcx
mov rcx, rdx
mov rbx, rdi
mov [rbp+var_C0], r8
mov [rbp+var_B8], r9
test al, al
jz short loc_1ECC0
movaps [rbp+var_B0], xmm0
movaps [rbp+var_A0], xmm1
movaps [rbp+var_90], xmm2
movaps [rbp+var_80], xmm3
movaps [rbp+var_70], xmm4
movaps [rbp+var_60], xmm5
movaps [rbp+var_50], xmm6
movaps [rbp+var_40], xmm7
loc_1ECC0:
lea eax, [rsi-7D0h]
cmp eax, 3Eh ; '>'
jnb short loc_1ECD4
lea rdx, client_errors
jmp short loc_1ECE6
loc_1ECD4:
lea eax, [rsi-1388h]
cmp eax, 0Fh
ja short loc_1ECEE
lea rdx, mariadb_client_errors
loc_1ECE6:
mov eax, eax
mov r15, [rdx+rax*8]
jmp short loc_1ECF1
loc_1ECEE:
xor r15d, r15d
loc_1ECF1:
mov [rbx+108h], esi
lea rdi, [rbx+30Dh]
mov edx, 5
mov rsi, rcx
call ma_strmake
mov rax, 3000000020h
lea r9, [rbp+var_30]
mov [r9], rax
lea rax, [rbp+arg_0]
mov [r9+8], rax
lea rax, [rbp+var_E0]
mov [r9+10h], rax
test r15, r15
lea r8, aExecuteTestWit+29h; ""
cmovnz r8, r15
test r14, r14
cmovnz r8, r14
add rbx, 10Ch
mov esi, 200h
mov rdi, rbx
mov edx, 1
mov rcx, 0FFFFFFFFFFFFFFFFh
call ___vsnprintf_chk
add rsp, 0C8h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long stmt_set_error(long long a1, int a2, long long a3, char *a4, ...)
{
int v6; // eax
char **v7; // rdx
char *v8; // r15
char *v9; // r8
va_list va; // [rsp+B0h] [rbp-30h] BYREF
v6 = a2 - 2000;
if ( (unsigned int)(a2 - 2000) < 0x3E )
{
v7 = client_errors;
LABEL_5:
v8 = v7[v6];
goto LABEL_7;
}
v6 = a2 - 5000;
if ( (unsigned int)(a2 - 5000) <= 0xF )
{
v7 = mariadb_client_errors;
goto LABEL_5;
}
v8 = 0LL;
LABEL_7:
*(_DWORD *)(a1 + 264) = a2;
ma_strmake(a1 + 781, a3, 5LL);
va_start(va, a4);
v9 = "";
if ( v8 )
v9 = v8;
if ( a4 )
v9 = a4;
return __vsnprintf_chk(a1 + 268, 512LL, 1LL, -1LL, v9, va);
}
| stmt_set_error:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xc8
MOV R14,RCX
MOV RCX,RDX
MOV RBX,RDI
MOV qword ptr [RBP + -0xc0],R8
MOV qword ptr [RBP + -0xb8],R9
TEST AL,AL
JZ 0x0011ecc0
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM1
MOVAPS xmmword ptr [RBP + -0x90],XMM2
MOVAPS xmmword ptr [RBP + -0x80],XMM3
MOVAPS xmmword ptr [RBP + -0x70],XMM4
MOVAPS xmmword ptr [RBP + -0x60],XMM5
MOVAPS xmmword ptr [RBP + -0x50],XMM6
MOVAPS xmmword ptr [RBP + -0x40],XMM7
LAB_0011ecc0:
LEA EAX,[RSI + -0x7d0]
CMP EAX,0x3e
JNC 0x0011ecd4
LEA RDX,[0x14ab30]
JMP 0x0011ece6
LAB_0011ecd4:
LEA EAX,[RSI + -0x1388]
CMP EAX,0xf
JA 0x0011ecee
LEA RDX,[0x14ad30]
LAB_0011ece6:
MOV EAX,EAX
MOV R15,qword ptr [RDX + RAX*0x8]
JMP 0x0011ecf1
LAB_0011ecee:
XOR R15D,R15D
LAB_0011ecf1:
MOV dword ptr [RBX + 0x108],ESI
LEA RDI,[RBX + 0x30d]
MOV EDX,0x5
MOV RSI,RCX
CALL 0x00125a97
MOV RAX,0x3000000020
LEA R9,[RBP + -0x30]
MOV qword ptr [R9],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [R9 + 0x8],RAX
LEA RAX,[RBP + -0xe0]
MOV qword ptr [R9 + 0x10],RAX
TEST R15,R15
LEA R8,[0x1355f7]
CMOVNZ R8,R15
TEST R14,R14
CMOVNZ R8,R14
ADD RBX,0x10c
MOV ESI,0x200
MOV RDI,RBX
MOV EDX,0x1
MOV RCX,-0x1
CALL 0x00113380
ADD RSP,0xc8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void stmt_set_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long param_9,int param_10,int8 param_11,char *param_12,int8 param_13,
int8 param_14)
{
char in_AL;
uint uVar1;
int **ppuVar2;
char *pcVar3;
char *pcVar4;
int1 local_e8 [32];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int1 *local_30;
int1 *local_28;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
uVar1 = param_10 - 2000;
if (uVar1 < 0x3e) {
ppuVar2 = &client_errors;
}
else {
uVar1 = param_10 - 5000;
if (0xf < uVar1) {
pcVar4 = (char *)0x0;
goto LAB_0011ecf1;
}
ppuVar2 = (int **)mariadb_client_errors;
}
pcVar4 = ppuVar2[uVar1];
LAB_0011ecf1:
*(int *)(param_9 + 0x108) = param_10;
local_c8 = param_13;
local_c0 = param_14;
ma_strmake(param_9 + 0x30d,param_11,5);
local_38 = 0x3000000020;
local_30 = &stack0x00000008;
local_28 = local_e8;
pcVar3 = "";
if (pcVar4 != (char *)0x0) {
pcVar3 = pcVar4;
}
if (param_12 != (char *)0x0) {
pcVar3 = param_12;
}
__vsnprintf_chk(param_9 + 0x10c,0x200,1,0xffffffffffffffff,pcVar3);
return;
}
|
|
6,480 | qdevtools::QMarginsEdit::setMargins(QMargins const&) | HuaiminNotSleepYet[P]QDevTools/qdevtools.cpp | void setMargins(const QMargins& value)
{
if (value == margins())
return;
{
QSignalBlocker blocker{this};
t_->setValue(value.top());
r_->setValue(value.right());
b_->setValue(value.bottom());
l_->setValue(value.left());
}
emit valueChanged();
} | O0 | cpp | qdevtools::QMarginsEdit::setMargins(QMargins const&):
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x34440
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x331d0
testb $0x1, %al
jne 0x346d0
jmp 0x346d5
jmp 0x3477c
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x347d0
movq -0x50(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34520
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0x100c0
jmp 0x34704
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x345a0
movq -0x60(%rbp), %rdi
movl %eax, %esi
callq 0x100c0
jmp 0x34726
movq -0x50(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x345c0
movq -0x68(%rbp), %rdi
movl %eax, %esi
callq 0x100c0
jmp 0x34748
movq -0x50(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x345e0
movq -0x70(%rbp), %rdi
movl %eax, %esi
callq 0x100c0
jmp 0x3476a
leaq -0x30(%rbp), %rdi
callq 0x34830
movq -0x50(%rbp), %rdi
callq 0x103a0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34830
movq -0x38(%rbp), %rdi
callq 0xf410
| _ZN9qdevtools12QMarginsEdit10setMarginsERK8QMargins:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]; this
mov [rbp+var_50], rdi
mov rax, [rbp+var_10]
mov [rbp+var_48], rax
call _ZNK9qdevtools12QMarginsEdit7marginsEv; qdevtools::QMarginsEdit::margins(void)
mov rdi, [rbp+var_48]
mov [rbp+var_20], rax
mov [rbp+var_18], rdx
lea rsi, [rbp+var_20]
call _ZeqRK8QMarginsS1_; operator==(QMargins const&,QMargins const&)
test al, 1
jnz short loc_346D0
jmp short loc_346D5
loc_346D0:
jmp loc_3477C
loc_346D5:
mov rsi, [rbp+var_50]; QObject *
lea rdi, [rbp+var_30]; this
call _ZN14QSignalBlockerC2EP7QObject; QSignalBlocker::QSignalBlocker(QObject *)
mov rax, [rbp+var_50]
mov rax, [rax+28h]
mov [rbp+var_58], rax
mov rdi, [rbp+var_10]; this
call _ZNK8QMargins3topEv; QMargins::top(void)
mov rdi, [rbp+var_58]; this
mov esi, eax; int
call _ZN8QSpinBox8setValueEi; QSpinBox::setValue(int)
jmp short $+2
loc_34704:
mov rax, [rbp+var_50]
mov rax, [rax+30h]
mov [rbp+var_60], rax
mov rdi, [rbp+var_10]; this
call _ZNK8QMargins5rightEv; QMargins::right(void)
mov rdi, [rbp+var_60]; this
mov esi, eax; int
call _ZN8QSpinBox8setValueEi; QSpinBox::setValue(int)
jmp short $+2
loc_34726:
mov rax, [rbp+var_50]
mov rax, [rax+38h]
mov [rbp+var_68], rax
mov rdi, [rbp+var_10]; this
call _ZNK8QMargins6bottomEv; QMargins::bottom(void)
mov rdi, [rbp+var_68]; this
mov esi, eax; int
call _ZN8QSpinBox8setValueEi; QSpinBox::setValue(int)
jmp short $+2
loc_34748:
mov rax, [rbp+var_50]
mov rax, [rax+40h]
mov [rbp+var_70], rax
mov rdi, [rbp+var_10]; this
call _ZNK8QMargins4leftEv; QMargins::left(void)
mov rdi, [rbp+var_70]; this
mov esi, eax; int
call _ZN8QSpinBox8setValueEi; QSpinBox::setValue(int)
jmp short $+2
loc_3476A:
lea rdi, [rbp+var_30]; this
call _ZN14QSignalBlockerD2Ev; QSignalBlocker::~QSignalBlocker()
mov rdi, [rbp+var_50]; this
call _ZN9qdevtools13BuiltinEditor12valueChangedEv; qdevtools::BuiltinEditor::valueChanged(void)
loc_3477C:
add rsp, 70h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
lea rdi, [rbp+var_30]; this
call _ZN14QSignalBlockerD2Ev; QSignalBlocker::~QSignalBlocker()
mov rdi, [rbp+var_38]
call __Unwind_Resume
| char qdevtools::QMarginsEdit::setMargins(QSpinBox **this, const QMargins *a2)
{
long long v2; // rdx
char result; // al
int v4; // eax
int v5; // eax
int v6; // eax
unsigned int v7; // eax
long long v8; // rsi
long long v9; // rdx
long long v10; // rcx
void **v11; // r8
QSpinBox *v12; // [rsp+0h] [rbp-70h]
QSpinBox *v13; // [rsp+8h] [rbp-68h]
QSpinBox *v14; // [rsp+10h] [rbp-60h]
QSpinBox *v15; // [rsp+18h] [rbp-58h]
_BYTE v16[16]; // [rsp+40h] [rbp-30h] BYREF
_QWORD v17[2]; // [rsp+50h] [rbp-20h] BYREF
QMargins *v18; // [rsp+60h] [rbp-10h]
qdevtools::QMarginsEdit *v19; // [rsp+68h] [rbp-8h]
v19 = (qdevtools::QMarginsEdit *)this;
v18 = a2;
v17[0] = qdevtools::QMarginsEdit::margins(this);
v17[1] = v2;
result = operator==(a2, v17);
if ( (result & 1) == 0 )
{
QSignalBlocker::QSignalBlocker((QSignalBlocker *)v16, (QObject *)this);
v15 = this[5];
v4 = QMargins::top(v18);
QSpinBox::setValue(v15, v4);
v14 = this[6];
v5 = QMargins::right(v18);
QSpinBox::setValue(v14, v5);
v13 = this[7];
v6 = QMargins::bottom(v18);
QSpinBox::setValue(v13, v6);
v12 = this[8];
v7 = QMargins::left(v18);
v8 = v7;
QSpinBox::setValue(v12, v7);
QSignalBlocker::~QSignalBlocker((QSignalBlocker *)v16);
return qdevtools::BuiltinEditor::valueChanged((qdevtools::BuiltinEditor *)this, v8, v9, v10, v11);
}
return result;
}
| setMargins:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x50],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x48],RAX
CALL 0x00134440
MOV RDI,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x18],RDX
LEA RSI,[RBP + -0x20]
CALL 0x001331d0
TEST AL,0x1
JNZ 0x001346d0
JMP 0x001346d5
LAB_001346d0:
JMP 0x0013477c
LAB_001346d5:
MOV RSI,qword ptr [RBP + -0x50]
LEA RDI,[RBP + -0x30]
CALL 0x001347d0
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00134520
MOV RDI,qword ptr [RBP + -0x58]
MOV ESI,EAX
LAB_001346fd:
CALL 0x001100c0
JMP 0x00134704
LAB_00134704:
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001345a0
MOV RDI,qword ptr [RBP + -0x60]
MOV ESI,EAX
CALL 0x001100c0
JMP 0x00134726
LAB_00134726:
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001345c0
MOV RDI,qword ptr [RBP + -0x68]
MOV ESI,EAX
CALL 0x001100c0
JMP 0x00134748
LAB_00134748:
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001345e0
MOV RDI,qword ptr [RBP + -0x70]
MOV ESI,EAX
CALL 0x001100c0
LAB_00134768:
JMP 0x0013476a
LAB_0013476a:
LEA RDI,[RBP + -0x30]
CALL 0x00134830
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x001103a0
LAB_0013477c:
ADD RSP,0x70
POP RBP
RET
|
/* qdevtools::QMarginsEdit::setMargins(QMargins const&) */
void __thiscall qdevtools::QMarginsEdit::setMargins(QMarginsEdit *this,QMargins *param_1)
{
int8 uVar1;
ulong uVar2;
QSignalBlocker local_38 [16];
QMargins local_28 [16];
QMargins *local_18;
QMarginsEdit *local_10;
local_18 = param_1;
local_10 = this;
local_28 = (QMargins [16])margins();
uVar2 = operator==(param_1,local_28);
if ((uVar2 & 1) == 0) {
QSignalBlocker::QSignalBlocker(local_38,(QObject *)this);
uVar1 = *(int8 *)(this + 0x28);
QMargins::top(local_18);
/* try { // try from 001346fd to 00134767 has its CatchHandler @ 00134782 */
QSpinBox::setValue((int)uVar1);
uVar1 = *(int8 *)(this + 0x30);
QMargins::right(local_18);
QSpinBox::setValue((int)uVar1);
uVar1 = *(int8 *)(this + 0x38);
QMargins::bottom(local_18);
QSpinBox::setValue((int)uVar1);
uVar1 = *(int8 *)(this + 0x40);
QMargins::left(local_18);
QSpinBox::setValue((int)uVar1);
QSignalBlocker::~QSignalBlocker(local_38);
BuiltinEditor::valueChanged((BuiltinEditor *)this);
}
return;
}
|
|
6,481 | qdevtools::QMarginsEdit::setMargins(QMargins const&) | HuaiminNotSleepYet[P]QDevTools/qdevtools.cpp | void setMargins(const QMargins& value)
{
if (value == margins())
return;
{
QSignalBlocker blocker{this};
t_->setValue(value.top());
r_->setValue(value.right());
b_->setValue(value.bottom());
l_->setValue(value.left());
}
emit valueChanged();
} | O3 | cpp | qdevtools::QMarginsEdit::setMargins(QMargins const&):
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1fa44
cmpl %eax, (%r14)
jne 0x1facf
shrq $0x20, %rax
cmpl %eax, 0x4(%r14)
jne 0x1facf
cmpl %edx, 0x8(%r14)
jne 0x1facf
shrq $0x20, %rdx
cmpl %edx, 0xc(%r14)
jne 0x1facf
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf1a0
movl %eax, %ebp
movq 0x28(%rbx), %rdi
movl 0x4(%r14), %esi
callq 0xfcc0
movq 0x30(%rbx), %rdi
movl 0x8(%r14), %esi
callq 0xfcc0
movq 0x38(%rbx), %rdi
movl 0xc(%r14), %esi
callq 0xfcc0
movq 0x40(%rbx), %rdi
movl (%r14), %esi
callq 0xfcc0
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0xf1a0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10a0e
movq %rax, %r14
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0xf1a0
movq %r14, %rdi
callq 0xf410
| _ZN9qdevtools12QMarginsEdit10setMarginsERK8QMargins:
push rbp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
call _ZNK9qdevtools12QMarginsEdit7marginsEv; qdevtools::QMarginsEdit::margins(void)
cmp [r14], eax
jnz short loc_1FACF
shr rax, 20h
cmp [r14+4], eax
jnz short loc_1FACF
cmp [r14+8], edx
jnz short loc_1FACF
shr rdx, 20h
cmp [r14+0Ch], edx
jnz short loc_1FACF
pop rbx
pop r14
pop rbp
retn
loc_1FACF:
mov rdi, rbx; this
mov esi, 1; bool
call __ZN7QObject12blockSignalsEb; QObject::blockSignals(bool)
mov ebp, eax
mov rdi, [rbx+28h]; this
mov esi, [r14+4]; int
call __ZN8QSpinBox8setValueEi; QSpinBox::setValue(int)
mov rdi, [rbx+30h]; this
mov esi, [r14+8]; int
call __ZN8QSpinBox8setValueEi; QSpinBox::setValue(int)
mov rdi, [rbx+38h]; this
mov esi, [r14+0Ch]; int
call __ZN8QSpinBox8setValueEi; QSpinBox::setValue(int)
mov rdi, [rbx+40h]; this
mov esi, [r14]; int
call __ZN8QSpinBox8setValueEi; QSpinBox::setValue(int)
movzx esi, bpl; bool
mov rdi, rbx; this
call __ZN7QObject12blockSignalsEb; QObject::blockSignals(bool)
mov rdi, rbx; this
pop rbx
pop r14
pop rbp
jmp _ZN9qdevtools13BuiltinEditor12valueChangedEv; qdevtools::BuiltinEditor::valueChanged(void)
mov r14, rax
movzx esi, bpl; bool
mov rdi, rbx; this
call __ZN7QObject12blockSignalsEb; QObject::blockSignals(bool)
mov rdi, r14
call __Unwind_Resume
| unsigned long long qdevtools::QMarginsEdit::setMargins(QSpinBox **this, int *a2)
{
unsigned long long v2; // rax
unsigned int v3; // edx
int v4; // rdx^4
unsigned long long result; // rax
unsigned __int8 v6; // bp
long long v7; // rdx
long long v8; // rcx
void **v9; // r8
v2 = qdevtools::QMarginsEdit::margins(this);
if ( *a2 != (_DWORD)v2 || (result = HIDWORD(v2), *(_QWORD *)(a2 + 1) != __PAIR64__(v3, result)) || a2[3] != v4 )
{
v6 = QObject::blockSignals((QObject *)this, 1);
QSpinBox::setValue(this[5], a2[1]);
QSpinBox::setValue(this[6], a2[2]);
QSpinBox::setValue(this[7], a2[3]);
QSpinBox::setValue(this[8], *a2);
QObject::blockSignals((QObject *)this, v6);
return qdevtools::BuiltinEditor::valueChanged((qdevtools::BuiltinEditor *)this, v6, v7, v8, v9);
}
return result;
}
| setMargins:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
CALL 0x0011fa44
CMP dword ptr [R14],EAX
JNZ 0x0011facf
SHR RAX,0x20
CMP dword ptr [R14 + 0x4],EAX
JNZ 0x0011facf
CMP dword ptr [R14 + 0x8],EDX
JNZ 0x0011facf
SHR RDX,0x20
CMP dword ptr [R14 + 0xc],EDX
JNZ 0x0011facf
POP RBX
POP R14
POP RBP
RET
LAB_0011facf:
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0010f1a0
MOV EBP,EAX
MOV RDI,qword ptr [RBX + 0x28]
MOV ESI,dword ptr [R14 + 0x4]
LAB_0011fae6:
CALL 0x0010fcc0
MOV RDI,qword ptr [RBX + 0x30]
MOV ESI,dword ptr [R14 + 0x8]
CALL 0x0010fcc0
MOV RDI,qword ptr [RBX + 0x38]
MOV ESI,dword ptr [R14 + 0xc]
CALL 0x0010fcc0
MOV RDI,qword ptr [RBX + 0x40]
MOV ESI,dword ptr [R14]
CALL 0x0010fcc0
LAB_0011fb11:
MOVZX ESI,BPL
MOV RDI,RBX
CALL 0x0010f1a0
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x00110a0e
|
/* qdevtools::QMarginsEdit::setMargins(QMargins const&) */
void __thiscall qdevtools::QMarginsEdit::setMargins(QMarginsEdit *this,QMargins *param_1)
{
int1 auVar1 [16];
auVar1 = margins();
if ((((*(int *)param_1 == auVar1._0_4_) && (*(int *)(param_1 + 4) == auVar1._4_4_)) &&
(*(int *)(param_1 + 8) == auVar1._8_4_)) && (*(int *)(param_1 + 0xc) == auVar1._12_4_)) {
return;
}
QObject::blockSignals(SUB81(this,0));
/* try { // try from 0011fae6 to 0011fb10 has its CatchHandler @ 0011fb29 */
QSpinBox::setValue((int)*(int8 *)(this + 0x28));
QSpinBox::setValue((int)*(int8 *)(this + 0x30));
QSpinBox::setValue((int)*(int8 *)(this + 0x38));
QSpinBox::setValue((int)*(int8 *)(this + 0x40));
QObject::blockSignals(SUB81(this,0));
BuiltinEditor::valueChanged((BuiltinEditor *)this);
return;
}
|
|
6,482 | dns_question_create | xtate/src/proto/proto-dns.c | int dns_question_create(uint8_t *buffer, char *name, dns_record_type type,
uint16_t id) {
static uint8_t *aftername;
int name_len = dns_str2namebuf(name, buffer + 12);
if (name_len < 0) {
return -1;
}
aftername = buffer + 12 + name_len;
dns_buffer_set_id(buffer, id);
*((uint16_t *)(buffer + 2)) = 0;
*((uint16_t *)aftername) = htons(type);
*((uint16_t *)(aftername + 2)) = htons(DNS_CLS_IN);
*((uint16_t *)(buffer + 4)) = htons(0x0001);
return aftername + 4 - buffer;
} | O3 | c | dns_question_create:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rdi, %r14
leaq 0xc(%rdi), %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x31298
testl %eax, %eax
js 0x313d3
movl %eax, %eax
addq %rax, %rbx
movq %rbx, 0x172a1e(%rip) # 0x1a3dc0
rolw $0x8, %r15w
movw %r15w, (%r14)
movw $0x0, 0x2(%r14)
rolw $0x8, %bp
movw %bp, 0xc(%r14,%rax)
movw $0x100, %cx # imm = 0x100
movw %cx, 0xe(%r14,%rax)
movw %cx, 0x4(%r14)
subl %r14d, %ebx
addl $0x4, %ebx
jmp 0x313d8
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| dns_question_create:
push rbp
push r15
push r14
push rbx
push rax
mov r15d, ecx
mov ebp, edx
mov r14, rdi
lea rbx, [rdi+0Ch]
mov rdi, rsi
mov rsi, rbx
call dns_str2namebuf
test eax, eax
js short loc_313D3
mov eax, eax
add rbx, rax
mov cs:dns_question_create_aftername, rbx
rol r15w, 8
mov [r14], r15w
mov word ptr [r14+2], 0
rol bp, 8
mov [r14+rax+0Ch], bp
mov cx, 100h
mov [r14+rax+0Eh], cx
mov [r14+4], cx
sub ebx, r14d
add ebx, 4
jmp short loc_313D8
loc_313D3:
mov ebx, 0FFFFFFFFh
loc_313D8:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long dns_question_create(long long a1, long long a2, __int16 a3, __int16 a4)
{
unsigned int v6; // eax
v6 = dns_str2namebuf(a2, (unsigned __int8 *)(a1 + 12));
if ( (v6 & 0x80000000) != 0 )
{
return (unsigned int)-1;
}
else
{
dns_question_create_aftername = v6 + a1 + 12;
*(_WORD *)a1 = __ROL2__(a4, 8);
*(_WORD *)(a1 + 2) = 0;
*(_WORD *)(a1 + v6 + 12) = __ROL2__(a3, 8);
*(_WORD *)(a1 + v6 + 14) = 256;
*(_WORD *)(a1 + 4) = 256;
return v6 + 16;
}
}
| dns_question_create:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R15D,ECX
MOV EBP,EDX
MOV R14,RDI
LEA RBX,[RDI + 0xc]
MOV RDI,RSI
MOV RSI,RBX
CALL 0x00131298
TEST EAX,EAX
JS 0x001313d3
MOV EAX,EAX
ADD RBX,RAX
MOV qword ptr [0x002a3dc0],RBX
ROL R15W,0x8
MOV word ptr [R14],R15W
MOV word ptr [R14 + 0x2],0x0
ROL BP,0x8
MOV word ptr [R14 + RAX*0x1 + 0xc],BP
MOV CX,0x100
MOV word ptr [R14 + RAX*0x1 + 0xe],CX
MOV word ptr [R14 + 0x4],CX
SUB EBX,R14D
ADD EBX,0x4
JMP 0x001313d8
LAB_001313d3:
MOV EBX,0xffffffff
LAB_001313d8:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int dns_question_create(ushort *param_1,int8 param_2,ushort param_3,ushort param_4)
{
uint uVar1;
ulong uVar2;
int iVar3;
long lVar4;
uVar1 = dns_str2namebuf(param_2,param_1 + 6);
if ((int)uVar1 < 0) {
iVar3 = -1;
}
else {
uVar2 = (ulong)uVar1;
lVar4 = (long)(param_1 + 6) + uVar2;
dns_question_create_aftername = lVar4;
*param_1 = param_4 << 8 | param_4 >> 8;
param_1[1] = 0;
*(ushort *)((long)param_1 + uVar2 + 0xc) = param_3 << 8 | param_3 >> 8;
*(int2 *)((long)param_1 + uVar2 + 0xe) = 0x100;
param_1[2] = 0x100;
iVar3 = ((int)lVar4 - (int)param_1) + 4;
}
return iVar3;
}
|
|
6,483 | 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;
} | O1 | cpp | set_process_priority(ggml_sched_priority):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpl $0x3, %edi
ja 0x727e3
movl %ebx, %eax
leaq 0x7edb0(%rip), %rcx # 0xf1570
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %bpl
jmp 0x72837
movl $0xfffffff6, %edx # imm = 0xFFFFFFF6
jmp 0x727e5
movl $0xffffffec, %edx # imm = 0xFFFFFFEC
jmp 0x727e5
movl $0xfffffffb, %edx # imm = 0xFFFFFFFB
jmp 0x727e5
xorl %edx, %edx
xorl %edi, %edi
xorl %esi, %esi
callq 0x1b1f0
testl %eax, %eax
setne %bpl
jne 0x72837
leaq 0xbdc2b(%rip), %rax # 0x130428
cmpl $0x0, (%rax)
js 0x72837
callq 0xce04b
movq %rax, %r14
callq 0x1b060
movq %rax, %r15
movl (%rax), %edi
callq 0x1b2b0
movl (%r15), %r9d
leaq 0x7f173(%rip), %rdx # 0xf1996
movq %r14, %rdi
movl $0x3, %esi
movl %ebx, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0xce0e6
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_727C7; jumptable 00000000000727C7 default case
mov eax, ebx
lea rcx, jpt_727C7
movsxd rax, ds:(jpt_727C7 - 0F1570h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_727C9:
mov bpl, 1; jumptable 00000000000727C7 case 0
jmp short loc_72837
loc_727CE:
mov edx, 0FFFFFFF6h; jumptable 00000000000727C7 case 2
jmp short loc_727E5
loc_727D5:
mov edx, 0FFFFFFECh; jumptable 00000000000727C7 case 3
jmp short loc_727E5
loc_727DC:
mov edx, 0FFFFFFFBh; jumptable 00000000000727C7 case 1
jmp short loc_727E5
def_727C7:
xor edx, edx; jumptable 00000000000727C7 default case
loc_727E5:
xor edi, edi
xor esi, esi
call _setpriority
test eax, eax
setnz bpl
jnz short loc_72837
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_72837
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 "...
mov rdi, r14
mov esi, 3
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_72837:
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long set_process_priority(int a1, double a2)
{
unsigned int v2; // ebp
long long v3; // rdx
int v4; // eax
int v5; // r14d
unsigned int *v6; // r15
int v7; // eax
switch ( a1 )
{
case 0:
LOBYTE(v2) = 1;
return v2;
case 1:
v3 = 4294967291LL;
goto LABEL_7;
case 2:
v3 = 4294967286LL;
goto LABEL_7;
case 3:
v3 = 4294967276LL;
goto LABEL_7;
default:
v3 = 0LL;
LABEL_7:
v4 = setpriority(0LL, 0LL, v3);
LOBYTE(v2) = v4 != 0;
if ( !v4 && common_log_verbosity_thold >= 0 )
{
v5 = common_log_main();
v6 = (unsigned int *)__errno_location(a2);
v7 = strerror(*v6);
common_log_add(v5, 3, (unsigned int)"failed to set process priority %d : %s (%d)\n", a1, v7, *v6);
}
return v2;
}
}
| set_process_priority:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,EDI
CMP EDI,0x3
JA 0x001727e3
MOV EAX,EBX
LEA RCX,[0x1f1570]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV BPL,0x1
JMP 0x00172837
caseD_2:
MOV EDX,0xfffffff6
JMP 0x001727e5
caseD_3:
MOV EDX,0xffffffec
JMP 0x001727e5
caseD_1:
MOV EDX,0xfffffffb
JMP 0x001727e5
default:
XOR EDX,EDX
LAB_001727e5:
XOR EDI,EDI
XOR ESI,ESI
CALL 0x0011b1f0
TEST EAX,EAX
SETNZ BPL
JNZ 0x00172837
LEA RAX,[0x230428]
CMP dword ptr [RAX],0x0
JS 0x00172837
CALL 0x001ce04b
MOV R14,RAX
CALL 0x0011b060
MOV R15,RAX
MOV EDI,dword ptr [RAX]
CALL 0x0011b2b0
MOV R9D,dword ptr [R15]
LEA RDX,[0x1f1996]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,EBX
MOV R8,RAX
XOR EAX,EAX
CALL 0x001ce0e6
LAB_00172837:
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_00172837;
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);
common_log_add(uVar2,3,"failed to set process priority %d : %s (%d)\n",param_1,pcVar4,*piVar3);
}
LAB_00172837:
return uVar5 & 0xffffffff;
}
|
|
6,484 | 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;
} | O3 | cpp | set_process_priority(ggml_sched_priority):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpl $0x3, %edi
ja 0x71f15
movl %ebx, %eax
leaq 0x7c67e(%rip), %rcx # 0xee570
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %bpl
jmp 0x71f6b
movl $0xfffffff6, %edx # imm = 0xFFFFFFF6
jmp 0x71f17
movl $0xffffffec, %edx # imm = 0xFFFFFFEC
jmp 0x71f17
movl $0xfffffffb, %edx # imm = 0xFFFFFFFB
jmp 0x71f17
xorl %edx, %edx
xorl %edi, %edi
xorl %esi, %esi
callq 0x1a1f0
testl %eax, %eax
setne %bpl
jne 0x71f6b
leaq 0xbb4f9(%rip), %rax # 0x12d428
cmpl $0x0, (%rax)
js 0x71f6b
callq 0xcc467
movq %rax, %r14
callq 0x1a060
movq %rax, %r15
movl (%rax), %edi
callq 0x1a2b0
movl (%r15), %r9d
leaq 0x7ca31(%rip), %rdx # 0xee986
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x3, %esi
movl %ebx, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0xcc504
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_71EF9; jumptable 0000000000071EF9 default case
mov eax, ebx
lea rcx, jpt_71EF9
movsxd rax, ds:(jpt_71EF9 - 0EE570h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_71EFB:
mov bpl, 1; jumptable 0000000000071EF9 case 0
jmp short loc_71F6B
loc_71F00:
mov edx, 0FFFFFFF6h; jumptable 0000000000071EF9 case 2
jmp short loc_71F17
loc_71F07:
mov edx, 0FFFFFFECh; jumptable 0000000000071EF9 case 3
jmp short loc_71F17
loc_71F0E:
mov edx, 0FFFFFFFBh; jumptable 0000000000071EF9 case 1
jmp short loc_71F17
def_71EF9:
xor edx, edx; jumptable 0000000000071EF9 default case
loc_71F17:
xor edi, edi
xor esi, esi
call _setpriority
test eax, eax
setnz bpl
jnz short loc_71F6B
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_71F6B
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
mov rdi, r14
mov esi, 3
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_71F6B:
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long set_process_priority(int a1, double a2)
{
unsigned int v2; // ebp
long long v3; // rdx
int v4; // eax
int v5; // r14d
unsigned int *v6; // r15
int v7; // eax
switch ( a1 )
{
case 0:
LOBYTE(v2) = 1;
return v2;
case 1:
v3 = 4294967291LL;
goto LABEL_7;
case 2:
v3 = 4294967286LL;
goto LABEL_7;
case 3:
v3 = 4294967276LL;
goto LABEL_7;
default:
v3 = 0LL;
LABEL_7:
v4 = setpriority(0LL, 0LL, v3);
LOBYTE(v2) = v4 != 0;
if ( !v4 && common_log_verbosity_thold >= 0 )
{
v5 = common_log_main();
v6 = (unsigned int *)__errno_location(a2);
v7 = strerror(*v6);
v2 = 0;
common_log_add(v5, 3, (unsigned int)"failed to set process priority %d : %s (%d)\n", a1, v7, *v6);
}
return v2;
}
}
| set_process_priority:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,EDI
CMP EDI,0x3
JA 0x00171f15
MOV EAX,EBX
LEA RCX,[0x1ee570]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV BPL,0x1
JMP 0x00171f6b
caseD_2:
MOV EDX,0xfffffff6
JMP 0x00171f17
caseD_3:
MOV EDX,0xffffffec
JMP 0x00171f17
caseD_1:
MOV EDX,0xfffffffb
JMP 0x00171f17
default:
XOR EDX,EDX
LAB_00171f17:
XOR EDI,EDI
XOR ESI,ESI
CALL 0x0011a1f0
TEST EAX,EAX
SETNZ BPL
JNZ 0x00171f6b
LEA RAX,[0x22d428]
CMP dword ptr [RAX],0x0
JS 0x00171f6b
CALL 0x001cc467
MOV R14,RAX
CALL 0x0011a060
MOV R15,RAX
MOV EDI,dword ptr [RAX]
CALL 0x0011a2b0
MOV R9D,dword ptr [R15]
LEA RDX,[0x1ee986]
XOR EBP,EBP
MOV RDI,R14
MOV ESI,0x3
MOV ECX,EBX
MOV R8,RAX
XOR EAX,EAX
CALL 0x001cc504
LAB_00171f6b:
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_00171f6b;
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_00171f6b:
return uVar5 & 0xffffffff;
}
|
|
6,485 | my_mb_wc_utf8mb4_quick | eloqsql/strings/ctype-utf8.h | static inline int
my_mb_wc_utf8mb4_quick(my_wc_t *pwc, const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0x80)
{
*pwc= c;
return 1;
}
else if (c < 0xc2)
return MY_CS_ILSEQ;
else if (c < 0xe0)
{
if (s + 2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
else if (c < 0xf0)
{
if (s + 3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
else if (c < 0xf5)
{
if (s + 4 > e) /* We need 4 characters */
return MY_CS_TOOSMALL4;
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
*pwc= UTF8MB4_CODE(c, s[1], s[2], s[3]);
return 4;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_utf8mb4_quick:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0xeeefc
movzbl (%rsi), %ecx
testb %cl, %cl
js 0xeeef5
movl $0x1, %eax
movq %rcx, (%rdi)
jmp 0xeeefc
cmpb $-0x3e, %cl
jae 0xeeefe
xorl %eax, %eax
popq %rbp
retq
cmpb $-0x21, %cl
ja 0xeef34
leaq 0x2(%rsi), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %r8
ja 0xeeefc
movzbl 0x1(%rsi), %edx
xorl $0x80, %edx
movl $0x0, %eax
cmpb $0x3f, %dl
ja 0xeeefc
andl $0x1f, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl $0x2, %eax
jmp 0xeeef0
cmpb $-0x11, %cl
ja 0xeef96
leaq 0x3(%rsi), %r8
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %r8
ja 0xeeefc
movzbl 0x1(%rsi), %edx
cmpb $-0x41, %dl
jg 0xeeefa
movzbl 0x2(%rsi), %esi
cmpb $-0x41, %sil
jg 0xeeefa
cmpl $0xe0, %ecx
sete %r8b
cmpb $-0x60, %dl
setb %r9b
movl $0x0, %eax
testb %r9b, %r8b
jne 0xeeefc
shll $0xc, %ecx
movzwl %cx, %eax
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x3, %eax
movq %rsi, %rcx
jmp 0xeeef0
cmpb $-0xc, %cl
ja 0xeeefa
leaq 0x4(%rsi), %r8
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rdx, %r8
ja 0xeeefc
movzbl 0x1(%rsi), %r8d
cmpb $-0x41, %r8b
jg 0xeeefa
movzbl 0x2(%rsi), %edx
cmpb $-0x41, %dl
jg 0xeeefa
movzbl 0x3(%rsi), %esi
cmpb $-0x41, %sil
jg 0xeeefa
cmpl $0xf0, %ecx
sete %al
cmpb $-0x70, %r8b
setb %r9b
testb %r9b, %al
jne 0xeeefa
cmpl $0xf4, %ecx
sete %r9b
cmpb $-0x70, %r8b
setae %r10b
movl $0x0, %eax
testb %r10b, %r9b
jne 0xeeefc
andl $0x7, %ecx
shll $0x12, %ecx
andl $0x3f, %r8d
shll $0xc, %r8d
orl %ecx, %r8d
andl $0x3f, %edx
shll $0x6, %edx
orl %r8d, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x4, %eax
jmp 0xeef8e
| my_mb_wc_utf8mb4_quick_0:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb short loc_EEEFC
movzx ecx, byte ptr [rsi]
test cl, cl
js short loc_EEEF5
mov eax, 1
loc_EEEF0:
mov [rdi], rcx
jmp short loc_EEEFC
loc_EEEF5:
cmp cl, 0C2h
jnb short loc_EEEFE
loc_EEEFA:
xor eax, eax
loc_EEEFC:
pop rbp
retn
loc_EEEFE:
cmp cl, 0DFh
ja short loc_EEF34
lea r8, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp r8, rdx
ja short loc_EEEFC
movzx edx, byte ptr [rsi+1]
xor edx, 80h
mov eax, 0
cmp dl, 3Fh ; '?'
ja short loc_EEEFC
and ecx, 1Fh
shl ecx, 6
or ecx, edx
mov eax, 2
jmp short loc_EEEF0
loc_EEF34:
cmp cl, 0EFh
ja short loc_EEF96
lea r8, [rsi+3]
mov eax, 0FFFFFF99h
cmp r8, rdx
ja short loc_EEEFC
movzx edx, byte ptr [rsi+1]
cmp dl, 0BFh
jg short loc_EEEFA
movzx esi, byte ptr [rsi+2]
cmp sil, 0BFh
jg short loc_EEEFA
cmp ecx, 0E0h
setz r8b
cmp dl, 0A0h
setb r9b
mov eax, 0
test r8b, r9b
jnz short loc_EEEFC
shl ecx, 0Ch
movzx eax, cx
and edx, 3Fh
shl edx, 6
or edx, eax
and esi, 3Fh
or rsi, rdx
mov eax, 3
loc_EEF8E:
mov rcx, rsi
jmp loc_EEEF0
loc_EEF96:
cmp cl, 0F4h
ja loc_EEEFA
lea r8, [rsi+4]
mov eax, 0FFFFFF98h
cmp r8, rdx
ja loc_EEEFC
movzx r8d, byte ptr [rsi+1]
cmp r8b, 0BFh
jg loc_EEEFA
movzx edx, byte ptr [rsi+2]
cmp dl, 0BFh
jg loc_EEEFA
movzx esi, byte ptr [rsi+3]
cmp sil, 0BFh
jg loc_EEEFA
cmp ecx, 0F0h
setz al
cmp r8b, 90h
setb r9b
test al, r9b
jnz loc_EEEFA
cmp ecx, 0F4h
setz r9b
cmp r8b, 90h
setnb r10b
mov eax, 0
test r9b, r10b
jnz loc_EEEFC
and ecx, 7
shl ecx, 12h
and r8d, 3Fh
shl r8d, 0Ch
or r8d, ecx
and edx, 3Fh
shl edx, 6
or edx, r8d
and esi, 3Fh
or rsi, rdx
mov eax, 4
jmp loc_EEF8E
| long long my_mb_wc_utf8mb4_quick_0(unsigned long long *a1, unsigned __int8 *a2, unsigned long long a3)
{
long long result; // rax
unsigned long long v4; // rcx
char v5; // dl
char v6; // si
unsigned long long v7; // rsi
char v8; // r8
char v9; // dl
char v10; // si
result = 4294967195LL;
if ( (unsigned long long)a2 >= a3 )
return result;
v4 = *a2;
if ( (v4 & 0x80u) == 0LL )
{
result = 1LL;
LABEL_4:
*a1 = v4;
return result;
}
if ( (unsigned __int8)v4 < 0xC2u )
return 0LL;
if ( (unsigned __int8)v4 > 0xDFu )
{
if ( (unsigned __int8)v4 > 0xEFu )
{
if ( (unsigned __int8)v4 <= 0xF4u )
{
result = 4294967192LL;
if ( (unsigned long long)(a2 + 4) > a3 )
return result;
v8 = a2[1];
if ( v8 <= -65 )
{
v9 = a2[2];
if ( v9 <= -65 )
{
v10 = a2[3];
if ( v10 <= -65 && ((unsigned __int8)v8 >= 0x90u || (_DWORD)v4 != 240) )
{
result = 0LL;
if ( (unsigned __int8)v8 >= 0x90u && (_DWORD)v4 == 244 )
return result;
v7 = ((v4 & 7) << 18) | ((unsigned __int8)(v8 & 0x3F) << 12) | ((unsigned __int8)(v9 & 0x3F) << 6) | v10 & 0x3F;
result = 4LL;
LABEL_18:
v4 = v7;
goto LABEL_4;
}
}
}
}
}
else
{
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) > a3 )
return result;
v5 = a2[1];
if ( v5 <= -65 )
{
v6 = a2[2];
if ( v6 <= -65 )
{
result = 0LL;
if ( (unsigned __int8)v5 < 0xA0u && (_DWORD)v4 == 224 )
return result;
v7 = (unsigned __int16)((_WORD)v4 << 12) | ((unsigned __int8)(v5 & 0x3F) << 6) | (unsigned long long)(v6 & 0x3F);
result = 3LL;
goto LABEL_18;
}
}
}
return 0LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
{
result = 0LL;
if ( (a2[1] ^ 0x80u) <= 0x3F )
{
v4 = a2[1] ^ 0x80 | ((unsigned __int8)(v4 & 0x1F) << 6);
result = 2LL;
goto LABEL_4;
}
}
return result;
}
| my_mb_wc_utf8mb4_quick:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x001eeefc
MOVZX ECX,byte ptr [RSI]
TEST CL,CL
JS 0x001eeef5
MOV EAX,0x1
LAB_001eeef0:
MOV qword ptr [RDI],RCX
JMP 0x001eeefc
LAB_001eeef5:
CMP CL,0xc2
JNC 0x001eeefe
LAB_001eeefa:
XOR EAX,EAX
LAB_001eeefc:
POP RBP
RET
LAB_001eeefe:
CMP CL,0xdf
JA 0x001eef34
LEA R8,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP R8,RDX
JA 0x001eeefc
MOVZX EDX,byte ptr [RSI + 0x1]
XOR EDX,0x80
MOV EAX,0x0
CMP DL,0x3f
JA 0x001eeefc
AND ECX,0x1f
SHL ECX,0x6
OR ECX,EDX
MOV EAX,0x2
JMP 0x001eeef0
LAB_001eef34:
CMP CL,0xef
JA 0x001eef96
LEA R8,[RSI + 0x3]
MOV EAX,0xffffff99
CMP R8,RDX
JA 0x001eeefc
MOVZX EDX,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001eeefa
MOVZX ESI,byte ptr [RSI + 0x2]
CMP SIL,0xbf
JG 0x001eeefa
CMP ECX,0xe0
SETZ R8B
CMP DL,0xa0
SETC R9B
MOV EAX,0x0
TEST R8B,R9B
JNZ 0x001eeefc
SHL ECX,0xc
MOVZX EAX,CX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,EAX
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x3
LAB_001eef8e:
MOV RCX,RSI
JMP 0x001eeef0
LAB_001eef96:
CMP CL,0xf4
JA 0x001eeefa
LEA R8,[RSI + 0x4]
MOV EAX,0xffffff98
CMP R8,RDX
JA 0x001eeefc
MOVZX R8D,byte ptr [RSI + 0x1]
CMP R8B,0xbf
JG 0x001eeefa
MOVZX EDX,byte ptr [RSI + 0x2]
CMP DL,0xbf
JG 0x001eeefa
MOVZX ESI,byte ptr [RSI + 0x3]
CMP SIL,0xbf
JG 0x001eeefa
CMP ECX,0xf0
SETZ AL
CMP R8B,0x90
SETC R9B
TEST AL,R9B
JNZ 0x001eeefa
CMP ECX,0xf4
SETZ R9B
CMP R8B,0x90
SETNC R10B
MOV EAX,0x0
TEST R9B,R10B
JNZ 0x001eeefc
AND ECX,0x7
SHL ECX,0x12
AND R8D,0x3f
SHL R8D,0xc
OR R8D,ECX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,R8D
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x4
JMP 0x001eef8e
|
int8 my_mb_wc_utf8mb4_quick(ulong *param_1,byte *param_2,byte *param_3)
{
byte bVar1;
byte bVar2;
int8 uVar3;
uint uVar4;
ulong uVar5;
if (param_3 <= param_2) {
return 0xffffff9b;
}
bVar1 = *param_2;
uVar5 = (ulong)bVar1;
if ((char)bVar1 < '\0') {
if (0xc1 < bVar1) {
uVar4 = (uint)bVar1;
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return 0xffffff9a;
}
if (0x3f < (byte)(param_2[1] ^ 0x80)) {
return 0;
}
uVar5 = (ulong)((uVar4 & 0x1f) << 6 | param_2[1] ^ 0x80);
uVar3 = 2;
goto LAB_001eeef0;
}
if (bVar1 < 0xf0) {
if (param_3 < param_2 + 3) {
return 0xffffff99;
}
bVar2 = param_2[1];
if (((char)bVar2 < -0x40) && ((char)param_2[2] < -0x40)) {
if (uVar4 == 0xe0 && bVar2 < 0xa0) {
return 0;
}
uVar4 = param_2[2] & 0x3f | (bVar2 & 0x3f) << 6 | (bVar1 & 0xf) << 0xc;
uVar3 = 3;
LAB_001eef8e:
uVar5 = (ulong)uVar4;
goto LAB_001eeef0;
}
}
else if (bVar1 < 0xf5) {
if (param_3 < param_2 + 4) {
return 0xffffff98;
}
bVar1 = param_2[1];
if (((((char)bVar1 < -0x40) && ((char)param_2[2] < -0x40)) && ((char)param_2[3] < -0x40)) &&
(uVar4 != 0xf0 || 0x8f < bVar1)) {
if (uVar4 == 0xf4 && 0x8f < bVar1) {
return 0;
}
uVar4 = param_2[3] & 0x3f |
(param_2[2] & 0x3f) << 6 | (bVar1 & 0x3f) << 0xc | (uVar4 & 7) << 0x12;
uVar3 = 4;
goto LAB_001eef8e;
}
}
}
uVar3 = 0;
}
else {
uVar3 = 1;
LAB_001eeef0:
*param_1 = uVar5;
}
return uVar3;
}
|
|
6,486 | tailoring_append2 | eloqsql/strings/ctype.c | static int
tailoring_append2(MY_XML_PARSER *st,
const char *fmt,
size_t len1, const char *attr1,
size_t len2, const char *attr2)
{
struct my_cs_file_info *i= (struct my_cs_file_info *) st->user_data;
size_t newlen= i->tailoring_length + len1 + len2 + 64; /* 64 for format */
if (MY_XML_OK == my_charset_file_tailoring_realloc(i, newlen))
{
char *dst= i->tailoring + i->tailoring_length;
sprintf(dst, fmt, (int) len1, attr1, (int) len2, attr2);
i->tailoring_length+= strlen(dst);
return MY_XML_OK;
}
return MY_XML_ERROR;
} | O0 | c | tailoring_append2:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x690(%rax), %rax
addq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x7e350
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x7e744
movq -0x40(%rbp), %rax
movq 0x688(%rax), %rax
movq -0x40(%rbp), %rcx
addq 0x690(%rcx), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movl %eax, %r8d
movq -0x38(%rbp), %r9
movb $0x0, %al
callq 0x250b0
movq -0x50(%rbp), %rdi
callq 0x25130
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq 0x690(%rax), %rcx
movq %rcx, 0x690(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7e74b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| tailoring_append2:
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_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_10]
mov rax, [rax+140h]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov rax, [rax+690h]
add rax, [rbp+var_20]
add rax, [rbp+var_30]
add rax, 40h ; '@'
mov [rbp+var_48], rax
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_48]
call my_charset_file_tailoring_realloc
mov ecx, eax
xor eax, eax
cmp eax, ecx
jnz short loc_7E744
mov rax, [rbp+var_40]
mov rax, [rax+688h]
mov rcx, [rbp+var_40]
add rax, [rcx+690h]
mov [rbp+var_50], rax
mov rdi, [rbp+var_50]
mov rsi, [rbp+var_18]
mov rax, [rbp+var_20]
mov edx, eax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_30]
mov r8d, eax
mov r9, [rbp+var_38]
mov al, 0
call _sprintf
mov rdi, [rbp+var_50]
call _strlen
mov rcx, rax
mov rax, [rbp+var_40]
add rcx, [rax+690h]
mov [rax+690h], rcx
mov [rbp+var_4], 0
jmp short loc_7E74B
loc_7E744:
mov [rbp+var_4], 1
loc_7E74B:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long tailoring_append2(long long a1, const char *a2, long long a3, long long a4, long long a5, long long a6)
{
long long v7; // [rsp+0h] [rbp-50h]
_QWORD *v8; // [rsp+10h] [rbp-40h]
unsigned int v10; // [rsp+20h] [rbp-30h]
unsigned int v12; // [rsp+30h] [rbp-20h]
v12 = a3;
v10 = a5;
v8 = *(_QWORD **)(a1 + 320);
if ( (unsigned int)my_charset_file_tailoring_realloc(v8, a5 + a3 + v8[210] + 64) )
{
return 1;
}
else
{
v7 = v8[210] + v8[209];
sprintf(v7, a2, v12, a4, v10, a6);
v8[210] += strlen(v7);
return 0;
}
}
| tailoring_append2:
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 + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x140]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x690]
ADD RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x30]
ADD RAX,0x40
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x0017e350
MOV ECX,EAX
XOR EAX,EAX
CMP EAX,ECX
JNZ 0x0017e744
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x688]
MOV RCX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RCX + 0x690]
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,EAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x30]
MOV R8D,EAX
MOV R9,qword ptr [RBP + -0x38]
MOV AL,0x0
CALL 0x001250b0
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00125130
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RCX,qword ptr [RAX + 0x690]
MOV qword ptr [RAX + 0x690],RCX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0017e74b
LAB_0017e744:
MOV dword ptr [RBP + -0x4],0x1
LAB_0017e74b:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
bool tailoring_append2(long param_1,char *param_2,ulong param_3,int8 param_4,ulong param_5,
int8 param_6)
{
long lVar1;
int iVar2;
char *__s;
size_t sVar3;
lVar1 = *(long *)(param_1 + 0x140);
iVar2 = my_charset_file_tailoring_realloc
(lVar1,*(long *)(lVar1 + 0x690) + param_3 + param_5 + 0x40);
if (iVar2 == 0) {
__s = (char *)(*(long *)(lVar1 + 0x688) + *(long *)(lVar1 + 0x690));
sprintf(__s,param_2,param_3 & 0xffffffff,param_4,param_5 & 0xffffffff,param_6);
sVar3 = strlen(__s);
*(size_t *)(lVar1 + 0x690) = sVar3 + *(long *)(lVar1 + 0x690);
}
return iVar2 != 0;
}
|
|
6,487 | testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-filepath.cc | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
const FilePath& base_name,
const char* extension) {
FilePath full_pathname;
int number = 0;
do {
full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
} while (full_pathname.FileOrDirectoryExists());
return full_pathname;
} | O0 | cpp | testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*):
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
callq 0xe35f0
movl $0x0, 0x50(%rsp)
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movl 0x50(%rsp), %ecx
movl %ecx, %eax
incl %eax
movl %eax, 0x50(%rsp)
movq 0x58(%rsp), %r8
leaq 0x30(%rsp), %rdi
callq 0xb6c30
jmp 0xb73be
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe3660
jmp 0xb73cf
leaq 0x30(%rsp), %rdi
callq 0xe3490
movq 0x10(%rsp), %rdi
callq 0xb71d0
movb %al, 0xf(%rsp)
jmp 0xb73e9
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xb7397
jmp 0xb73f3
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xb7435
jmp 0xb742b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xb743f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xe3490
jmp 0xb743f
movq 0x10(%rsp), %rdi
callq 0xe3490
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0xe3490
movq 0x28(%rsp), %rdi
callq 0x14c80
nopw %cs:(%rax,%rax)
| _ZN7testing8internal8FilePath22GenerateUniqueFileNameERKS1_S3_PKc:
sub rsp, 78h
mov [rsp+78h+var_68], rdi
mov rax, rdi
mov [rsp+78h+var_60], rax
mov [rsp+78h+var_8], rdi
mov [rsp+78h+var_10], rsi
mov [rsp+78h+var_18], rdx
mov [rsp+78h+var_20], rcx
mov [rsp+78h+var_21], 0
call _ZN7testing8internal8FilePathC2Ev; testing::internal::FilePath::FilePath(void)
mov [rsp+78h+var_28], 0
loc_B7397:
mov rsi, [rsp+78h+var_10]; testing::internal::FilePath *
mov rdx, [rsp+78h+var_18]; testing::internal::FilePath *
mov ecx, [rsp+78h+var_28]; int
mov eax, ecx
inc eax
mov [rsp+78h+var_28], eax
mov r8, [rsp+78h+var_20]; char *
lea rdi, [rsp+78h+var_48]; this
call _ZN7testing8internal8FilePath12MakeFileNameERKS1_S3_iPKc; testing::internal::FilePath::MakeFileName(testing::internal::FilePath const&,testing::internal::FilePath const&,int,char const*)
jmp short $+2
loc_B73BE:
mov rdi, [rsp+78h+var_68]; this
lea rsi, [rsp+78h+var_48]; testing::internal::FilePath *
call _ZN7testing8internal8FilePath3SetERKS1_; testing::internal::FilePath::Set(testing::internal::FilePath const&)
jmp short $+2
loc_B73CF:
lea rdi, [rsp+78h+var_48]; this
call _ZN7testing8internal8FilePathD2Ev; testing::internal::FilePath::~FilePath()
mov rdi, [rsp+78h+var_68]; this
call _ZNK7testing8internal8FilePath21FileOrDirectoryExistsEv; testing::internal::FilePath::FileOrDirectoryExists(void)
mov [rsp+78h+var_69], al
jmp short $+2
loc_B73E9:
mov al, [rsp+78h+var_69]
test al, 1
jnz short loc_B7397
jmp short $+2
loc_B73F3:
mov [rsp+78h+var_21], 1
test [rsp+78h+var_21], 1
jnz short loc_B7435
jmp short loc_B742B
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
jmp short loc_B743F
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_28]; this
call _ZN7testing8internal8FilePathD2Ev; testing::internal::FilePath::~FilePath()
jmp short loc_B743F
loc_B742B:
mov rdi, [rsp+78h+var_68]; this
call _ZN7testing8internal8FilePathD2Ev; testing::internal::FilePath::~FilePath()
loc_B7435:
mov rax, [rsp+78h+var_60]
add rsp, 78h
retn
loc_B743F:
mov rdi, [rsp+arg_8]; this
call _ZN7testing8internal8FilePathD2Ev; testing::internal::FilePath::~FilePath()
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| testing::internal::FilePath * testing::internal::FilePath::GenerateUniqueFileName(
testing::internal::FilePath *this,
const testing::internal::FilePath *a2,
const testing::internal::FilePath *a3,
char *a4)
{
int v4; // ecx
_BYTE v6[32]; // [rsp+30h] [rbp-48h] BYREF
int v7; // [rsp+50h] [rbp-28h]
char v8; // [rsp+57h] [rbp-21h]
char *v9; // [rsp+58h] [rbp-20h]
testing::internal::FilePath *v10; // [rsp+60h] [rbp-18h]
testing::internal::FilePath *v11; // [rsp+68h] [rbp-10h]
testing::internal::FilePath *v12; // [rsp+70h] [rbp-8h]
v12 = this;
v11 = a2;
v10 = a3;
v9 = a4;
v8 = 0;
testing::internal::FilePath::FilePath(this);
v7 = 0;
do
{
v4 = v7++;
testing::internal::FilePath::MakeFileName((testing::internal::FilePath *)v6, v11, v10, v4, v9);
testing::internal::FilePath::Set(this, (const testing::internal::FilePath *)v6);
testing::internal::FilePath::~FilePath((testing::internal::FilePath *)v6);
}
while ( testing::internal::FilePath::FileOrDirectoryExists(this) );
return this;
}
| GenerateUniqueFileName:
SUB RSP,0x78
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x70],RDI
MOV qword ptr [RSP + 0x68],RSI
MOV qword ptr [RSP + 0x60],RDX
MOV qword ptr [RSP + 0x58],RCX
MOV byte ptr [RSP + 0x57],0x0
CALL 0x001e35f0
MOV dword ptr [RSP + 0x50],0x0
LAB_001b7397:
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x60]
MOV ECX,dword ptr [RSP + 0x50]
MOV EAX,ECX
INC EAX
MOV dword ptr [RSP + 0x50],EAX
MOV R8,qword ptr [RSP + 0x58]
LAB_001b73b2:
LEA RDI,[RSP + 0x30]
CALL 0x001b6c30
JMP 0x001b73be
LAB_001b73be:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x30]
CALL 0x001e3660
JMP 0x001b73cf
LAB_001b73cf:
LEA RDI,[RSP + 0x30]
CALL 0x001e3490
LAB_001b73d9:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001b71d0
LAB_001b73e3:
MOV byte ptr [RSP + 0xf],AL
JMP 0x001b73e9
LAB_001b73e9:
MOV AL,byte ptr [RSP + 0xf]
TEST AL,0x1
JNZ 0x001b7397
JMP 0x001b73f3
LAB_001b73f3:
MOV byte ptr [RSP + 0x57],0x1
TEST byte ptr [RSP + 0x57],0x1
JNZ 0x001b7435
JMP 0x001b742b
LAB_001b742b:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001e3490
LAB_001b7435:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x78
RET
|
/* WARNING: Removing unreachable block (ram,0x001b73ff) */
/* testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&,
testing::internal::FilePath const&, char const*) */
FilePath * __thiscall
testing::internal::FilePath::GenerateUniqueFileName
(FilePath *this,FilePath *param_1,FilePath *param_2,char *param_3)
{
int iVar1;
byte bVar2;
FilePath local_48 [32];
int local_28;
int1 local_21;
char *local_20;
FilePath *local_18;
FilePath *local_10;
FilePath *local_8;
local_21 = 0;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
FilePath(this);
local_28 = 0;
do {
iVar1 = local_28;
local_28 = local_28 + 1;
/* try { // try from 001b73b2 to 001b73bb has its CatchHandler @ 001b7401 */
MakeFileName(local_48,local_10,local_18,iVar1,local_20);
/* try { // try from 001b73be to 001b73cc has its CatchHandler @ 001b7411 */
Set(this,local_48);
~FilePath(local_48);
/* try { // try from 001b73d9 to 001b73e2 has its CatchHandler @ 001b7401 */
bVar2 = FileOrDirectoryExists(this);
} while ((bVar2 & 1) != 0);
return this;
}
|
|
6,488 | google::protobuf::internal::WireFormat::ComputeUnknownMessageSetItemsSize(google::protobuf::UnknownFieldSet const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/wire_format.cc | size_t WireFormat::ComputeUnknownMessageSetItemsSize(
const UnknownFieldSet& unknown_fields) {
size_t size = 0;
for (int i = 0; i < unknown_fields.field_count(); i++) {
const UnknownField& field = unknown_fields.field(i);
// The only unknown fields that are allowed to exist in a MessageSet are
// messages, which are length-delimited.
if (field.type() == UnknownField::TYPE_LENGTH_DELIMITED) {
size += WireFormatLite::kMessageSetItemTagsSize;
size += io::CodedOutputStream::VarintSize32(field.number());
int field_size = field.GetLengthDelimitedSize();
size += io::CodedOutputStream::VarintSize32(field_size);
size += field_size;
}
}
return size;
} | O0 | cpp | google::protobuf::internal::WireFormat::ComputeUnknownMessageSetItemsSize(google::protobuf::UnknownFieldSet const&):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x7b010
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x167e7b
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x7b020
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x7b070
cmpl $0x3, %eax
jne 0x167e69
leaq 0x921ff(%rip), %rax # 0x1fa010
movq (%rax), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x7b050
movl %eax, %edi
callq 0xde460
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x178100
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
callq 0xde460
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movslq 0x4(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x167e6b
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x167dca
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf8internal10WireFormat33ComputeUnknownMessageSetItemsSizeERKNS0_15UnknownFieldSetE:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], 0
mov [rsp+28h+var_14], 0
loc_167DCA:
mov eax, [rsp+28h+var_14]
mov [rsp+28h+var_28], eax
mov rdi, [rsp+28h+var_8]; this
call _ZNK6google8protobuf15UnknownFieldSet11field_countEv; google::protobuf::UnknownFieldSet::field_count(void)
mov ecx, eax
mov eax, [rsp+28h+var_28]
cmp eax, ecx
jge loc_167E7B
mov rdi, [rsp+28h+var_8]; this
mov esi, [rsp+28h+var_14]; unsigned int
call _ZNK6google8protobuf15UnknownFieldSet5fieldEi; google::protobuf::UnknownFieldSet::field(int)
mov [rsp+28h+var_24+4], rax
mov rdi, [rsp+28h+var_24+4]; this
call _ZNK6google8protobuf12UnknownField4typeEv; google::protobuf::UnknownField::type(void)
cmp eax, 3
jnz short loc_167E69
lea rax, _ZN6google8protobuf8internal14WireFormatLite23kMessageSetItemTagsSizeE; google::protobuf::internal::WireFormatLite::kMessageSetItemTagsSize
mov rax, [rax]
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
mov rdi, [rsp+28h+var_24+4]; this
call _ZNK6google8protobuf12UnknownField6numberEv; google::protobuf::UnknownField::number(void)
mov edi, eax; this
call _ZN6google8protobuf2io17CodedOutputStream12VarintSize32Ej; google::protobuf::io::CodedOutputStream::VarintSize32(uint)
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
mov rdi, [rsp+28h+var_24+4]; this
call _ZNK6google8protobuf12UnknownField22GetLengthDelimitedSizeEv; google::protobuf::UnknownField::GetLengthDelimitedSize(void)
mov dword ptr [rsp+28h+var_24], eax
mov edi, dword ptr [rsp+28h+var_24]; this
call _ZN6google8protobuf2io17CodedOutputStream12VarintSize32Ej; google::protobuf::io::CodedOutputStream::VarintSize32(uint)
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
movsxd rax, dword ptr [rsp+28h+var_24]
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
loc_167E69:
jmp short $+2
loc_167E6B:
mov eax, [rsp+28h+var_14]
add eax, 1
mov [rsp+28h+var_14], eax
jmp loc_167DCA
loc_167E7B:
mov rax, [rsp+28h+var_10]
add rsp, 28h
retn
| long long google::protobuf::internal::WireFormat::ComputeUnknownMessageSetItemsSize(
google::protobuf::internal::WireFormat *this,
const google::protobuf::UnknownFieldSet *a2)
{
unsigned int v2; // eax
unsigned int LengthDelimitedSize; // [rsp+4h] [rbp-24h]
google::protobuf::io::CodedOutputStream *v5; // [rsp+8h] [rbp-20h]
int i; // [rsp+14h] [rbp-14h]
long long v7; // [rsp+18h] [rbp-10h]
long long v8; // [rsp+18h] [rbp-10h]
v7 = 0LL;
for ( i = 0; i < (int)google::protobuf::UnknownFieldSet::field_count(this); ++i )
{
v5 = (google::protobuf::io::CodedOutputStream *)google::protobuf::UnknownFieldSet::field(this, i);
if ( (unsigned int)google::protobuf::UnknownField::type(v5) == 3 )
{
v2 = google::protobuf::UnknownField::number(v5);
v8 = v7
+ google::protobuf::internal::WireFormatLite::kMessageSetItemTagsSize
+ google::protobuf::io::CodedOutputStream::VarintSize32((google::protobuf::io::CodedOutputStream *)v2, i);
LengthDelimitedSize = google::protobuf::UnknownField::GetLengthDelimitedSize(v5);
v7 = v8
+ google::protobuf::io::CodedOutputStream::VarintSize32(
(google::protobuf::io::CodedOutputStream *)LengthDelimitedSize,
i)
+ (int)LengthDelimitedSize;
}
}
return v7;
}
| Destroy<google::protobuf::EnumOptions>:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00168630
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x18],RAX
CALL 0x00168690
MOV qword ptr [RSP + 0x10],RAX
LAB_00167ddc:
MOV RAX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RSP + 0x10]
JZ 0x00167e02
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001c46c0
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x50
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00167ddc
LAB_00167e02:
MOV AL,0x1
AND AL,0x1
ADD RSP,0x28
RET
|
/* bool google::protobuf::(anonymous namespace)::FlatAllocation<char, std::__cxx11::string,
google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables,
google::protobuf::MessageOptions, google::protobuf::FieldOptions, google::protobuf::EnumOptions,
google::protobuf::EnumValueOptions, google::protobuf::ExtensionRangeOptions,
google::protobuf::OneofOptions, google::protobuf::ServiceOptions,
google::protobuf::MethodOptions,
google::protobuf::FileOptions>::Destroy<google::protobuf::EnumOptions>() */
bool __thiscall
google::protobuf::(anonymous_namespace)::
FlatAllocation<char,std::__cxx11::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>
::Destroy<google::protobuf::EnumOptions>
(FlatAllocation<char,std::__cxx11::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>
*this)
{
EnumOptions *pEVar1;
EnumOptions *local_10;
local_10 = Begin<google::protobuf::EnumOptions>(this);
pEVar1 = End<google::protobuf::EnumOptions>(this);
for (; local_10 != pEVar1; local_10 = local_10 + 0x50) {
EnumOptions::~EnumOptions(local_10);
}
return true;
}
|
|
6,489 | ConsoleListener::Log(Common::Log::LogLevel, char const*) | Dolphin-anty/Source/Core/Common/Logging/ConsoleListenerNix.cpp | void ConsoleListener::Log(Common::Log::LogLevel level, const char* text)
{
char color_attr[16] = "";
char reset_attr[16] = "";
if (m_use_color)
{
strcpy(reset_attr, "\x1b[0m");
switch (level)
{
case Common::Log::LogLevel::LNOTICE:
// light green
strcpy(color_attr, "\x1b[92m");
break;
case Common::Log::LogLevel::LERROR:
// light red
strcpy(color_attr, "\x1b[91m");
break;
case Common::Log::LogLevel::LWARNING:
// light yellow
strcpy(color_attr, "\x1b[93m");
break;
default:
break;
}
}
fprintf(stderr, "%s%s%s", color_attr, text, reset_attr);
} | O3 | cpp | ConsoleListener::Log(Common::Log::LogLevel, char const*):
subq $0x28, %rsp
movq %rdx, %rcx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
cmpb $0x1, 0x8(%rdi)
jne 0x7f4b
movb $0x0, 0x14(%rsp)
movl $0x6d305b1b, 0x10(%rsp) # imm = 0x6D305B1B
cmpl $0x3, %esi
je 0x7f3d
cmpl $0x2, %esi
je 0x7f2d
cmpl $0x1, %esi
jne 0x7f4b
movw $0x6d, 0x4(%rsp)
movl $0x32395b1b, (%rsp) # imm = 0x32395B1B
jmp 0x7f4b
movw $0x6d, 0x4(%rsp)
movl $0x31395b1b, (%rsp) # imm = 0x31395B1B
jmp 0x7f4b
movw $0x6d, 0x4(%rsp)
movl $0x33395b1b, (%rsp) # imm = 0x33395B1B
movq 0x4b05e(%rip), %rax # 0x52fb0
movq (%rax), %rdi
leaq 0x35b45(%rip), %rsi # 0x3daa1
movq %rsp, %rdx
leaq 0x10(%rsp), %r8
xorl %eax, %eax
callq 0x72b0
addq $0x28, %rsp
retq
| _ZN15ConsoleListener3LogEN6Common3Log8LogLevelEPKc:
sub rsp, 28h
mov rcx, rdx
xorps xmm0, xmm0
movaps [rsp+28h+var_28], xmm0
movaps [rsp+28h+var_18], xmm0
cmp byte ptr [rdi+8], 1
jnz short loc_7F4B
mov byte ptr [rsp+28h+var_18+4], 0
mov dword ptr [rsp+28h+var_18], 6D305B1Bh
cmp esi, 3
jz short loc_7F3D
cmp esi, 2
jz short loc_7F2D
cmp esi, 1
jnz short loc_7F4B
mov word ptr [rsp+28h+var_28+4], 6Dh ; 'm'
mov dword ptr [rsp+28h+var_28], 32395B1Bh
jmp short loc_7F4B
loc_7F2D:
mov word ptr [rsp+28h+var_28+4], 6Dh ; 'm'
mov dword ptr [rsp+28h+var_28], 31395B1Bh
jmp short loc_7F4B
loc_7F3D:
mov word ptr [rsp+28h+var_28+4], 6Dh ; 'm'
mov dword ptr [rsp+28h+var_28], 33395B1Bh
loc_7F4B:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aSSS; "%s%s%s"
mov rdx, rsp
lea r8, [rsp+28h+var_18]
xor eax, eax
call _fprintf
add rsp, 28h
retn
| long long ConsoleListener::Log(long long a1, int a2, const char *a3)
{
__int128 v4; // [rsp+0h] [rbp-28h] BYREF
char v5[24]; // [rsp+10h] [rbp-18h] BYREF
v4 = 0LL;
*(_OWORD *)v5 = 0LL;
if ( *(_BYTE *)(a1 + 8) == 1 )
{
strcpy(v5, "\x1B[0m");
switch ( a2 )
{
case 3:
strcpy((char *)&v4, "\x1B[93m");
break;
case 2:
strcpy((char *)&v4, "\x1B[91m");
break;
case 1:
strcpy((char *)&v4, "\x1B[92m");
break;
}
}
return fprintf(stderr, "%s%s%s", (const char *)&v4, a3, v5);
}
| Log:
SUB RSP,0x28
MOV RCX,RDX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
CMP byte ptr [RDI + 0x8],0x1
JNZ 0x00107f4b
MOV byte ptr [RSP + 0x14],0x0
MOV dword ptr [RSP + 0x10],0x6d305b1b
CMP ESI,0x3
JZ 0x00107f3d
CMP ESI,0x2
JZ 0x00107f2d
CMP ESI,0x1
JNZ 0x00107f4b
MOV word ptr [RSP + 0x4],0x6d
MOV dword ptr [RSP],0x32395b1b
JMP 0x00107f4b
LAB_00107f2d:
MOV word ptr [RSP + 0x4],0x6d
MOV dword ptr [RSP],0x31395b1b
JMP 0x00107f4b
LAB_00107f3d:
MOV word ptr [RSP + 0x4],0x6d
MOV dword ptr [RSP],0x33395b1b
LAB_00107f4b:
MOV RAX,qword ptr [0x00152fb0]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x13daa1]
MOV RDX,RSP
LEA R8,[RSP + 0x10]
XOR EAX,EAX
CALL 0x001072b0
ADD RSP,0x28
RET
|
/* ConsoleListener::Log(Common::Log::LogLevel, char const*) */
void __thiscall ConsoleListener::Log(ConsoleListener *this,int param_2,int8 param_3)
{
int8 local_28;
int8 uStack_20;
int8 local_18;
int8 uStack_10;
local_28 = 0;
uStack_20 = 0;
local_18 = 0;
uStack_10 = 0;
if (this[8] == (ConsoleListener)0x1) {
local_18 = 0x6d305b1b;
if (param_2 == 3) {
local_28 = 0x6d33395b1b;
}
else if (param_2 == 2) {
local_28 = 0x6d31395b1b;
}
else if (param_2 == 1) {
local_28 = 0x6d32395b1b;
}
}
fprintf(*(FILE **)PTR_stderr_00152fb0,"%s%s%s",&local_28,param_3,&local_18);
return;
}
|
|
6,490 | PFS_buffer_default_array<PFS_mutex>::allocate(pfs_dirty_state*) | eloqsql/storage/perfschema/pfs_buffer_container.h | value_type *allocate(pfs_dirty_state *dirty_state)
{
uint index;
uint monotonic;
uint monotonic_max;
value_type *pfs;
if (m_full)
return NULL;
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
monotonic_max= monotonic + static_cast<uint>(m_max);
while (monotonic < monotonic_max)
{
index= monotonic % m_max;
pfs= m_ptr + index;
if (pfs->m_lock.free_to_dirty(dirty_state))
{
return pfs;
}
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
}
m_full= true;
return NULL;
} | O0 | c | PFS_buffer_default_array<PFS_mutex>::allocate(pfs_dirty_state*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, (%rax)
je 0x56a4a
movq $0x0, -0x8(%rbp)
jmp 0x56ae5
movq -0x38(%rbp), %rdi
addq $0x4, %rdi
movl $0x1, %esi
callq 0x31670
movq -0x38(%rbp), %rcx
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq 0x50(%rcx), %rcx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x56ad6
movq -0x38(%rbp), %rcx
movl -0x20(%rbp), %eax
xorl %edx, %edx
divq 0x50(%rcx)
movq -0x38(%rbp), %rax
movl %edx, %ecx
movl %ecx, -0x1c(%rbp)
movq 0x48(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x680, %rcx, %rcx # imm = 0x680
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32780
testb $0x1, %al
jne 0x56ab5
jmp 0x56abf
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x56ae5
movq -0x38(%rbp), %rdi
addq $0x4, %rdi
movl $0x1, %esi
callq 0x31670
movl %eax, -0x20(%rbp)
jmp 0x56a6f
movq -0x38(%rbp), %rax
movb $0x1, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| _ZN24PFS_buffer_default_arrayI17PFS_prepared_stmtE8allocateEP15pfs_dirty_state:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
test byte ptr [rax], 1
jz short loc_56A4A
mov [rbp+var_8], 0
jmp loc_56AE5
loc_56A4A:
mov rdi, [rbp+var_38]
add rdi, 4; this
mov esi, (offset dword_0+1); unsigned int *
call _ZN10PFS_atomic7add_u32EPjj; PFS_atomic::add_u32(uint *,uint)
mov rcx, [rbp+var_38]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
mov rcx, [rcx+50h]
add eax, ecx
mov [rbp+var_24], eax
loc_56A6F:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_24]
jnb short loc_56AD6
mov rcx, [rbp+var_38]
mov eax, [rbp+var_20]
xor edx, edx
div qword ptr [rcx+50h]
mov rax, [rbp+var_38]
mov ecx, edx
mov [rbp+var_1C], ecx
mov rax, [rax+48h]
mov ecx, [rbp+var_1C]
imul rcx, 680h
add rax, rcx
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_18]
call _ZN8pfs_lock13free_to_dirtyEP15pfs_dirty_state; pfs_lock::free_to_dirty(pfs_dirty_state *)
test al, 1
jnz short loc_56AB5
jmp short loc_56ABF
loc_56AB5:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
jmp short loc_56AE5
loc_56ABF:
mov rdi, [rbp+var_38]
add rdi, 4; this
mov esi, (offset dword_0+1); unsigned int *
call _ZN10PFS_atomic7add_u32EPjj; PFS_atomic::add_u32(uint *,uint)
mov [rbp+var_20], eax
jmp short loc_56A6F
loc_56AD6:
mov rax, [rbp+var_38]
mov byte ptr [rax], 1
mov [rbp+var_8], 0
loc_56AE5:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| PFS_atomic * PFS_buffer_default_array<PFS_prepared_stmt>::allocate(long long a1, unsigned int *a2)
{
PFS_atomic *v3; // [rsp+10h] [rbp-30h]
unsigned int v4; // [rsp+1Ch] [rbp-24h]
unsigned int v5; // [rsp+20h] [rbp-20h]
if ( (*(_BYTE *)a1 & 1) != 0 )
return 0LL;
v5 = PFS_atomic::add_u32((PFS_atomic *)(a1 + 4), (unsigned int *)((char *)&dword_0 + 1));
v4 = *(_QWORD *)(a1 + 80) + v5;
while ( v5 < v4 )
{
v3 = (PFS_atomic *)(1664 * ((unsigned long long)v5 % *(_QWORD *)(a1 + 80)) + *(_QWORD *)(a1 + 72));
if ( (pfs_lock::free_to_dirty(v3, a2) & 1) != 0 )
return v3;
v5 = PFS_atomic::add_u32((PFS_atomic *)(a1 + 4), (unsigned int *)((char *)&dword_0 + 1));
}
*(_BYTE *)a1 = 1;
return 0LL;
}
| allocate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
TEST byte ptr [RAX],0x1
JZ 0x00156a4a
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00156ae5
LAB_00156a4a:
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x4
MOV ESI,0x1
CALL 0x00131670
MOV RCX,qword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x50]
ADD EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
LAB_00156a6f:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x00156ad6
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x20]
XOR EDX,EDX
DIV qword ptr [RCX + 0x50]
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,EDX
MOV dword ptr [RBP + -0x1c],ECX
MOV RAX,qword ptr [RAX + 0x48]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x680
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00132780
TEST AL,0x1
JNZ 0x00156ab5
JMP 0x00156abf
LAB_00156ab5:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00156ae5
LAB_00156abf:
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x4
MOV ESI,0x1
CALL 0x00131670
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00156a6f
LAB_00156ad6:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x1
MOV qword ptr [RBP + -0x8],0x0
LAB_00156ae5:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
/* PFS_buffer_default_array<PFS_prepared_stmt>::allocate(pfs_dirty_state*) */
pfs_lock * __thiscall
PFS_buffer_default_array<PFS_prepared_stmt>::allocate
(PFS_buffer_default_array<PFS_prepared_stmt> *this,pfs_dirty_state *param_1)
{
uint uVar1;
pfs_lock *this_00;
ulong uVar2;
uint local_28;
if (((byte)*this & 1) == 0) {
local_28 = PFS_atomic::add_u32((uint *)(this + 4),1);
uVar1 = local_28 + (int)*(int8 *)(this + 0x50);
while (local_28 < uVar1) {
this_00 = (pfs_lock *)
(*(long *)(this + 0x48) +
((ulong)local_28 % *(ulong *)(this + 0x50) & 0xffffffff) * 0x680);
uVar2 = pfs_lock::free_to_dirty(this_00,param_1);
if ((uVar2 & 1) != 0) {
return this_00;
}
local_28 = PFS_atomic::add_u32((uint *)(this + 4),1);
}
*this = (PFS_buffer_default_array<PFS_prepared_stmt>)0x1;
}
return (pfs_lock *)0x0;
}
|
|
6,491 | PFS_buffer_default_array<PFS_mutex>::allocate(pfs_dirty_state*) | eloqsql/storage/perfschema/pfs_buffer_container.h | value_type *allocate(pfs_dirty_state *dirty_state)
{
uint index;
uint monotonic;
uint monotonic_max;
value_type *pfs;
if (m_full)
return NULL;
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
monotonic_max= monotonic + static_cast<uint>(m_max);
while (monotonic < monotonic_max)
{
index= monotonic % m_max;
pfs= m_ptr + index;
if (pfs->m_lock.free_to_dirty(dirty_state))
{
return pfs;
}
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
}
m_full= true;
return NULL;
} | O3 | c | PFS_buffer_default_array<PFS_mutex>::allocate(pfs_dirty_state*):
cmpb $0x0, (%rdi)
je 0x4665b
xorl %ecx, %ecx
jmp 0x466b7
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
lock
xaddl %eax, 0x4(%rdi)
movl 0x50(%rdi), %r8d
addl %eax, %r8d
cmpl %r8d, %eax
jae 0x466b1
movl %eax, %eax
xorl %edx, %edx
divq 0x50(%rdi)
movq 0x48(%rdi), %rcx
imulq $0x940, %rdx, %rdx # imm = 0x940
movl 0x7e0(%rcx,%rdx), %eax
testb $0x3, %al
jne 0x466a5
addq %rdx, %rcx
movl %eax, %edx
orl $0x1, %edx
lock
cmpxchgl %edx, 0x7e0(%rcx)
je 0x466bb
movl $0x1, %eax
lock
xaddl %eax, 0x4(%rdi)
jmp 0x46670
movb $0x1, (%rdi)
xorl %ecx, %ecx
popq %rbp
movq %rcx, %rax
retq
movl %edx, (%rsi)
jmp 0x466b6
nop
| _ZN24PFS_buffer_default_arrayI8PFS_hostE8allocateEP15pfs_dirty_state:
cmp byte ptr [rdi], 0
jz short loc_4665B
xor ecx, ecx
jmp short loc_466B7
loc_4665B:
push rbp
mov rbp, rsp
mov eax, 1
lock xadd [rdi+4], eax
mov r8d, [rdi+50h]
add r8d, eax
loc_46670:
cmp eax, r8d
jnb short loc_466B1
mov eax, eax
xor edx, edx
div qword ptr [rdi+50h]
mov rcx, [rdi+48h]
imul rdx, 940h
mov eax, [rcx+rdx+7E0h]
test al, 3
jnz short loc_466A5
add rcx, rdx
mov edx, eax
or edx, 1
lock cmpxchg [rcx+7E0h], edx
jz short loc_466BB
loc_466A5:
mov eax, 1
lock xadd [rdi+4], eax
jmp short loc_46670
loc_466B1:
mov byte ptr [rdi], 1
xor ecx, ecx
loc_466B6:
pop rbp
loc_466B7:
mov rax, rcx
retn
loc_466BB:
mov [rsi], edx
jmp short loc_466B6
| long long PFS_buffer_default_array<PFS_host>::allocate(long long a1, signed __int32 *a2)
{
long long v2; // rcx
unsigned __int32 v3; // eax
unsigned __int32 v4; // r8d
long long v5; // rcx
unsigned long long v6; // rdx
signed __int32 v7; // eax
if ( *(_BYTE *)a1 )
return 0LL;
v3 = _InterlockedExchangeAdd((volatile signed __int32 *)(a1 + 4), 1u);
v4 = v3 + *(_DWORD *)(a1 + 80);
while ( 1 )
{
if ( v3 >= v4 )
{
*(_BYTE *)a1 = 1;
return 0LL;
}
v5 = *(_QWORD *)(a1 + 72);
v6 = 2368 * ((unsigned long long)v3 % *(_QWORD *)(a1 + 80));
v7 = *(_DWORD *)(v5 + v6 + 2016);
if ( (v7 & 3) == 0 )
{
v2 = v6 + v5;
if ( v7 == _InterlockedCompareExchange((volatile signed __int32 *)(v2 + 2016), v7 | 1, v7) )
break;
}
v3 = _InterlockedExchangeAdd((volatile signed __int32 *)(a1 + 4), 1u);
}
*a2 = v7 | 1;
return v2;
}
| allocate:
CMP byte ptr [RDI],0x0
JZ 0x0014665b
XOR ECX,ECX
JMP 0x001466b7
LAB_0014665b:
PUSH RBP
MOV RBP,RSP
MOV EAX,0x1
XADD.LOCK dword ptr [RDI + 0x4],EAX
MOV R8D,dword ptr [RDI + 0x50]
ADD R8D,EAX
LAB_00146670:
CMP EAX,R8D
JNC 0x001466b1
MOV EAX,EAX
XOR EDX,EDX
DIV qword ptr [RDI + 0x50]
MOV RCX,qword ptr [RDI + 0x48]
IMUL RDX,RDX,0x940
MOV EAX,dword ptr [RCX + RDX*0x1 + 0x7e0]
TEST AL,0x3
JNZ 0x001466a5
ADD RCX,RDX
MOV EDX,EAX
OR EDX,0x1
CMPXCHG.LOCK dword ptr [RCX + 0x7e0],EDX
JZ 0x001466bb
LAB_001466a5:
MOV EAX,0x1
XADD.LOCK dword ptr [RDI + 0x4],EAX
JMP 0x00146670
LAB_001466b1:
MOV byte ptr [RDI],0x1
XOR ECX,ECX
LAB_001466b6:
POP RBP
LAB_001466b7:
MOV RAX,RCX
RET
LAB_001466bb:
MOV dword ptr [RSI],EDX
JMP 0x001466b6
|
/* PFS_buffer_default_array<PFS_host>::allocate(pfs_dirty_state*) */
long __thiscall
PFS_buffer_default_array<PFS_host>::allocate
(PFS_buffer_default_array<PFS_host> *this,pfs_dirty_state *param_1)
{
PFS_buffer_default_array<PFS_host> *pPVar1;
uint *puVar2;
uint uVar3;
long lVar4;
uint uVar5;
bool bVar6;
if (*this == (PFS_buffer_default_array<PFS_host>)0x0) {
LOCK();
pPVar1 = this + 4;
uVar3 = *(uint *)pPVar1;
*(uint *)pPVar1 = *(uint *)pPVar1 + 1;
UNLOCK();
uVar5 = *(int *)(this + 0x50) + uVar3;
while (uVar3 < uVar5) {
lVar4 = ((ulong)uVar3 % *(ulong *)(this + 0x50)) * 0x940;
uVar3 = *(uint *)(*(long *)(this + 0x48) + 0x7e0 + lVar4);
if ((uVar3 & 3) == 0) {
lVar4 = *(long *)(this + 0x48) + lVar4;
puVar2 = (uint *)(lVar4 + 0x7e0);
LOCK();
bVar6 = uVar3 == *puVar2;
if (bVar6) {
*puVar2 = uVar3 | 1;
}
UNLOCK();
if (bVar6) {
*(uint *)param_1 = uVar3 | 1;
return lVar4;
}
}
LOCK();
pPVar1 = this + 4;
uVar3 = *(uint *)pPVar1;
*(uint *)pPVar1 = *(uint *)pPVar1 + 1;
UNLOCK();
}
*this = (PFS_buffer_default_array<PFS_host>)0x1;
}
return 0;
}
|
|
6,492 | my_long10_to_str_8bit | eloqsql/strings/ctype-simple.c | size_t my_long10_to_str_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t len, int radix, long int val)
{
char buffer[66];
register char *p, *e;
long int new_val;
uint sign=0;
unsigned long int uval = (unsigned long int) val;
e = p = &buffer[sizeof(buffer)-1];
*p= 0;
if (radix < 0)
{
if (val < 0)
{
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval= (unsigned long int)0 - uval;
*dst++= '-';
len--;
sign= 1;
}
}
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;
}
len= MY_MIN(len, (size_t) (e-p));
memcpy(dst, p, len);
return len+sign;
} | O0 | c | my_long10_to_str_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdx, -0x68(%rbp)
movl %ecx, -0x6c(%rbp)
movq %r8, -0x78(%rbp)
movl $0x0, -0x94(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x50(%rbp), %rax
addq $0x41, %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x6c(%rbp)
jge 0x46e31
cmpq $0x0, -0x78(%rbp)
jge 0x46e2f
xorl %eax, %eax
subq -0xa0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp)
movb $0x2d, (%rax)
movq -0x68(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x68(%rbp)
movl $0x1, -0x94(%rbp)
jmp 0x46e31
movq -0xa0(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x90(%rbp)
movq -0xa0(%rbp), %rax
imulq $0xa, -0x90(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0x46ed2
movq -0x78(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x90(%rbp)
movq -0x78(%rbp), %rax
imulq $0xa, -0x90(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x46e80
movq -0x68(%rbp), %rax
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x46ef6
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0x46f0b
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x24260
movq -0x68(%rbp), %rax
movl -0x94(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x46f5d
movq -0xb0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
callq 0x24370
nopw %cs:(%rax,%rax)
| my_long10_to_str_8bit:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov [rbp+var_6C], ecx
mov [rbp+var_78], r8
mov [rbp+var_94], 0
mov rax, [rbp+var_78]
mov [rbp+var_A0], rax
lea rax, [rbp+var_50]
add rax, 41h ; 'A'
mov [rbp+var_80], rax
mov [rbp+var_88], rax
mov rax, [rbp+var_80]
mov byte ptr [rax], 0
cmp [rbp+var_6C], 0
jge short loc_46E31
cmp [rbp+var_78], 0
jge short loc_46E2F
xor eax, eax
sub rax, [rbp+var_A0]
mov [rbp+var_A0], rax
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 1
mov [rbp+var_60], rcx
mov byte ptr [rax], 2Dh ; '-'
mov rax, [rbp+var_68]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_68], rax
mov [rbp+var_94], 1
loc_46E2F:
jmp short $+2
loc_46E31:
mov rax, [rbp+var_A0]
mov ecx, 0Ah
xor edx, edx
div rcx
mov [rbp+var_90], rax
mov rax, [rbp+var_A0]
imul rcx, [rbp+var_90], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_90]
mov [rbp+var_78], rax
loc_46E80:
cmp [rbp+var_78], 0
jz short loc_46ED2
mov rax, [rbp+var_78]
mov ecx, 0Ah
cqo
idiv rcx
mov [rbp+var_90], rax
mov rax, [rbp+var_78]
imul rcx, [rbp+var_90], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_90]
mov [rbp+var_78], rax
jmp short loc_46E80
loc_46ED2:
mov rax, [rbp+var_68]
mov rcx, [rbp+var_88]
mov rdx, [rbp+var_80]
sub rcx, rdx
cmp rax, rcx
jnb short loc_46EF6
mov rax, [rbp+var_68]
mov [rbp+var_A8], rax
jmp short loc_46F0B
loc_46EF6:
mov rax, [rbp+var_88]
mov rcx, [rbp+var_80]
sub rax, rcx
mov [rbp+var_A8], rax
loc_46F0B:
mov rax, [rbp+var_A8]
mov [rbp+var_68], rax
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_68]
call _memcpy
mov rax, [rbp+var_68]
mov ecx, [rbp+var_94]
add rax, rcx
mov [rbp+var_B0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_46F5D
mov rax, [rbp+var_B0]
add rsp, 0B0h
pop rbp
retn
loc_46F5D:
call ___stack_chk_fail
| _BYTE * my_long10_to_str_8bit(long long a1, _BYTE *a2, _BYTE *a3, int a4, long long a5)
{
char *v5; // rax
_BYTE *v7; // [rsp+8h] [rbp-A8h]
unsigned long long v8; // [rsp+10h] [rbp-A0h]
unsigned int v9; // [rsp+1Ch] [rbp-94h]
char *v10; // [rsp+30h] [rbp-80h]
signed long long i; // [rsp+38h] [rbp-78h]
_BYTE *v12; // [rsp+48h] [rbp-68h]
_BYTE *v13; // [rsp+50h] [rbp-60h]
char v14; // [rsp+A0h] [rbp-10h] BYREF
_BYTE v15[7]; // [rsp+A1h] [rbp-Fh] BYREF
unsigned long long v16; // [rsp+A8h] [rbp-8h]
v16 = __readfsqword(0x28u);
v13 = a2;
v12 = a3;
v9 = 0;
v8 = a5;
v15[0] = 0;
if ( a4 < 0 && a5 < 0 )
{
v8 = -a5;
v13 = a2 + 1;
*a2 = 45;
v12 = a3 - 1;
v9 = 1;
}
v10 = &v14;
v14 = v8 % 0xA + 48;
for ( i = v8 / 0xA; i; i /= 10LL )
{
v5 = v10--;
*(v5 - 1) = i % 10 + 48;
}
if ( (unsigned long long)v12 >= v15 - v10 )
v7 = (_BYTE *)(v15 - v10);
else
v7 = v12;
memcpy(v13, v10, v7);
return &v7[v9];
}
| my_long10_to_str_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV dword ptr [RBP + -0x6c],ECX
MOV qword ptr [RBP + -0x78],R8
MOV dword ptr [RBP + -0x94],0x0
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0xa0],RAX
LEA RAX,[RBP + -0x50]
ADD RAX,0x41
MOV qword ptr [RBP + -0x80],RAX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX],0x0
CMP dword ptr [RBP + -0x6c],0x0
JGE 0x00146e31
CMP qword ptr [RBP + -0x78],0x0
JGE 0x00146e2f
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x60],RCX
MOV byte ptr [RAX],0x2d
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x68],RAX
MOV dword ptr [RBP + -0x94],0x1
LAB_00146e2f:
JMP 0x00146e31
LAB_00146e31:
MOV RAX,qword ptr [RBP + -0xa0]
MOV ECX,0xa
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0xa0]
IMUL RCX,qword ptr [RBP + -0x90],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x78],RAX
LAB_00146e80:
CMP qword ptr [RBP + -0x78],0x0
JZ 0x00146ed2
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,0xa
CQO
IDIV RCX
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x78]
IMUL RCX,qword ptr [RBP + -0x90],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00146e80
LAB_00146ed2:
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RBP + -0x80]
SUB RCX,RDX
CMP RAX,RCX
JNC 0x00146ef6
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x00146f0b
LAB_00146ef6:
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x80]
SUB RAX,RCX
MOV qword ptr [RBP + -0xa8],RAX
LAB_00146f0b:
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x68]
CALL 0x00124260
MOV RAX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RBP + -0x94]
ADD RAX,RCX
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00146f5d
MOV RAX,qword ptr [RBP + -0xb0]
ADD RSP,0xb0
POP RBP
RET
LAB_00146f5d:
CALL 0x00124370
|
char * my_long10_to_str_8bit
(int8 param_1,int1 *param_2,char *param_3,int param_4,ulong param_5)
{
long in_FS_OFFSET;
char *local_b0;
ulong local_a8;
uint local_9c;
char *local_88;
ulong local_80;
char *local_70;
int1 *local_68;
char local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_9c = 0;
local_19[2] = 0;
local_a8 = param_5;
local_70 = param_3;
local_68 = param_2;
if (param_4 < 0) {
if ((long)param_5 < 0) {
local_a8 = -param_5;
local_68 = param_2 + 1;
*param_2 = 0x2d;
local_70 = param_3 + -1;
}
local_9c = (uint)((long)param_5 < 0);
}
local_19[1] = (char)local_a8 + (char)(local_a8 / 10) * -10 + '0';
local_88 = local_19 + 1;
local_80 = local_a8 / 10;
while (local_80 != 0) {
local_88[-1] = (char)local_80 + (char)((long)local_80 / 10) * -10 + '0';
local_88 = local_88 + -1;
local_80 = (long)local_80 / 10;
}
if (local_70 < local_19 + (2 - (long)local_88)) {
local_b0 = local_70;
}
else {
local_b0 = local_19 + (2 - (long)local_88);
}
memcpy(local_68,local_88,(size_t)local_b0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_b0 + local_9c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
6,493 | pfs_set_socket_state_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_set_socket_state_v1(PSI_socket *socket, PSI_socket_state state)
{
assert((state == PSI_SOCKET_STATE_IDLE) || (state == PSI_SOCKET_STATE_ACTIVE));
PFS_socket *pfs= reinterpret_cast<PFS_socket*>(socket);
assert(pfs != NULL);
assert(pfs->m_idle || (state == PSI_SOCKET_STATE_IDLE));
assert(!pfs->m_idle || (state == PSI_SOCKET_STATE_ACTIVE));
pfs->m_idle= (state == PSI_SOCKET_STATE_IDLE);
} | O0 | cpp | pfs_set_socket_state_v1:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
sete %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0xac(%rax)
popq %rbp
retq
nopl (%rax)
| pfs_set_socket_state_v1:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
cmp [rbp+var_C], 1
setz cl
mov rax, [rbp+var_18]
and cl, 1
mov [rax+0ACh], cl
pop rbp
retn
| long long pfs_set_socket_state_v1(long long a1, int a2)
{
long long result; // rax
result = a1;
*(_BYTE *)(a1 + 172) = a2 == 1;
return result;
}
| pfs_set_socket_state_v1:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP dword ptr [RBP + -0xc],0x1
SETZ CL
MOV RAX,qword ptr [RBP + -0x18]
AND CL,0x1
MOV byte ptr [RAX + 0xac],CL
POP RBP
RET
|
void pfs_set_socket_state_v1(long param_1,int param_2)
{
*(bool *)(param_1 + 0xac) = param_2 == 1;
return;
}
|
|
6,494 | get_charset_number_internal | eloqsql/mysys/charset.c | static uint
get_charset_number_internal(const char *charset_name, uint cs_flags)
{
CHARSET_INFO **cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if ( cs[0] && cs[0]->cs_name.str && (cs[0]->state & cs_flags) &&
!my_strcasecmp(&my_charset_latin1, cs[0]->cs_name.str, charset_name))
return cs[0]->number;
}
return 0;
} | O0 | c | get_charset_number_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x374a5a(%rip), %rax # 0x39dc90
movq %rax, -0x20(%rbp)
leaq 0x374a4f(%rip), %rax # 0x39dc90
addq $0x4000, %rax # imm = 0x4000
cmpq %rax, -0x20(%rbp)
jae 0x292c7
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x292b4
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x292b4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x292b4
leaq 0x260b42(%rip), %rax # 0x289dc0
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rsi
movq -0x10(%rbp), %rdx
leaq 0x260b21(%rip), %rdi # 0x289dc0
callq *%rax
cmpl $0x0, %eax
jne 0x292b4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x292ce
jmp 0x292b6
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x2923a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| get_charset_number_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
lea rax, all_charsets
mov [rbp+var_20], rax
loc_2923A:
lea rax, all_charsets
add rax, 4000h
cmp [rbp+var_20], rax
jnb short loc_292C7
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jz short loc_292B4
mov rax, [rbp+var_20]
mov rax, [rax]
cmp qword ptr [rax+10h], 0
jz short loc_292B4
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+0Ch]
and eax, [rbp+var_14]
cmp eax, 0
jz short loc_292B4
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_20]
mov rcx, [rcx]
mov rsi, [rcx+10h]
mov rdx, [rbp+var_10]
lea rdi, my_charset_latin1
call rax
cmp eax, 0
jnz short loc_292B4
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_4], eax
jmp short loc_292CE
loc_292B4:
jmp short $+2
loc_292B6:
mov rax, [rbp+var_20]
add rax, 8
mov [rbp+var_20], rax
jmp loc_2923A
loc_292C7:
mov [rbp+var_4], 0
loc_292CE:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long get_charset_number_internal(long long a1, int a2)
{
unsigned int **i; // [rsp+0h] [rbp-20h]
for ( i = (unsigned int **)all_charsets; i < &all_charsets[2048]; ++i )
{
if ( *i
&& *((_QWORD *)*i + 2)
&& (a2 & (*i)[3]) != 0
&& !(*(unsigned int ( **)(void *, _QWORD, long long))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*((_QWORD *)*i + 2),
a1) )
{
return **i;
}
}
return 0;
}
| get_charset_number_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
LEA RAX,[0x49dc90]
MOV qword ptr [RBP + -0x20],RAX
LAB_0012923a:
LEA RAX,[0x49dc90]
ADD RAX,0x4000
CMP qword ptr [RBP + -0x20],RAX
JNC 0x001292c7
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JZ 0x001292b4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x001292b4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,dword ptr [RBP + -0x14]
CMP EAX,0x0
JZ 0x001292b4
LEA RAX,[0x389dc0]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX]
MOV RSI,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x10]
LEA RDI,[0x389dc0]
CALL RAX
CMP EAX,0x0
JNZ 0x001292b4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001292ce
LAB_001292b4:
JMP 0x001292b6
LAB_001292b6:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x8
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0012923a
LAB_001292c7:
MOV dword ptr [RBP + -0x4],0x0
LAB_001292ce:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 get_charset_number_internal(int8 param_1,uint param_2)
{
int iVar1;
long *local_28;
local_28 = &all_charsets;
while( true ) {
if ((long *)0x4a1c8f < local_28) {
return 0;
}
if ((((*local_28 != 0) && (*(long *)(*local_28 + 0x10) != 0)) &&
((*(uint *)(*local_28 + 0xc) & param_2) != 0)) &&
(iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_00389e80 + 0x40))
(&my_charset_latin1,*(int8 *)(*local_28 + 0x10),param_1), iVar1 == 0
)) break;
local_28 = local_28 + 1;
}
return *(int4 *)*local_28;
}
|
|
6,495 | resetGameDataDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 666mxvbee[P]BattleShip/lib/Utils/FileUtils.cpp | void resetGameDataDirectory(const std::string& path) {
std::error_code ec;
std::filesystem::remove_all(path, ec);
if (!std::filesystem::create_directories(path, ec)) {
if (ec) {
std::cerr << "Error while creating directory " << path << ": " << ec.message() << "\n";
}
}
} | O1 | cpp | resetGameDataDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x0, (%r14)
callq 0x51f0
movq %rax, 0x8(%r14)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x18b1e
movq %r15, %rdi
movq %r14, %rsi
callq 0x54d0
leaq 0x10(%rsp), %rdi
callq 0x5f84
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x18b1e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x55d0
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x5f84
cmpl $0x0, (%rsp)
sete %al
orb %al, %bpl
jne 0x188af
movq 0xc7bf(%rip), %r14 # 0x24fe0
leaq 0x31ea(%rip), %rsi # 0x1ba12
movl $0x1f, %edx
movq %r14, %rdi
callq 0x5400
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x5400
movq %rax, %rbx
leaq 0x1a86(%rip), %rsi # 0x1a2d4
movl $0x2, %edx
movq %rax, %rdi
callq 0x5400
movq 0x8(%rsp), %rsi
movl (%rsp), %edx
movq (%rsi), %rax
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x5400
leaq 0x3023(%rip), %rsi # 0x1b8aa
movl $0x1, %edx
movq %rax, %rdi
callq 0x5400
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x188af
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5380
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x188e9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5380
jmp 0x188e9
jmp 0x188dc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5f84
movq %rbx, %rdi
callq 0x55e0
| _Z22resetGameDataDirectoryRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push rbx
sub rsp, 38h
mov rbx, rdi
mov r14, rsp
mov dword ptr [r14], 0
call __ZNSt3_V215system_categoryEv; std::_V2::system_category(void)
mov [r14+8], rax
lea r15, [rsp+58h+var_48]
mov rdi, r15; this
mov rsi, rbx
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<std::string,std::filesystem::__cxx11::path>(std::string const&,std::filesystem::__cxx11::path::format)
mov rdi, r15
mov rsi, r14
call __ZNSt10filesystem10remove_allERKNS_7__cxx114pathERSt10error_code; std::filesystem::remove_all(std::filesystem::__cxx11::path const&,std::error_code &)
lea rdi, [rsp+58h+var_48]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea r14, [rsp+58h+var_48]
mov rdi, r14; this
mov rsi, rbx
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<std::string,std::filesystem::__cxx11::path>(std::string const&,std::filesystem::__cxx11::path::format)
mov rsi, rsp
mov rdi, r14
call __ZNSt10filesystem18create_directoriesERKNS_7__cxx114pathERSt10error_code; std::filesystem::create_directories(std::filesystem::__cxx11::path const&,std::error_code &)
mov ebp, eax
lea rdi, [rsp+58h+var_48]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
cmp [rsp+58h+var_58], 0
setz al
or bpl, al
jnz loc_188AF
mov r14, cs:_ZSt4cerr_ptr
lea rsi, aErrorWhileCrea; "Error while creating directory "
mov edx, 1Fh
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rbx]
mov rdx, [rbx+8]
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
lea rsi, aSettingsStartg_4+31h; ": "
mov edx, 2
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rsp+58h+var_50]
mov edx, [rsp+58h+var_58]
mov rax, [rsi]
lea r14, [rsp+58h+var_48]
mov rdi, r14
call qword ptr [rax+20h]
mov rsi, [r14]
mov rdx, [r14+8]
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)
lea rsi, aSlaveAllMaster+2Dh; "\n"
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+58h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_188AF
mov rsi, [rsp+58h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_188AF:
add rsp, 38h
pop rbx
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_188E9
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_188E9
jmp short $+2
loc_188DC:
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
loc_188E9:
mov rdi, rbx
call __Unwind_Resume
| void resetGameDataDirectory(std::_V2 *a1)
{
unsigned __int8 v1; // bp
long long v2; // rbx
long long v3; // rax
unsigned int v4; // [rsp+0h] [rbp-58h] BYREF
long long v5; // [rsp+8h] [rbp-50h]
void *v6[2]; // [rsp+10h] [rbp-48h] BYREF
long long v7; // [rsp+20h] [rbp-38h] BYREF
v4 = 0;
v5 = std::_V2::system_category(a1);
std::filesystem::__cxx11::path::path<std::string,std::filesystem::__cxx11::path>((std::filesystem::__cxx11::path *)v6);
std::filesystem::remove_all(v6, &v4);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v6);
std::filesystem::__cxx11::path::path<std::string,std::filesystem::__cxx11::path>((std::filesystem::__cxx11::path *)v6);
v1 = std::filesystem::create_directories(v6, &v4);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v6);
if ( !((v4 == 0) | v1) )
{
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "Error while creating directory ", 31LL);
v2 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, *(_QWORD *)a1, *((_QWORD *)a1 + 1));
std::__ostream_insert<char,std::char_traits<char>>(v2, ": ", 2LL);
(*(void ( **)(void **, long long, _QWORD))(*(_QWORD *)v5 + 32LL))(v6, v5, v4);
v3 = std::__ostream_insert<char,std::char_traits<char>>(v2, v6[0], v6[1]);
std::__ostream_insert<char,std::char_traits<char>>(v3, "\n", 1LL);
if ( v6[0] != &v7 )
operator delete(v6[0], v7 + 1);
}
}
| resetGameDataDirectory:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV R14,RSP
MOV dword ptr [R14],0x0
CALL 0x001051f0
MOV qword ptr [R14 + 0x8],RAX
LEA R15,[RSP + 0x10]
MOV RDI,R15
MOV RSI,RBX
MOV EDX,0x2
CALL 0x00118b1e
LAB_001187c9:
MOV RDI,R15
MOV RSI,R14
CALL 0x001054d0
LAB_001187d4:
LEA RDI,[RSP + 0x10]
CALL 0x00105f84
LEA R14,[RSP + 0x10]
MOV RDI,R14
MOV RSI,RBX
MOV EDX,0x2
CALL 0x00118b1e
LAB_001187f3:
MOV RSI,RSP
MOV RDI,R14
CALL 0x001055d0
LAB_001187fe:
MOV EBP,EAX
LEA RDI,[RSP + 0x10]
CALL 0x00105f84
CMP dword ptr [RSP],0x0
SETZ AL
OR BPL,AL
JNZ 0x001188af
MOV R14,qword ptr [0x00124fe0]
LEA RSI,[0x11ba12]
MOV EDX,0x1f
MOV RDI,R14
CALL 0x00105400
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
MOV RDI,R14
CALL 0x00105400
MOV RBX,RAX
LEA RSI,[0x11a2d4]
MOV EDX,0x2
MOV RDI,RAX
CALL 0x00105400
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,dword ptr [RSP]
MOV RAX,qword ptr [RSI]
LEA R14,[RSP + 0x10]
MOV RDI,R14
CALL qword ptr [RAX + 0x20]
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
LAB_00118878:
MOV RDI,RBX
CALL 0x00105400
LEA RSI,[0x11b8aa]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00105400
LAB_00118894:
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001188af
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x00105380
LAB_001188af:
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* resetGameDataDirectory(std::__cxx11::string const&) */
void resetGameDataDirectory(string *param_1)
{
int *puVar1;
char cVar2;
ostream *poVar3;
int local_58 [2];
long *local_50;
long *local_48;
long local_40;
long local_38 [3];
local_58[0] = 0;
local_50 = (long *)std::_V2::system_category();
std::filesystem::__cxx11::path::path<std::__cxx11::string,std::filesystem::__cxx11::path>
((path *)&local_48,param_1,2);
/* try { // try from 001187c9 to 001187d3 has its CatchHandler @ 001188dc */
std::filesystem::remove_all((path *)&local_48,(error_code *)local_58);
std::filesystem::__cxx11::path::~path((path *)&local_48);
std::filesystem::__cxx11::path::path<std::__cxx11::string,std::filesystem::__cxx11::path>
((path *)&local_48,param_1,2);
/* try { // try from 001187f3 to 001187fd has its CatchHandler @ 001188da */
cVar2 = std::filesystem::create_directories((path *)&local_48,(error_code *)local_58);
std::filesystem::__cxx11::path::~path((path *)&local_48);
puVar1 = PTR_cerr_00124fe0;
if (cVar2 == '\0' && local_58[0] != 0) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00124fe0,"Error while creating directory ",0x1f);
poVar3 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)puVar1,*(char **)param_1,*(long *)(param_1 + 8));
std::__ostream_insert<char,std::char_traits<char>>(poVar3,": ",2);
(**(code **)(*local_50 + 0x20))(&local_48,local_50,local_58[0]);
/* try { // try from 00118878 to 00118893 has its CatchHandler @ 001188ba */
poVar3 = std::__ostream_insert<char,std::char_traits<char>>(poVar3,(char *)local_48,local_40);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"\n",1);
if (local_48 != local_38) {
operator_delete(local_48,local_38[0] + 1);
}
}
return;
}
|
|
6,496 | resetGameDataDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 666mxvbee[P]BattleShip/lib/Utils/FileUtils.cpp | void resetGameDataDirectory(const std::string& path) {
std::error_code ec;
std::filesystem::remove_all(path, ec);
if (!std::filesystem::create_directories(path, ec)) {
if (ec) {
std::cerr << "Error while creating directory " << path << ": " << ec.message() << "\n";
}
}
} | O3 | cpp | resetGameDataDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x0, (%r14)
callq 0x51f0
movq %rax, 0x8(%r14)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x18a66
movq %r15, %rdi
movq %r14, %rsi
callq 0x54d0
leaq 0x10(%rsp), %rdi
callq 0x5f34
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x18a66
movq %rsp, %rsi
movq %r14, %rdi
callq 0x55d0
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x5f34
cmpl $0x0, (%rsp)
sete %al
orb %al, %bpl
jne 0x187f7
movq 0xc877(%rip), %r14 # 0x24fe0
leaq 0x32d9(%rip), %rsi # 0x1ba49
movl $0x1f, %edx
movq %r14, %rdi
callq 0x5400
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x5400
movq %rax, %rbx
leaq 0x1b3e(%rip), %rsi # 0x1a2d4
movl $0x2, %edx
movq %rax, %rdi
callq 0x5400
movq 0x8(%rsp), %rsi
movl (%rsp), %edx
movq (%rsi), %rax
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x5400
leaq 0x3112(%rip), %rsi # 0x1b8e1
movl $0x1, %edx
movq %rax, %rdi
callq 0x5400
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x187f7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5380
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18831
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5380
jmp 0x18831
jmp 0x18824
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5f34
movq %rbx, %rdi
callq 0x55e0
| _Z22resetGameDataDirectoryRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push rbx
sub rsp, 38h
mov rbx, rdi
mov r14, rsp
mov dword ptr [r14], 0
call __ZNSt3_V215system_categoryEv; std::_V2::system_category(void)
mov [r14+8], rax
lea r15, [rsp+58h+var_48]
mov rdi, r15; this
mov rsi, rbx
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<std::string,std::filesystem::__cxx11::path>(std::string const&,std::filesystem::__cxx11::path::format)
mov rdi, r15
mov rsi, r14
call __ZNSt10filesystem10remove_allERKNS_7__cxx114pathERSt10error_code; std::filesystem::remove_all(std::filesystem::__cxx11::path const&,std::error_code &)
lea rdi, [rsp+58h+var_48]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea r14, [rsp+58h+var_48]
mov rdi, r14; this
mov rsi, rbx
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<std::string,std::filesystem::__cxx11::path>(std::string const&,std::filesystem::__cxx11::path::format)
mov rsi, rsp
mov rdi, r14
call __ZNSt10filesystem18create_directoriesERKNS_7__cxx114pathERSt10error_code; std::filesystem::create_directories(std::filesystem::__cxx11::path const&,std::error_code &)
mov ebp, eax
lea rdi, [rsp+58h+var_48]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
cmp [rsp+58h+var_58], 0
setz al
or bpl, al
jnz loc_187F7
mov r14, cs:_ZSt4cerr_ptr
lea rsi, aErrorWhileCrea; "Error while creating directory "
mov edx, 1Fh
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rbx]
mov rdx, [rbx+8]
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
lea rsi, aSettingsStartg_4+31h; ": "
mov edx, 2
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rsp+58h+var_50]
mov edx, [rsp+58h+var_58]
mov rax, [rsi]
lea r14, [rsp+58h+var_48]
mov rdi, r14
call qword ptr [rax+20h]
mov rsi, [r14]
mov rdx, [r14+8]
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)
lea rsi, aSlaveAllMaster+2Dh; "\n"
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+58h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_187F7
mov rsi, [rsp+58h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_187F7:
add rsp, 38h
pop rbx
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_18831
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_18831
jmp short $+2
loc_18824:
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
loc_18831:
mov rdi, rbx
call __Unwind_Resume
| void resetGameDataDirectory(std::_V2 *a1)
{
unsigned __int8 v1; // bp
long long v2; // rbx
long long v3; // rax
unsigned int v4; // [rsp+0h] [rbp-58h] BYREF
long long v5; // [rsp+8h] [rbp-50h]
void *v6[2]; // [rsp+10h] [rbp-48h] BYREF
long long v7; // [rsp+20h] [rbp-38h] BYREF
v4 = 0;
v5 = std::_V2::system_category(a1);
std::filesystem::__cxx11::path::path<std::string,std::filesystem::__cxx11::path>((std::filesystem::__cxx11::path *)v6);
std::filesystem::remove_all(v6, &v4);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v6);
std::filesystem::__cxx11::path::path<std::string,std::filesystem::__cxx11::path>((std::filesystem::__cxx11::path *)v6);
v1 = std::filesystem::create_directories(v6, &v4);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v6);
if ( !((v4 == 0) | v1) )
{
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "Error while creating directory ", 31LL);
v2 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, *(_QWORD *)a1, *((_QWORD *)a1 + 1));
std::__ostream_insert<char,std::char_traits<char>>(v2, ": ", 2LL);
(*(void ( **)(void **, long long, _QWORD))(*(_QWORD *)v5 + 32LL))(v6, v5, v4);
v3 = std::__ostream_insert<char,std::char_traits<char>>(v2, v6[0], v6[1]);
std::__ostream_insert<char,std::char_traits<char>>(v3, "\n", 1LL);
if ( v6[0] != &v7 )
operator delete(v6[0], v7 + 1);
}
}
| resetGameDataDirectory:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV R14,RSP
MOV dword ptr [R14],0x0
CALL 0x001051f0
MOV qword ptr [R14 + 0x8],RAX
LEA R15,[RSP + 0x10]
MOV RDI,R15
MOV RSI,RBX
MOV EDX,0x2
CALL 0x00118a66
LAB_00118711:
MOV RDI,R15
MOV RSI,R14
CALL 0x001054d0
LAB_0011871c:
LEA RDI,[RSP + 0x10]
CALL 0x00105f34
LEA R14,[RSP + 0x10]
MOV RDI,R14
MOV RSI,RBX
MOV EDX,0x2
CALL 0x00118a66
LAB_0011873b:
MOV RSI,RSP
MOV RDI,R14
CALL 0x001055d0
LAB_00118746:
MOV EBP,EAX
LEA RDI,[RSP + 0x10]
CALL 0x00105f34
CMP dword ptr [RSP],0x0
SETZ AL
OR BPL,AL
JNZ 0x001187f7
MOV R14,qword ptr [0x00124fe0]
LEA RSI,[0x11ba49]
MOV EDX,0x1f
MOV RDI,R14
CALL 0x00105400
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
MOV RDI,R14
CALL 0x00105400
MOV RBX,RAX
LEA RSI,[0x11a2d4]
MOV EDX,0x2
MOV RDI,RAX
CALL 0x00105400
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,dword ptr [RSP]
MOV RAX,qword ptr [RSI]
LEA R14,[RSP + 0x10]
MOV RDI,R14
CALL qword ptr [RAX + 0x20]
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
LAB_001187c0:
MOV RDI,RBX
CALL 0x00105400
LEA RSI,[0x11b8e1]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00105400
LAB_001187dc:
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001187f7
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x00105380
LAB_001187f7:
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* resetGameDataDirectory(std::__cxx11::string const&) */
void resetGameDataDirectory(string *param_1)
{
int *puVar1;
char cVar2;
ostream *poVar3;
int local_58 [2];
long *local_50;
long *local_48;
long local_40;
long local_38 [3];
local_58[0] = 0;
local_50 = (long *)std::_V2::system_category();
std::filesystem::__cxx11::path::path<std::__cxx11::string,std::filesystem::__cxx11::path>
((path *)&local_48,param_1,2);
/* try { // try from 00118711 to 0011871b has its CatchHandler @ 00118824 */
std::filesystem::remove_all((path *)&local_48,(error_code *)local_58);
std::filesystem::__cxx11::path::~path((path *)&local_48);
std::filesystem::__cxx11::path::path<std::__cxx11::string,std::filesystem::__cxx11::path>
((path *)&local_48,param_1,2);
/* try { // try from 0011873b to 00118745 has its CatchHandler @ 00118822 */
cVar2 = std::filesystem::create_directories((path *)&local_48,(error_code *)local_58);
std::filesystem::__cxx11::path::~path((path *)&local_48);
puVar1 = PTR_cerr_00124fe0;
if (cVar2 == '\0' && local_58[0] != 0) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00124fe0,"Error while creating directory ",0x1f);
poVar3 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)puVar1,*(char **)param_1,*(long *)(param_1 + 8));
std::__ostream_insert<char,std::char_traits<char>>(poVar3,": ",2);
(**(code **)(*local_50 + 0x20))(&local_48,local_50,local_58[0]);
/* try { // try from 001187c0 to 001187db has its CatchHandler @ 00118802 */
poVar3 = std::__ostream_insert<char,std::char_traits<char>>(poVar3,(char *)local_48,local_40);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"\n",1);
if (local_48 != local_38) {
operator_delete(local_48,local_38[0] + 1);
}
}
return;
}
|
|
6,497 | google::protobuf::DescriptorBuilder::CrossLinkService(google::protobuf::ServiceDescriptor*, google::protobuf::ServiceDescriptorProto const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | void DescriptorBuilder::CrossLinkService(ServiceDescriptor* service,
const ServiceDescriptorProto& proto) {
if (service->options_ == nullptr) {
service->options_ = &ServiceOptions::default_instance();
}
for (int i = 0; i < service->method_count(); i++) {
CrossLinkMethod(&service->methods_[i], proto.method(i));
}
} | O3 | cpp | google::protobuf::DescriptorBuilder::CrossLinkService(google::protobuf::ServiceDescriptor*, google::protobuf::ServiceDescriptorProto const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x18(%rsi)
jne 0xd773c
leaq 0x13a9f0(%rip), %rax # 0x212128
movq %rax, 0x18(%r14)
cmpl $0x0, 0x28(%r14)
jle 0xd7771
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x20(%r14), %rsi
addq %r12, %rsi
movq 0x28(%rbx), %rax
movq 0x8(%rax,%r13,8), %rdx
movq %r15, %rdi
callq 0xd77a4
incq %r13
movslq 0x28(%r14), %rax
addq $0x40, %r12
cmpq %rax, %r13
jl 0xd7749
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| _ZN6google8protobuf17DescriptorBuilder16CrossLinkServiceEPNS0_17ServiceDescriptorERKNS0_22ServiceDescriptorProtoE:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
cmp qword ptr [rsi+18h], 0
jnz short loc_D773C
lea rax, _ZN6google8protobuf33_ServiceOptions_default_instance_E; google::protobuf::_ServiceOptions_default_instance_
mov [r14+18h], rax
loc_D773C:
cmp dword ptr [r14+28h], 0
jle short loc_D7771
xor r12d, r12d
xor r13d, r13d
loc_D7749:
mov rsi, [r14+20h]
add rsi, r12; google::protobuf::MethodDescriptor *
mov rax, [rbx+28h]
mov rdx, [rax+r13*8+8]; google::protobuf::MethodDescriptorProto *
mov rdi, r15; this
call _ZN6google8protobuf17DescriptorBuilder15CrossLinkMethodEPNS0_16MethodDescriptorERKNS0_21MethodDescriptorProtoE; google::protobuf::DescriptorBuilder::CrossLinkMethod(google::protobuf::MethodDescriptor *,google::protobuf::MethodDescriptorProto const&)
inc r13
movsxd rax, dword ptr [r14+28h]
add r12, 40h ; '@'
cmp r13, rax
jl short loc_D7749
loc_D7771:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| void ( *** google::protobuf::DescriptorBuilder::CrossLinkService(
google::protobuf::DescriptorBuilder *this,
google::protobuf::ServiceDescriptor *a2,
const google::protobuf::ServiceDescriptorProto *a3))(google::protobuf::ServiceOptions *__hidden this)
{
void ( ***result)(google::protobuf::ServiceOptions *__hidden); // rax
long long v5; // r12
void ( ***v6)(google::protobuf::ServiceOptions *__hidden); // r13
if ( !*((_QWORD *)a2 + 3) )
{
result = &google::protobuf::_ServiceOptions_default_instance_;
*((_QWORD *)a2 + 3) = &google::protobuf::_ServiceOptions_default_instance_;
}
if ( *((int *)a2 + 10) > 0 )
{
v5 = 0LL;
v6 = 0LL;
do
{
google::protobuf::DescriptorBuilder::CrossLinkMethod(
this,
(google::protobuf::MethodDescriptor *)(v5 + *((_QWORD *)a2 + 4)),
*(const google::protobuf::MethodDescriptorProto **)(*((_QWORD *)a3 + 5) + 8LL * (_QWORD)v6 + 8));
v6 = (void ( ***)(google::protobuf::ServiceOptions *__hidden))((char *)v6 + 1);
result = (void ( ***)(google::protobuf::ServiceOptions *__hidden))*((int *)a2 + 10);
v5 += 64LL;
}
while ( (long long)v6 < (long long)result );
}
return result;
}
| CrossLinkService:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
CMP qword ptr [RSI + 0x18],0x0
JNZ 0x001d773c
LEA RAX,[0x312128]
MOV qword ptr [R14 + 0x18],RAX
LAB_001d773c:
CMP dword ptr [R14 + 0x28],0x0
JLE 0x001d7771
XOR R12D,R12D
XOR R13D,R13D
LAB_001d7749:
MOV RSI,qword ptr [R14 + 0x20]
ADD RSI,R12
MOV RAX,qword ptr [RBX + 0x28]
MOV RDX,qword ptr [RAX + R13*0x8 + 0x8]
MOV RDI,R15
CALL 0x001d77a4
INC R13
MOVSXD RAX,dword ptr [R14 + 0x28]
ADD R12,0x40
CMP R13,RAX
JL 0x001d7749
LAB_001d7771:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* google::protobuf::DescriptorBuilder::CrossLinkService(google::protobuf::ServiceDescriptor*,
google::protobuf::ServiceDescriptorProto const&) */
void __thiscall
google::protobuf::DescriptorBuilder::CrossLinkService
(DescriptorBuilder *this,ServiceDescriptor *param_1,ServiceDescriptorProto *param_2)
{
long lVar1;
long lVar2;
if (*(long *)(param_1 + 0x18) == 0) {
*(int1 **)(param_1 + 0x18) = _ServiceOptions_default_instance_;
}
if (0 < *(int *)(param_1 + 0x28)) {
lVar1 = 0;
lVar2 = 0;
do {
CrossLinkMethod(this,(MethodDescriptor *)(*(long *)(param_1 + 0x20) + lVar1),
*(MethodDescriptorProto **)(*(long *)(param_2 + 0x28) + 8 + lVar2 * 8));
lVar2 = lVar2 + 1;
lVar1 = lVar1 + 0x40;
} while (lVar2 < *(int *)(param_1 + 0x28));
}
return;
}
|
|
6,498 | CLI::Validator::Validator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | MikePodsytnik[P]TCRtrie/build_O2/_deps/cli11-src/include/CLI/Validators.hpp | explicit Validator(std::string validator_desc) : desc_function_([validator_desc]() { return validator_desc; }) {} | O2 | cpp | CLI::Validator::Validator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x75e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd5d8
leaq 0x8(%rsp), %rdi
callq 0x7860
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
leaq 0x1d2(%rip), %rax # 0xd71e
movq %rax, 0x38(%rbx)
leaq 0x1db(%rip), %rax # 0xd732
movq %rax, 0x30(%rbx)
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
movb $0x0, 0x50(%rbx)
orl $-0x1, 0x60(%rbx)
movw $0x1, 0x64(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7860
movq %rbx, %rdi
callq 0x7770
nop
| _ZN3CLI9ValidatorC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rsp+38h+var_30]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rdi, rbx
mov rsi, r14
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvEEC2IZN3CLI9ValidatorC1ES5_EUlvE_vEEOT_; std::function<std::string ()(void)>::function<CLI::Validator::Validator(std::string)::{lambda(void)#1},void>(CLI::Validator::Validator(std::string)::{lambda(void)#1} &&)
lea rdi, [rsp+38h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
xorps xmm0, xmm0
movups xmmword ptr [rbx+20h], xmm0
lea rax, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS5_EN3CLI9Validator5func_MUlS6_E_EE9_M_invokeERKSt9_Any_dataS6_
mov [rbx+38h], rax
lea rax, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS5_EN3CLI9Validator5func_MUlS6_E_EE10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation
mov [rbx+30h], rax
lea rax, [rbx+50h]
mov [rbx+40h], rax
and qword ptr [rbx+48h], 0
mov byte ptr [rbx+50h], 0
or dword ptr [rbx+60h], 0FFFFFFFFh
mov word ptr [rbx+64h], 1
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long CLI::Validator::Validator(long long a1)
{
long long result; // rax
_BYTE v2[48]; // [rsp+8h] [rbp-30h] BYREF
std::string::basic_string(v2);
std::function<std::string ()(void)>::function<CLI::Validator::Validator(std::string)::{lambda(void)#1},void>(a1, v2);
std::string::~string(v2);
*(_OWORD *)(a1 + 32) = 0LL;
*(_QWORD *)(a1 + 56) = ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS5_EN3CLI9Validator5func_MUlS6_E_EE9_M_invokeERKSt9_Any_dataS6_;
*(_QWORD *)(a1 + 48) = ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS5_EN3CLI9Validator5func_MUlS6_E_EE10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation;
result = a1 + 80;
*(_QWORD *)(a1 + 64) = a1 + 80;
*(_QWORD *)(a1 + 72) = 0LL;
*(_BYTE *)(a1 + 80) = 0;
*(_DWORD *)(a1 + 96) = -1;
*(_WORD *)(a1 + 100) = 1;
return result;
}
| Validator:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x001075e0
LAB_0010d529:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010d5d8
LAB_0010d534:
LEA RDI,[RSP + 0x8]
CALL 0x00107860
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
LEA RAX,[0x10d71e]
MOV qword ptr [RBX + 0x38],RAX
LEA RAX,[0x10d732]
MOV qword ptr [RBX + 0x30],RAX
LEA RAX,[RBX + 0x50]
MOV qword ptr [RBX + 0x40],RAX
AND qword ptr [RBX + 0x48],0x0
MOV byte ptr [RBX + 0x50],0x0
OR dword ptr [RBX + 0x60],0xffffffff
MOV word ptr [RBX + 0x64],0x1
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* CLI::Validator::Validator(std::__cxx11::string) */
void __thiscall CLI::Validator::Validator(Validator *this,string *param_2)
{
string local_30 [32];
std::__cxx11::string::string(local_30,param_2);
/* try { // try from 0010d529 to 0010d533 has its CatchHandler @ 0010d57e */
std::function<std::__cxx11::string()>::
function<CLI::Validator::Validator(std::__cxx11::string)::_lambda()_1_,void>((_lambda___1_ *)this)
;
std::__cxx11::string::~string(local_30);
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(code **)(this + 0x38) =
std::
_Function_handler<std::__cxx11::string(std::__cxx11::string&),CLI::Validator::func_::{lambda(std::__cxx11::string&)#1}>
::_M_invoke;
*(code **)(this + 0x30) =
std::
_Function_handler<std::__cxx11::string(std::__cxx11::string&),CLI::Validator::func_::{lambda(std::__cxx11::string&)#1}>
::_M_manager;
*(Validator **)(this + 0x40) = this + 0x50;
*(int8 *)(this + 0x48) = 0;
this[0x50] = (Validator)0x0;
*(int4 *)(this + 0x60) = 0xffffffff;
*(int2 *)(this + 100) = 1;
return;
}
|
|
6,499 | evmone::instr::core::tload(evmone::StackTop, evmone::ExecutionState&) | corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/lib/evmone/instructions.hpp | inline void tload(StackTop stack, ExecutionState& state) noexcept
{
auto& x = stack.top();
const auto key = intx::be::store<evmc::bytes32>(x);
const auto value = state.host.get_transient_storage(state.msg->recipient, key);
x = intx::be::load<uint256>(value);
} | O2 | cpp | evmone::instr::core::tload(evmone::StackTop, evmone::ExecutionState&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3c237
movq 0x20(%r14), %rax
addq $0x28, %r14
movl 0x28(%rax), %ecx
movq %rsp, %rdx
movl %ecx, 0x10(%rdx)
movups 0x18(%rax), %xmm0
movaps %xmm0, (%rdx)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x2f5ec
movdqa 0x10(%r12), %xmm0
movdqa 0x3ab8e(%rip), %xmm1 # 0x76da0
pshufb %xmm1, %xmm0
movdqu %xmm0, (%rbx)
movdqa (%r12), %xmm0
pshufb %xmm1, %xmm0
movdqu %xmm0, 0x10(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN6evmone5instr4core5tloadENS_8StackTopERNS_14ExecutionStateE:
push r15
push r14
push r12
push rbx
sub rsp, 68h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+88h+var_40]
mov rdi, r15
mov rsi, rbx
call _ZN4intx2be5storeIN4evmc7bytes32ENS_4uintILj256EEEEET_RKT0_; intx::be::store<evmc::bytes32,intx::uint<256u>>(intx::uint<256u> const&)
mov rax, [r14+20h]
add r14, 28h ; '('
mov ecx, [rax+28h]
mov rdx, rsp
mov [rdx+10h], ecx
movups xmm0, xmmword ptr [rax+18h]
movaps xmmword ptr [rdx], xmm0
lea r12, [rsp+88h+var_68]
mov rdi, r12
mov rsi, r14
mov rcx, r15
call _ZNK4evmc11HostContext21get_transient_storageERKNS_7addressERKNS_7bytes32E; evmc::HostContext::get_transient_storage(evmc::address const&,evmc::bytes32 const&)
movdqa xmm0, xmmword ptr [r12+10h]
movdqa xmm1, cs:xmmword_76DA0
pshufb xmm0, xmm1
movdqu xmmword ptr [rbx], xmm0
movdqa xmm0, xmmword ptr [r12]
pshufb xmm0, xmm1
movdqu xmmword ptr [rbx+10h], xmm0
add rsp, 68h
pop rbx
pop r12
pop r14
pop r15
retn
| _OWORD * evmone::instr::core::tload(__m128i *a1, long long a2)
{
_OWORD *result; // rax
__m128i si128; // xmm1
__m128i v4; // [rsp+20h] [rbp-68h] BYREF
__m128i v5; // [rsp+30h] [rbp-58h] BYREF
_BYTE v6[64]; // [rsp+48h] [rbp-40h] BYREF
intx::be::store<evmc::bytes32,intx::uint<256u>>(v6, a1);
result = evmc::HostContext::get_transient_storage(&v4, a2 + 40);
si128 = _mm_load_si128((const __m128i *)&xmmword_76DA0);
*a1 = _mm_shuffle_epi8(_mm_load_si128(&v5), si128);
a1[1] = _mm_shuffle_epi8(_mm_load_si128(&v4), si128);
return result;
}
| tload:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x48]
MOV RDI,R15
MOV RSI,RBX
CALL 0x0013c237
MOV RAX,qword ptr [R14 + 0x20]
ADD R14,0x28
MOV ECX,dword ptr [RAX + 0x28]
MOV RDX,RSP
MOV dword ptr [RDX + 0x10],ECX
MOVUPS XMM0,xmmword ptr [RAX + 0x18]
MOVAPS xmmword ptr [RDX],XMM0
LEA R12,[RSP + 0x20]
MOV RDI,R12
MOV RSI,R14
MOV RCX,R15
CALL 0x0012f5ec
MOVDQA XMM0,xmmword ptr [R12 + 0x10]
MOVDQA XMM1,xmmword ptr [0x00176da0]
PSHUFB XMM0,XMM1
MOVDQU xmmword ptr [RBX],XMM0
MOVDQA XMM0,xmmword ptr [R12]
PSHUFB XMM0,XMM1
MOVDQU xmmword ptr [RBX + 0x10],XMM0
ADD RSP,0x68
POP RBX
POP R12
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* evmone::instr::core::tload(evmone::StackTop, evmone::ExecutionState&) */
void evmone::instr::core::tload(uint *param_1,long param_2)
{
int1 auVar1 [16];
int1 auVar2 [16];
address local_68 [16];
int1 local_58 [16];
be local_40 [32];
intx::be::store<evmc::bytes32,intx::uint<256u>>(local_40,param_1);
evmc::HostContext::get_transient_storage(local_68,(bytes32 *)(param_2 + 0x28));
auVar2 = _DAT_00176da0;
auVar1 = pshufb(local_58,_DAT_00176da0);
*(int1 (*) [16])param_1 = auVar1;
auVar2 = pshufb((int1 [16])local_68,auVar2);
*(int1 (*) [16])(param_1 + 0x10) = auVar2;
return;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.