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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
10,800 |
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>::empty() const
|
monkey531[P]llama/common/json.hpp
|
bool empty() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return true;
}
case value_t::array:
{
// delegate call to array_t::empty()
return m_data.m_value.array->empty();
}
case value_t::object:
{
// delegate call to object_t::empty()
return m_data.m_value.object->empty();
}
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
// all other types are nonempty
return false;
}
}
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::empty() const:
movzbl (%rdi), %eax
testl %eax, %eax
je 0xcb1ec
cmpl $0x1, %eax
je 0xcb1dd
cmpl $0x2, %eax
jne 0xcb1ef
movq 0x8(%rdi), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5emptyEv:
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_CB1EC
cmp eax, 1
jz short loc_CB1DD
cmp eax, 2
jnz short loc_CB1EF
loc_CB1DD:
mov rax, [rdi+8]
mov rcx, [rax]
cmp rcx, [rax+8]
setz al
retn
loc_CB1EC:
mov al, 1
retn
loc_CB1EF:
xor eax, eax
retn
|
bool 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>::empty(
unsigned __int8 *a1)
{
int v1; // eax
v1 = *a1;
if ( !*a1 )
return 1;
if ( v1 == 1 || v1 == 2 )
return **((_QWORD **)a1 + 1) == *(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL);
return 0;
}
|
empty:
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x001cb1ec
CMP EAX,0x1
JZ 0x001cb1dd
CMP EAX,0x2
JNZ 0x001cb1ef
LAB_001cb1dd:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
SETZ AL
RET
LAB_001cb1ec:
MOV AL,0x1
RET
LAB_001cb1ef:
XOR EAX,EAX
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::empty() 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>
::empty(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
long *plVar2;
bVar1 = *this;
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
return 1;
}
if ((bVar1 != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) &&
(bVar1 != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2)) {
return 0;
}
plVar2 = *(long **)(this + 8);
return CONCAT71((int7)((ulong)plVar2 >> 8),*plVar2 == plVar2[1]);
}
|
|
10,801 |
my_strnxfrm_latin1_de
|
eloqsql/strings/ctype-latin1.c
|
static size_t
my_strnxfrm_latin1_de(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar* src, size_t srclen, uint flags)
{
uchar *de= dst + dstlen;
const uchar *se= src + srclen;
uchar *d0= dst;
for ( ; src < se && dst < de && nweights; src++, nweights--)
{
uchar chr= combo1map[*src];
*dst++= chr;
if ((chr= combo2map[*src]) && dst < de && nweights > 1)
{
*dst++= chr;
nweights--;
}
}
return my_strxfrm_pad_desc_and_reverse(cs, d0, dst, de, nweights, flags, 0);
}
|
O3
|
c
|
my_strnxfrm_latin1_de:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rax
movl %ecx, %r10d
movq %rdx, %rcx
movl 0x10(%rbp), %r9d
addq %rsi, %rcx
testq %rax, %rax
jle 0x4ad6f
addq %r8, %rax
leaq 0x8dc27(%rip), %r11 # 0xd8930
leaq 0x8dd20(%rip), %rbx # 0xd8a30
movq %rsi, %r14
cmpq %rcx, %r14
jae 0x4ad74
testl %r10d, %r10d
je 0x4ad74
movzbl (%r8), %edx
movb (%rdx,%r11), %r15b
leaq 0x1(%r14), %rdx
movb %r15b, (%r14)
movzbl (%r8), %r15d
movb (%r15,%rbx), %r15b
testb %r15b, %r15b
je 0x4ad5f
cmpq %rcx, %rdx
setb %r12b
cmpl $0x2, %r10d
setae %r13b
andb %r12b, %r13b
cmpb $0x1, %r13b
jne 0x4ad5f
movb %r15b, 0x1(%r14)
addq $0x2, %r14
decl %r10d
movq %r14, %rdx
incq %r8
decl %r10d
movq %rdx, %r14
cmpq %rax, %r8
jb 0x4ad13
jmp 0x4ad77
movq %rsi, %rdx
jmp 0x4ad77
movq %r14, %rdx
movl $0x0, (%rsp)
movl %r10d, %r8d
callq 0x32028
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
|
my_strnxfrm_latin1_de:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rax, r9
mov r10d, ecx
mov rcx, rdx
mov r9d, [rbp+arg_0]
add rcx, rsi
test rax, rax
jle short loc_4AD6F
add rax, r8
lea r11, combo1map
lea rbx, combo2map
mov r14, rsi
loc_4AD13:
cmp r14, rcx
jnb short loc_4AD74
test r10d, r10d
jz short loc_4AD74
movzx edx, byte ptr [r8]
mov r15b, [rdx+r11]
lea rdx, [r14+1]
mov [r14], r15b
movzx r15d, byte ptr [r8]
mov r15b, [r15+rbx]
test r15b, r15b
jz short loc_4AD5F
cmp rdx, rcx
setb r12b
cmp r10d, 2
setnb r13b
and r13b, r12b
cmp r13b, 1
jnz short loc_4AD5F
mov [r14+1], r15b
add r14, 2
dec r10d
mov rdx, r14
loc_4AD5F:
inc r8
dec r10d
mov r14, rdx
cmp r8, rax
jb short loc_4AD13
jmp short loc_4AD77
loc_4AD6F:
mov rdx, rsi
jmp short loc_4AD77
loc_4AD74:
mov rdx, r14
loc_4AD77:
mov [rsp+30h+var_30], 0
mov r8d, r10d
call my_strxfrm_pad_desc_and_reverse
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_strnxfrm_latin1_de(
long long a1,
long long a2,
long long a3,
unsigned int a4,
unsigned __int8 *a5,
long long a6,
unsigned int a7)
{
unsigned long long v8; // rcx
unsigned __int8 *v9; // rax
_BYTE *v10; // r14
unsigned long long v11; // rdx
unsigned __int8 v12; // r15
v8 = a2 + a3;
if ( a6 <= 0 )
{
v11 = a2;
}
else
{
v9 = &a5[a6];
v10 = (_BYTE *)a2;
while ( (unsigned long long)v10 < v8 && a4 )
{
v11 = (unsigned long long)(v10 + 1);
*v10 = combo1map[*a5];
v12 = combo2map[*a5];
if ( v12 && v11 < v8 && a4 >= 2 )
{
v10[1] = v12;
--a4;
v11 = (unsigned long long)(v10 + 2);
}
++a5;
--a4;
v10 = (_BYTE *)v11;
if ( a5 >= v9 )
return my_strxfrm_pad_desc_and_reverse(a1, a2, v11, v8, a4, a7, 0);
}
v11 = (unsigned long long)v10;
}
return my_strxfrm_pad_desc_and_reverse(a1, a2, v11, v8, a4, a7, 0);
}
|
my_strnxfrm_latin1_de:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RAX,R9
MOV R10D,ECX
MOV RCX,RDX
MOV R9D,dword ptr [RBP + 0x10]
ADD RCX,RSI
TEST RAX,RAX
JLE 0x0014ad6f
ADD RAX,R8
LEA R11,[0x1d8930]
LEA RBX,[0x1d8a30]
MOV R14,RSI
LAB_0014ad13:
CMP R14,RCX
JNC 0x0014ad74
TEST R10D,R10D
JZ 0x0014ad74
MOVZX EDX,byte ptr [R8]
MOV R15B,byte ptr [RDX + R11*0x1]
LEA RDX,[R14 + 0x1]
MOV byte ptr [R14],R15B
MOVZX R15D,byte ptr [R8]
MOV R15B,byte ptr [R15 + RBX*0x1]
TEST R15B,R15B
JZ 0x0014ad5f
CMP RDX,RCX
SETC R12B
CMP R10D,0x2
SETNC R13B
AND R13B,R12B
CMP R13B,0x1
JNZ 0x0014ad5f
MOV byte ptr [R14 + 0x1],R15B
ADD R14,0x2
DEC R10D
MOV RDX,R14
LAB_0014ad5f:
INC R8
DEC R10D
MOV R14,RDX
CMP R8,RAX
JC 0x0014ad13
JMP 0x0014ad77
LAB_0014ad6f:
MOV RDX,RSI
JMP 0x0014ad77
LAB_0014ad74:
MOV RDX,R14
LAB_0014ad77:
MOV dword ptr [RSP],0x0
MOV R8D,R10D
CALL 0x00132028
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_strnxfrm_latin1_de
(int8 param_1,int1 *param_2,long param_3,uint param_4,byte *param_5,
long param_6,int4 param_7)
{
ulong in_RAX;
byte *pbVar1;
int1 *puVar2;
int1 *puVar3;
int1 *puVar4;
puVar2 = param_2 + param_3;
puVar4 = param_2;
if (0 < param_6) {
pbVar1 = param_5 + param_6;
puVar3 = param_2;
do {
puVar4 = puVar3;
if ((puVar2 <= puVar3) || (param_4 == 0)) break;
puVar4 = puVar3 + 1;
*puVar3 = combo1map[*param_5];
if ((combo2map[*param_5] != '\0') && (1 < param_4 && puVar4 < puVar2)) {
puVar3[1] = combo2map[*param_5];
puVar4 = puVar3 + 2;
param_4 = param_4 - 1;
}
param_5 = param_5 + 1;
param_4 = param_4 - 1;
puVar3 = puVar4;
} while (param_5 < pbVar1);
}
my_strxfrm_pad_desc_and_reverse
(param_1,param_2,puVar4,puVar2,param_4,param_7,in_RAX & 0xffffffff00000000);
return;
}
|
|
10,802 |
my_copy_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t
my_copy_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
set_if_smaller(src_length, dst_length);
set_if_smaller(src_length, nchars);
if (src_length)
memmove(dst, src, src_length);
status->m_source_end_pos= src + src_length;
status->m_well_formed_error_pos= NULL;
return src_length;
}
|
O3
|
c
|
my_copy_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq 0x10(%rbp), %r15
cmpq %rdx, %r8
cmovbq %r8, %rbx
cmpq %r9, %rbx
cmovaeq %r9, %rbx
testq %rbx, %rbx
je 0x3da8d
movq %rsi, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x245a0
addq %rbx, %r14
movq %r14, (%r15)
movq $0x0, 0x8(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
my_copy_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rcx
mov rbx, rdx
mov r15, [rbp+arg_0]
cmp r8, rdx
cmovb rbx, r8
cmp rbx, r9
cmovnb rbx, r9
test rbx, rbx
jz short loc_3DA8D
mov rdi, rsi
mov rsi, r14
mov rdx, rbx
call _memmove
loc_3DA8D:
add r14, rbx
mov [r15], r14
mov qword ptr [r15+8], 0
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
unsigned long long my_copy_8bit(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
unsigned long long a6,
_QWORD *a7)
{
unsigned long long v8; // rbx
v8 = a3;
if ( a5 < a3 )
v8 = a5;
if ( v8 >= a6 )
v8 = a6;
if ( v8 )
memmove(a2, a4, v8);
*a7 = v8 + a4;
a7[1] = 0LL;
return v8;
}
|
my_copy_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV RBX,RDX
MOV R15,qword ptr [RBP + 0x10]
CMP R8,RDX
CMOVC RBX,R8
CMP RBX,R9
CMOVNC RBX,R9
TEST RBX,RBX
JZ 0x0013da8d
MOV RDI,RSI
MOV RSI,R14
MOV RDX,RBX
CALL 0x001245a0
LAB_0013da8d:
ADD R14,RBX
MOV qword ptr [R15],R14
MOV qword ptr [R15 + 0x8],0x0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
size_t my_copy_8bit(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
ulong param_6,long *param_7)
{
if (param_5 < param_3) {
param_3 = param_5;
}
if (param_6 <= param_3) {
param_3 = param_6;
}
if (param_3 != 0) {
memmove(param_2,param_4,param_3);
}
*param_7 = (long)param_4 + param_3;
param_7[1] = 0;
return param_3;
}
|
|
10,803 |
js_typed_array_slice
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_typed_array_slice(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue args[2];
JSValue arr, val;
JSObject *p, *p1;
int n, len, start, final, count, shift, space;
arr = JS_UNDEFINED;
p = get_typed_array(ctx, this_val);
if (!p)
return JS_EXCEPTION;
if (typed_array_is_oob(p))
return JS_ThrowTypeErrorArrayBufferOOB(ctx);
len = p->u.array.count;
if (JS_ToInt32Clamp(ctx, &start, argv[0], 0, len, len))
goto exception;
final = len;
if (!JS_IsUndefined(argv[1])) {
if (JS_ToInt32Clamp(ctx, &final, argv[1], 0, len, len))
goto exception;
}
count = max_int(final - start, 0);
args[0] = this_val;
args[1] = js_int32(count);
arr = js_typed_array___speciesCreate(ctx, JS_UNDEFINED, 2, args);
if (JS_IsException(arr))
goto exception;
if (count > 0) {
if (validate_typed_array(ctx, this_val)
|| validate_typed_array(ctx, arr))
goto exception;
if (len != p->u.array.count)
goto slow_path;
p1 = get_typed_array(ctx, arr);
if (p1 != NULL && p->class_id == p1->class_id &&
typed_array_get_length(ctx, p1) >= count &&
typed_array_get_length(ctx, p) >= start + count) {
shift = typed_array_size_log2(p->class_id);
memmove(p1->u.array.u.uint8_ptr,
p->u.array.u.uint8_ptr + (start << shift),
count << shift);
} else {
slow_path:
space = max_int(0, p->u.array.count - start);
count = min_int(count, space);
for (n = 0; n < count; n++) {
val = JS_GetPropertyValue(ctx, this_val, js_int32(start + n));
if (JS_IsException(val))
goto exception;
if (JS_SetPropertyValue(ctx, arr, js_int32(n), val,
JS_PROP_THROW) < 0)
goto exception;
}
}
}
return arr;
exception:
JS_FreeValue(ctx, arr);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_typed_array_slice:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, 0x50(%rsp)
cmpl $-0x1, %r15d
jne 0x80bca
movq 0x50(%rsp), %r13
movzwl 0x6(%r13), %eax
addl $-0x15, %eax
cmpw $0xc, %ax
jb 0x80bde
leaq 0x20138(%rip), %rsi # 0xa0d09
xorl %r13d, %r13d
movq %r14, %rdi
xorl %eax, %eax
callq 0x21953
movl $0x6, %ebp
testq %r13, %r13
je 0x80c09
movq %r13, %rdi
callq 0x38ab0
testl %eax, %eax
je 0x80c0f
leaq 0x2011f(%rip), %rsi # 0xa0d1a
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x21953
jmp 0x80c0b
xorl %ebx, %ebx
xorl %eax, %eax
jmp 0x80c58
movl 0x40(%r13), %ebp
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movl %ebp, (%rsp)
leaq 0x3c(%rsp), %rsi
movq %r14, %rdi
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x26b42
movl $0x3, %edx
testl %eax, %eax
je 0x80c70
xorl %eax, %eax
xorl %ebx, %ebx
shlq $0x20, %rax
movl %ebx, %esi
orq %rax, %rsi
movq 0x18(%r14), %rdi
callq 0x1ccb2
xorl %ebx, %ebx
xorl %eax, %eax
movl $0x6, %ebp
orq %rax, %rbx
movq %rbx, %rax
movq %rbp, %rdx
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, 0x1c(%rsp)
movq 0x18(%rbx), %rcx
cmpl $0x3, %ecx
je 0x80ca6
movq 0x10(%rbx), %rdx
movl %ebp, (%rsp)
leaq 0x1c(%rsp), %rsi
xorl %ebx, %ebx
movq %r14, %rdi
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x26b42
movl $0x3, %edx
testl %eax, %eax
je 0x80ca6
xorl %eax, %eax
jmp 0x80c3d
movl 0x1c(%rsp), %ebx
movl 0x3c(%rsp), %ecx
movq %rcx, 0x30(%rsp)
subl %ecx, %ebx
xorl %eax, %eax
testl %ebx, %ebx
cmovgl %ebx, %eax
leaq 0x50(%rsp), %rdx
movq %r12, (%rdx)
movq %r15, 0x8(%rdx)
movq %rax, 0x28(%rsp)
movq %rax, 0x10(%rdx)
movq $0x0, 0x18(%rdx)
movq %r14, %rdi
movl $0x2, %esi
callq 0x7738d
movq %rax, %rcx
shrq $0x20, %rax
cmpl $0x6, %edx
jne 0x80cfa
movq %rcx, %rbx
jmp 0x80c3d
movq %rax, 0x20(%rsp)
movq %rdx, 0x10(%rsp)
testl %ebx, %ebx
movq %rcx, %rbx
jle 0x80e2a
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x81ff3
testl %eax, %eax
jne 0x80d35
movq %r14, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
callq 0x81ff3
testl %eax, %eax
je 0x80d44
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
jmp 0x80c3d
cmpl 0x40(%r13), %ebp
jne 0x80da9
movq %r14, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
callq 0x38a76
testq %rax, %rax
je 0x80da9
movzwl 0x6(%r13), %edx
movzwl 0x6(%rax), %ecx
cmpw %cx, %dx
jne 0x80da9
movq 0x30(%rax), %rdi
leaq 0x1b457(%rip), %rsi # 0x9c1cf
movb -0x15(%rcx,%rsi), %cl
movl 0x24(%rdi), %edi
shrl %cl, %edi
cmpl 0x28(%rsp), %edi
jb 0x80da9
movq 0x30(%r13), %rdi
movzbl -0x15(%rdx,%rsi), %ecx
movl 0x24(%rdi), %edx
shrl %cl, %edx
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdi
addl %edi, %esi
cmpl %esi, %edx
jae 0x80e46
movl 0x40(%r13), %ebp
subl 0x30(%rsp), %ebp
testl %ebp, %ebp
jle 0x80e2a
movq 0x28(%rsp), %rax
cmpl %ebp, %eax
cmovll %eax, %ebp
cmpl $0x1, %ebp
adcl $0x0, %ebp
xorl %r13d, %r13d
movq 0x30(%rsp), %rax
leal (%rax,%r13), %ecx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x3f219
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
cmpl $0x6, %edx
je 0x80d35
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rcx
xorl %r8d, %r8d
movl $0x4000, %r9d # imm = 0x4000
callq 0x24145
testl %eax, %eax
js 0x80d35
incq %r13
cmpq %r13, %rbp
jne 0x80dc8
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq %rbx, %rax
andq %rcx, %rax
movl %ebx, %ebx
movq 0x10(%rsp), %rbp
jmp 0x80c58
movq 0x38(%rax), %rdi
movq 0x30(%rsp), %rax
shll %cl, %eax
movslq %eax, %rsi
addq 0x38(%r13), %rsi
movq 0x28(%rsp), %rax
shll %cl, %eax
movslq %eax, %rdx
callq 0xe710
jmp 0x80e2a
|
js_typed_array_slice:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov rbx, r8
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov [rsp+0A8h+var_58], rsi
cmp r15d, 0FFFFFFFFh
jnz short loc_80BCA
mov r13, [rsp+0A8h+var_58]
movzx eax, word ptr [r13+6]
add eax, 0FFFFFFEBh
cmp ax, 0Ch
jb short loc_80BDE
loc_80BCA:
lea rsi, aNotATypedarray; "not a TypedArray"
xor r13d, r13d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
loc_80BDE:
mov ebp, 6
test r13, r13
jz short loc_80C09
mov rdi, r13
call typed_array_is_oob
test eax, eax
jz short loc_80C0F
lea rsi, aArraybufferIsD_0; "ArrayBuffer is detached or resized"
xor ebx, ebx
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
jmp short loc_80C0B
loc_80C09:
xor ebx, ebx
loc_80C0B:
xor eax, eax
jmp short loc_80C58
loc_80C0F:
mov ebp, [r13+40h]
mov rdx, [rbx]
mov rcx, [rbx+8]
mov dword ptr [rsp+0A8h+var_A8], ebp
lea rsi, [rsp+0A8h+var_6C]
mov rdi, r14
xor r8d, r8d
mov r9d, ebp
call JS_ToInt32Clamp
mov edx, 3
test eax, eax
jz short loc_80C70
xor eax, eax
xor ebx, ebx
loc_80C3D:
shl rax, 20h
mov esi, ebx
or rsi, rax
mov rdi, [r14+18h]
call JS_FreeValueRT
xor ebx, ebx
xor eax, eax
mov ebp, 6
loc_80C58:
or rbx, rax
mov rax, rbx
mov rdx, rbp
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_80C70:
mov [rsp+0A8h+var_8C], ebp
mov rcx, [rbx+18h]
cmp ecx, 3
jz short loc_80CA6
mov rdx, [rbx+10h]
mov dword ptr [rsp+0A8h+var_A8], ebp
lea rsi, [rsp+0A8h+var_8C]
xor ebx, ebx
mov rdi, r14
xor r8d, r8d
mov r9d, ebp
call JS_ToInt32Clamp
mov edx, 3
test eax, eax
jz short loc_80CA6
xor eax, eax
jmp short loc_80C3D
loc_80CA6:
mov ebx, [rsp+0A8h+var_8C]
mov ecx, [rsp+0A8h+var_6C]
mov [rsp+0A8h+var_78], rcx
sub ebx, ecx
xor eax, eax
test ebx, ebx
cmovg eax, ebx
lea rdx, [rsp+0A8h+var_58]
mov [rdx], r12
mov [rdx+8], r15
mov [rsp+0A8h+var_80], rax
mov [rdx+10h], rax
mov qword ptr [rdx+18h], 0
mov rdi, r14
mov esi, 2
call js_typed_array___speciesCreate
mov rcx, rax
shr rax, 20h
cmp edx, 6
jnz short loc_80CFA
mov rbx, rcx
jmp loc_80C3D
loc_80CFA:
mov [rsp+0A8h+var_88], rax
mov [rsp+0A8h+var_98], rdx
test ebx, ebx
mov rbx, rcx
jle loc_80E2A
mov rdi, r14
mov rsi, r12
mov rdx, r15
call validate_typed_array
test eax, eax
jnz short loc_80D35
mov rdi, r14
mov rsi, rbx
mov rdx, [rsp+0A8h+var_98]
call validate_typed_array
test eax, eax
jz short loc_80D44
loc_80D35:
mov rdx, [rsp+0A8h+var_98]
mov rax, [rsp+0A8h+var_88]
jmp loc_80C3D
loc_80D44:
cmp ebp, [r13+40h]
jnz short loc_80DA9
mov rdi, r14
mov rsi, rbx
mov rdx, [rsp+0A8h+var_98]
call get_typed_array
test rax, rax
jz short loc_80DA9
movzx edx, word ptr [r13+6]
movzx ecx, word ptr [rax+6]
cmp dx, cx
jnz short loc_80DA9
mov rdi, [rax+30h]
lea rsi, typed_array_size_log2
mov cl, [rcx+rsi-15h]
mov edi, [rdi+24h]
shr edi, cl
cmp edi, dword ptr [rsp+0A8h+var_80]
jb short loc_80DA9
mov rdi, [r13+30h]
movzx ecx, byte ptr [rdx+rsi-15h]
mov edx, [rdi+24h]
shr edx, cl
mov rsi, [rsp+0A8h+var_78]
mov rdi, [rsp+0A8h+var_80]
add esi, edi
cmp edx, esi
jnb loc_80E46
loc_80DA9:
mov ebp, [r13+40h]
sub ebp, dword ptr [rsp+0A8h+var_78]
test ebp, ebp
jle short loc_80E2A
mov rax, [rsp+0A8h+var_80]
cmp eax, ebp
cmovl ebp, eax
cmp ebp, 1
adc ebp, 0
xor r13d, r13d
loc_80DC8:
mov rax, [rsp+0A8h+var_78]
lea ecx, [rax+r13]
mov rdi, r14
mov rsi, r12
mov rdx, r15
xor r8d, r8d
call JS_GetPropertyValue
mov qword ptr [rsp+0A8h+var_68], rax
mov qword ptr [rsp+0A8h+var_68+8], rdx
cmp edx, 6
jz loc_80D35
movups xmm0, [rsp+0A8h+var_68]
movups [rsp+0A8h+var_A8], xmm0
mov rdi, r14
mov rsi, rbx
mov rdx, [rsp+0A8h+var_98]
mov rcx, r13
xor r8d, r8d
mov r9d, 4000h
call JS_SetPropertyValue
test eax, eax
js loc_80D35
inc r13
cmp rbp, r13
jnz short loc_80DC8
loc_80E2A:
mov rcx, 0FFFFFFFF00000000h
mov rax, rbx
and rax, rcx
mov ebx, ebx
mov rbp, [rsp+0A8h+var_98]
jmp loc_80C58
loc_80E46:
mov rdi, [rax+38h]
mov rax, [rsp+0A8h+var_78]
shl eax, cl
movsxd rsi, eax
add rsi, [r13+38h]
mov rax, [rsp+0A8h+var_80]
shl eax, cl
movsxd rdx, eax
call _memmove
jmp short loc_80E2A
|
unsigned long long js_typed_array_slice(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned long long v14; // rbx
long long v16; // r13
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
unsigned long long v23; // rax
int v24; // ebp
int v25; // eax
long long v26; // r8
long long v27; // r9
__m128 v28; // xmm4
__m128 v29; // xmm5
long long v30; // rdx
unsigned long long v31; // rax
long long v33; // rcx
_DWORD *v34; // rdx
int v35; // eax
unsigned int v36; // ebx
long long v37; // rax
unsigned long long v38; // rcx
bool v39; // cc
long long v40; // rcx
long long v41; // r8
long long v42; // r9
__m128 v43; // xmm4
__m128 v44; // xmm5
long long typed_array; // rax
long long v46; // rdx
long long v47; // rcx
char v48; // cl
int v49; // ebp
_DWORD *v50; // rbp
_DWORD *v51; // r13
__int128 v52; // rax
double v53; // xmm4_8
double v54; // xmm5_8
char v55; // [rsp+0h] [rbp-A8h]
unsigned long long v56; // [rsp+10h] [rbp-98h]
int v57; // [rsp+1Ch] [rbp-8Ch] BYREF
unsigned long long v58; // [rsp+20h] [rbp-88h]
long long v59; // [rsp+28h] [rbp-80h]
long long v60; // [rsp+30h] [rbp-78h]
unsigned int v61; // [rsp+3Ch] [rbp-6Ch] BYREF
__m128 v62; // [rsp+40h] [rbp-68h]
long long v63[11]; // [rsp+50h] [rbp-58h] BYREF
v14 = a5;
v63[0] = a2;
if ( (_DWORD)a3 != -1 || (v16 = v63[0], (unsigned __int16)(*(_WORD *)(v63[0] + 6) - 21) >= 0xCu) )
{
v16 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a TypedArray", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v55);
}
if ( !v16 )
{
v14 = 0LL;
goto LABEL_8;
}
if ( !typed_array_is_oob(v16) )
{
v24 = *(_DWORD *)(v16 + 64);
v25 = JS_ToInt32Clamp(a1, (int *)&v61, *(_DWORD **)v14, *(_QWORD *)(v14 + 8), 0, v24, v24);
v30 = 3LL;
if ( v25 )
{
v31 = 0LL;
LODWORD(v14) = 0;
LABEL_11:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)((v31 << 32) | (unsigned int)v14), v30);
v14 = 0LL;
v23 = 0LL;
return v23 | v14;
}
v57 = v24;
v33 = *(_QWORD *)(v14 + 24);
if ( (_DWORD)v33 != 3 )
{
v34 = *(_DWORD **)(v14 + 16);
LODWORD(v14) = 0;
v35 = JS_ToInt32Clamp(a1, &v57, v34, v33, 0, v24, v24);
v30 = 3LL;
if ( v35 )
{
v31 = 0LL;
goto LABEL_11;
}
}
v60 = v61;
v36 = v57 - v61;
v37 = 0LL;
if ( (int)(v57 - v61) > 0 )
v37 = v36;
v63[0] = a2;
v63[1] = a3;
v59 = v37;
v63[2] = v37;
v63[3] = 0LL;
v38 = js_typed_array___speciesCreate(a1, 2, v63, v61, v26, v27, a7, a8, a9, a10, v28, v29, a13, a14);
v31 = HIDWORD(v38);
if ( (_DWORD)v30 == 6 )
{
LODWORD(v14) = v38;
goto LABEL_11;
}
v58 = HIDWORD(v38);
v56 = v30;
v39 = (int)v36 <= 0;
v14 = v38;
if ( !v39 )
{
if ( (unsigned int)validate_typed_array(a1) || (unsigned int)validate_typed_array(a1) )
{
LABEL_23:
v30 = v56;
v31 = v58;
goto LABEL_11;
}
if ( v24 == *(_DWORD *)(v16 + 64)
&& (typed_array = get_typed_array(a1, v14, v56, v40, v41, v42, a7, a8, a9, a10, v43, v44, a13, a14)) != 0
&& (v46 = *(unsigned __int16 *)(v16 + 6), v47 = *(unsigned __int16 *)(typed_array + 6), (_WORD)v46 == (_WORD)v47)
&& *(_DWORD *)(*(_QWORD *)(typed_array + 48) + 36LL) >> typed_array_size_log2[v47 - 21] >= (unsigned int)v59
&& (v48 = typed_array_size_log2[v46 - 21],
*(_DWORD *)(*(_QWORD *)(v16 + 48) + 36LL) >> v48 >= (unsigned int)(v59 + v60)) )
{
memmove(
*(_QWORD *)(typed_array + 56),
*(_QWORD *)(v16 + 56) + (int)((_DWORD)v60 << v48),
(int)((_DWORD)v59 << v48));
}
else
{
v49 = *(_DWORD *)(v16 + 64) - v60;
if ( v49 > 0 )
{
if ( (int)v59 < v49 )
v49 = v59;
v50 = (_DWORD *)((unsigned int)(v49 == 0) + v49);
v51 = 0LL;
do
{
*(_QWORD *)&v52 = JS_GetPropertyValue(
a1,
a2,
a3,
(_DWORD *)(unsigned int)(v60 + (_DWORD)v51),
0LL,
a7,
a8,
a9,
a10,
*(double *)v43.m128_u64,
*(double *)v44.m128_u64,
a13,
a14);
v62 = (__m128)v52;
if ( DWORD2(v52) == 6 )
goto LABEL_23;
a7 = v62;
if ( (int)JS_SetPropertyValue(
a1,
v14,
v56,
v51,
0LL,
0x4000u,
*(double *)v62.m128_u64,
a8,
a9,
a10,
v53,
v54,
a13,
a14,
*(_OWORD *)&v62) < 0 )
goto LABEL_23;
v51 = (_DWORD *)((char *)v51 + 1);
}
while ( v50 != v51 );
}
}
}
v23 = v14 & 0xFFFFFFFF00000000LL;
v14 = (unsigned int)v14;
return v23 | v14;
}
v14 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"ArrayBuffer is detached or resized",
v17,
v18,
v19,
v20,
a7,
a8,
a9,
a10,
v21,
v22,
a13,
a14,
v55);
LABEL_8:
v23 = 0LL;
return v23 | v14;
}
|
js_typed_array_slice:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV RBX,R8
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV qword ptr [RSP + 0x50],RSI
CMP R15D,-0x1
JNZ 0x00180bca
MOV R13,qword ptr [RSP + 0x50]
MOVZX EAX,word ptr [R13 + 0x6]
ADD EAX,-0x15
CMP AX,0xc
JC 0x00180bde
LAB_00180bca:
LEA RSI,[0x1a0d09]
XOR R13D,R13D
MOV RDI,R14
XOR EAX,EAX
CALL 0x00121953
LAB_00180bde:
MOV EBP,0x6
TEST R13,R13
JZ 0x00180c09
MOV RDI,R13
CALL 0x00138ab0
TEST EAX,EAX
JZ 0x00180c0f
LEA RSI,[0x1a0d1a]
XOR EBX,EBX
MOV RDI,R14
XOR EAX,EAX
CALL 0x00121953
JMP 0x00180c0b
LAB_00180c09:
XOR EBX,EBX
LAB_00180c0b:
XOR EAX,EAX
JMP 0x00180c58
LAB_00180c0f:
MOV EBP,dword ptr [R13 + 0x40]
MOV RDX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
MOV dword ptr [RSP],EBP
LEA RSI,[RSP + 0x3c]
MOV RDI,R14
XOR R8D,R8D
MOV R9D,EBP
CALL 0x00126b42
MOV EDX,0x3
TEST EAX,EAX
JZ 0x00180c70
XOR EAX,EAX
XOR EBX,EBX
LAB_00180c3d:
SHL RAX,0x20
MOV ESI,EBX
OR RSI,RAX
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011ccb2
XOR EBX,EBX
XOR EAX,EAX
MOV EBP,0x6
LAB_00180c58:
OR RBX,RAX
MOV RAX,RBX
MOV RDX,RBP
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00180c70:
MOV dword ptr [RSP + 0x1c],EBP
MOV RCX,qword ptr [RBX + 0x18]
CMP ECX,0x3
JZ 0x00180ca6
MOV RDX,qword ptr [RBX + 0x10]
MOV dword ptr [RSP],EBP
LEA RSI,[RSP + 0x1c]
XOR EBX,EBX
MOV RDI,R14
XOR R8D,R8D
MOV R9D,EBP
CALL 0x00126b42
MOV EDX,0x3
TEST EAX,EAX
JZ 0x00180ca6
XOR EAX,EAX
JMP 0x00180c3d
LAB_00180ca6:
MOV EBX,dword ptr [RSP + 0x1c]
MOV ECX,dword ptr [RSP + 0x3c]
MOV qword ptr [RSP + 0x30],RCX
SUB EBX,ECX
XOR EAX,EAX
TEST EBX,EBX
CMOVG EAX,EBX
LEA RDX,[RSP + 0x50]
MOV qword ptr [RDX],R12
MOV qword ptr [RDX + 0x8],R15
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RDX + 0x10],RAX
MOV qword ptr [RDX + 0x18],0x0
MOV RDI,R14
MOV ESI,0x2
CALL 0x0017738d
MOV RCX,RAX
SHR RAX,0x20
CMP EDX,0x6
JNZ 0x00180cfa
MOV RBX,RCX
JMP 0x00180c3d
LAB_00180cfa:
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x10],RDX
TEST EBX,EBX
MOV RBX,RCX
JLE 0x00180e2a
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x00181ff3
TEST EAX,EAX
JNZ 0x00180d35
MOV RDI,R14
MOV RSI,RBX
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x00181ff3
TEST EAX,EAX
JZ 0x00180d44
LAB_00180d35:
MOV RDX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x20]
JMP 0x00180c3d
LAB_00180d44:
CMP EBP,dword ptr [R13 + 0x40]
JNZ 0x00180da9
MOV RDI,R14
MOV RSI,RBX
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x00138a76
TEST RAX,RAX
JZ 0x00180da9
MOVZX EDX,word ptr [R13 + 0x6]
MOVZX ECX,word ptr [RAX + 0x6]
CMP DX,CX
JNZ 0x00180da9
MOV RDI,qword ptr [RAX + 0x30]
LEA RSI,[0x19c1cf]
MOV CL,byte ptr [RCX + RSI*0x1 + -0x15]
MOV EDI,dword ptr [RDI + 0x24]
SHR EDI,CL
CMP EDI,dword ptr [RSP + 0x28]
JC 0x00180da9
MOV RDI,qword ptr [R13 + 0x30]
MOVZX ECX,byte ptr [RDX + RSI*0x1 + -0x15]
MOV EDX,dword ptr [RDI + 0x24]
SHR EDX,CL
MOV RSI,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RSP + 0x28]
ADD ESI,EDI
CMP EDX,ESI
JNC 0x00180e46
LAB_00180da9:
MOV EBP,dword ptr [R13 + 0x40]
SUB EBP,dword ptr [RSP + 0x30]
TEST EBP,EBP
JLE 0x00180e2a
MOV RAX,qword ptr [RSP + 0x28]
CMP EAX,EBP
CMOVL EBP,EAX
CMP EBP,0x1
ADC EBP,0x0
XOR R13D,R13D
LAB_00180dc8:
MOV RAX,qword ptr [RSP + 0x30]
LEA ECX,[RAX + R13*0x1]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
XOR R8D,R8D
CALL 0x0013f219
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
CMP EDX,0x6
JZ 0x00180d35
MOVUPS XMM0,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R14
MOV RSI,RBX
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,R13
XOR R8D,R8D
MOV R9D,0x4000
CALL 0x00124145
TEST EAX,EAX
JS 0x00180d35
INC R13
CMP RBP,R13
JNZ 0x00180dc8
LAB_00180e2a:
MOV RCX,-0x100000000
MOV RAX,RBX
AND RAX,RCX
MOV EBX,EBX
MOV RBP,qword ptr [RSP + 0x10]
JMP 0x00180c58
LAB_00180e46:
MOV RDI,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RSP + 0x30]
SHL EAX,CL
MOVSXD RSI,EAX
ADD RSI,qword ptr [R13 + 0x38]
MOV RAX,qword ptr [RSP + 0x28]
SHL EAX,CL
MOVSXD RDX,EAX
CALL 0x0010e710
JMP 0x00180e2a
|
int1 [16]
js_typed_array_slice
(long param_1,long param_2,int8 param_3,int8 param_4,int8 *param_5)
{
byte bVar1;
int iVar2;
int iVar3;
ulong uVar4;
long lVar5;
uint uVar6;
ulong uVar7;
int8 uVar8;
long lVar9;
ulong uVar10;
int1 auVar11 [16];
int1 auVar12 [16];
int local_8c;
ulong local_88;
ulong local_80;
ulong local_78;
uint local_6c;
int1 local_68 [16];
long local_58;
int8 local_50;
ulong local_48;
int8 local_40;
local_58 = param_2;
if (((int)param_3 != -1) || (lVar9 = param_2, 0xb < (ushort)(*(short *)(param_2 + 6) - 0x15U))) {
lVar9 = 0;
JS_ThrowTypeError(param_1,"not a TypedArray");
}
uVar8 = 6;
if (lVar9 != 0) {
iVar2 = typed_array_is_oob(lVar9);
if (iVar2 == 0) {
iVar2 = *(int *)(lVar9 + 0x40);
iVar3 = JS_ToInt32Clamp(param_1,&local_6c,*param_5,param_5[1],0,iVar2,iVar2);
if (iVar3 == 0) {
local_8c = iVar2;
if ((int)param_5[3] != 3) {
iVar3 = JS_ToInt32Clamp(param_1,&local_8c,param_5[2],param_5[3],0,iVar2,iVar2);
auVar11 = ZEXT816(3) << 0x40;
if (iVar3 != 0) {
uVar4 = 0;
goto LAB_00180c3d;
}
}
local_78 = (ulong)local_6c;
uVar6 = local_8c - local_6c;
local_80 = 0;
if (0 < (int)uVar6) {
local_80 = (ulong)uVar6;
}
local_40 = 0;
local_58 = param_2;
local_50 = param_3;
local_48 = local_80;
auVar11 = js_typed_array___speciesCreate(param_1,2);
uVar8 = auVar11._8_8_;
uVar7 = auVar11._0_8_;
uVar4 = uVar7 >> 0x20;
if (auVar11._8_4_ != 6) {
if ((int)uVar6 < 1) {
LAB_00180e2a:
uVar4 = uVar7 & 0xffffffff00000000;
uVar7 = uVar7 & 0xffffffff;
goto LAB_00180c58;
}
local_88 = uVar4;
iVar3 = validate_typed_array(param_1,param_2,param_3);
uVar4 = local_88;
if (iVar3 == 0) {
iVar3 = validate_typed_array(param_1,uVar7,uVar8);
uVar4 = local_88;
if (iVar3 == 0) {
if ((iVar2 == *(int *)(lVar9 + 0x40)) &&
(lVar5 = get_typed_array(param_1,uVar7,uVar8), lVar5 != 0)) {
if ((*(ushort *)(lVar9 + 6) == *(ushort *)(lVar5 + 6)) &&
((uint)local_80 <=
*(uint *)(*(long *)(lVar5 + 0x30) + 0x24) >>
("toSorted"[(ulong)*(ushort *)(lVar5 + 6) + 6] & 0x1fU))) {
bVar1 = "toSorted"[(ulong)*(ushort *)(lVar9 + 6) + 6];
if ((int)local_78 + (uint)local_80 <=
*(uint *)(*(long *)(lVar9 + 0x30) + 0x24) >> (bVar1 & 0x1f)) {
memmove(*(void **)(lVar5 + 0x38),
(void *)((long)((int)local_78 << (bVar1 & 0x1f)) +
*(long *)(lVar9 + 0x38)),
(long)(int)((uint)local_80 << (bVar1 & 0x1f)));
goto LAB_00180e2a;
}
}
}
iVar2 = *(int *)(lVar9 + 0x40) - (int)local_78;
if (0 < iVar2) {
if ((int)local_80 < iVar2) {
iVar2 = (int)local_80;
}
uVar10 = 0;
do {
auVar12 = JS_GetPropertyValue(param_1,param_2,param_3,(int)local_78 + (int)uVar10,
0);
uVar4 = local_88;
local_68 = auVar12;
if (auVar12._8_4_ == 6) goto LAB_00180c3d;
local_68._0_4_ = auVar12._0_4_;
iVar3 = JS_SetPropertyValue(param_1,uVar7,uVar8,uVar10,0,0x4000,local_68._0_4_,
auVar12._8_4_);
local_68 = auVar12;
uVar4 = local_88;
if (iVar3 < 0) goto LAB_00180c3d;
uVar10 = uVar10 + 1;
} while (iVar2 + (uint)(iVar2 == 0) != uVar10);
}
goto LAB_00180e2a;
}
}
}
}
else {
auVar11 = ZEXT816(3) << 0x40;
uVar4 = 0;
}
LAB_00180c3d:
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar11._0_8_ & 0xffffffff | uVar4 << 0x20,
auVar11._8_8_);
uVar7 = 0;
uVar4 = 0;
uVar8 = 6;
goto LAB_00180c58;
}
JS_ThrowTypeError(param_1,"ArrayBuffer is detached or resized");
}
uVar7 = 0;
uVar4 = 0;
LAB_00180c58:
auVar11._8_8_ = uVar8;
auVar11._0_8_ = uVar7 | uVar4;
return auVar11;
}
|
|
10,804 |
stbi_is_hdr_from_memory
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
{
#ifndef STBI_NO_HDR
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__hdr_test(&s);
#else
STBI_NOTUSED(buffer);
STBI_NOTUSED(len);
return 0;
#endif
}
|
O0
|
c
|
stbi_is_hdr_from_memory:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movl %esi, 0xec(%rsp)
movq 0xf0(%rsp), %rsi
movl 0xec(%rsp), %edx
leaq 0x8(%rsp), %rdi
callq 0xe3b0
leaq 0x8(%rsp), %rdi
callq 0xf080
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
|
stbi_is_hdr_from_memory:
sub rsp, 0F8h
mov [rsp+0F8h+var_8], rdi
mov [rsp+0F8h+var_C], esi
mov rsi, [rsp+0F8h+var_8]
mov edx, [rsp+0F8h+var_C]
lea rdi, [rsp+0F8h+var_F0]
call _ZL15stbi__start_memP13stbi__contextPKhi; stbi__start_mem(stbi__context *,uchar const*,int)
lea rdi, [rsp+0F8h+var_F0]
call _ZL14stbi__hdr_testP13stbi__context; stbi__hdr_test(stbi__context *)
add rsp, 0F8h
retn
|
long long stbi_is_hdr_from_memory(long long a1, int a2)
{
_BYTE v3[228]; // [rsp+8h] [rbp-F0h] BYREF
int v4; // [rsp+ECh] [rbp-Ch]
long long v5; // [rsp+F0h] [rbp-8h]
v5 = a1;
v4 = a2;
stbi__start_mem((long long)v3, a1, a2);
return stbi__hdr_test(v3);
}
|
stbi_is_hdr_from_memory:
SUB RSP,0xf8
MOV qword ptr [RSP + 0xf0],RDI
MOV dword ptr [RSP + 0xec],ESI
MOV RSI,qword ptr [RSP + 0xf0]
MOV EDX,dword ptr [RSP + 0xec]
LEA RDI,[RSP + 0x8]
CALL 0x0010e3b0
LEA RDI,[RSP + 0x8]
CALL 0x0010f080
ADD RSP,0xf8
RET
|
void stbi_is_hdr_from_memory(uchar *param_1,int param_2)
{
stbi__context local_f0 [228];
int local_c;
uchar *local_8;
local_c = param_2;
local_8 = param_1;
stbi__start_mem(local_f0,param_1,param_2);
stbi__hdr_test(local_f0);
return;
}
|
|
10,805 |
stbi_is_hdr_from_memory
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
{
#ifndef STBI_NO_HDR
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__hdr_test(&s);
#else
STBI_NOTUSED(buffer);
STBI_NOTUSED(len);
return 0;
#endif
}
|
O2
|
c
|
stbi_is_hdr_from_memory:
subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
andq $0x0, 0x10(%rax)
andl $0x0, 0x30(%rax)
andl $0x0, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rcx
addq %rdi, %rcx
movq %rcx, 0xd8(%rax)
movq %rcx, 0xc8(%rax)
movq %rax, %rdi
callq 0xc83e
addq $0xe8, %rsp
retq
|
stbi_is_hdr_from_memory:
sub rsp, 0E8h
lea rax, [rsp+0E8h+var_E0]
and qword ptr [rax+10h], 0
and dword ptr [rax+30h], 0
and dword ptr [rax+0B8h], 0
mov [rax+0D0h], rdi
mov [rax+0C0h], rdi
movsxd rcx, esi
add rcx, rdi
mov [rax+0D8h], rcx
mov [rax+0C8h], rcx
mov rdi, rax
call _ZL14stbi__hdr_testP13stbi__context; stbi__hdr_test(stbi__context *)
add rsp, 0E8h
retn
|
long long stbi_is_hdr_from_memory(long long a1, int a2)
{
_BYTE v3[16]; // [rsp+8h] [rbp-E0h] BYREF
long long v4; // [rsp+18h] [rbp-D0h]
int v5; // [rsp+38h] [rbp-B0h]
int v6; // [rsp+C0h] [rbp-28h]
long long v7; // [rsp+C8h] [rbp-20h]
long long v8; // [rsp+D0h] [rbp-18h]
long long v9; // [rsp+D8h] [rbp-10h]
long long v10; // [rsp+E0h] [rbp-8h]
v4 = 0LL;
v5 = 0;
v6 = 0;
v9 = a1;
v7 = a1;
v10 = a1 + a2;
v8 = v10;
return stbi__hdr_test(v3);
}
|
stbi_is_hdr_from_memory:
SUB RSP,0xe8
LEA RAX,[RSP + 0x8]
AND qword ptr [RAX + 0x10],0x0
AND dword ptr [RAX + 0x30],0x0
AND dword ptr [RAX + 0xb8],0x0
MOV qword ptr [RAX + 0xd0],RDI
MOV qword ptr [RAX + 0xc0],RDI
MOVSXD RCX,ESI
ADD RCX,RDI
MOV qword ptr [RAX + 0xd8],RCX
MOV qword ptr [RAX + 0xc8],RCX
MOV RDI,RAX
CALL 0x0010c83e
ADD RSP,0xe8
RET
|
void stbi_is_hdr_from_memory(long param_1,int param_2)
{
stbi__context local_e0 [16];
int8 local_d0;
int4 local_b0;
int4 local_28;
long local_20;
long local_18;
long local_10;
long local_8;
local_d0 = 0;
local_b0 = 0;
local_28 = 0;
local_18 = param_2 + param_1;
local_20 = param_1;
local_10 = param_1;
local_8 = local_18;
stbi__hdr_test(local_e0);
return;
}
|
|
10,806 |
stbi_is_hdr_from_memory
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
{
#ifndef STBI_NO_HDR
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__hdr_test(&s);
#else
STBI_NOTUSED(buffer);
STBI_NOTUSED(len);
return 0;
#endif
}
|
O3
|
c
|
stbi_is_hdr_from_memory:
subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movl %ecx, 0x30(%rax)
movl %ecx, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rcx
addq %rdi, %rcx
movq %rcx, 0xd8(%rax)
movq %rcx, 0xc8(%rax)
movq %rax, %rdi
callq 0x1a809
addq $0xe8, %rsp
retq
|
stbi_is_hdr_from_memory:
sub rsp, 0E8h
lea rax, [rsp+0E8h+var_E0]
mov qword ptr [rax+10h], 0
xor ecx, ecx
mov [rax+30h], ecx
mov [rax+0B8h], ecx
mov [rax+0D0h], rdi
mov [rax+0C0h], rdi
movsxd rcx, esi
add rcx, rdi
mov [rax+0D8h], rcx
mov [rax+0C8h], rcx
mov rdi, rax
call _ZL14stbi__hdr_testP13stbi__context; stbi__hdr_test(stbi__context *)
add rsp, 0E8h
retn
|
long long stbi_is_hdr_from_memory(long long a1, int a2)
{
_BYTE v3[16]; // [rsp+8h] [rbp-E0h] BYREF
long long v4; // [rsp+18h] [rbp-D0h]
int v5; // [rsp+38h] [rbp-B0h]
int v6; // [rsp+C0h] [rbp-28h]
long long v7; // [rsp+C8h] [rbp-20h]
long long v8; // [rsp+D0h] [rbp-18h]
long long v9; // [rsp+D8h] [rbp-10h]
long long v10; // [rsp+E0h] [rbp-8h]
v4 = 0LL;
v5 = 0;
v6 = 0;
v9 = a1;
v7 = a1;
v10 = a1 + a2;
v8 = v10;
return stbi__hdr_test(v3);
}
| |||
10,807 |
mi_restore_status
|
eloqsql/storage/myisam/mi_locking.c
|
void mi_restore_status(void *param)
{
MI_INFO *info= (MI_INFO*) param;
DBUG_ENTER("mi_restore_status");
DBUG_PRINT("info",("key_file: %ld data_file: %ld",
(long) info->s->state.state.key_file_length,
(long) info->s->state.state.data_file_length));
info->state= &info->s->state.state;
info->append_insert_at_end= 0;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
mi_restore_status:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xb03b2
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x33a(%rax)
jmp 0xb03d2
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mi_restore_status:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
jmp short $+2
loc_B03B2:
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 18h
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov byte ptr [rax+33Ah], 0
jmp short $+2
loc_B03D2:
pop rbp
retn
|
long long mi_restore_status(long long a1)
{
long long result; // rax
*(_QWORD *)(a1 + 8) = *(_QWORD *)a1 + 24LL;
result = a1;
*(_BYTE *)(a1 + 826) = 0;
return result;
}
|
mi_restore_status:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001b03b2
LAB_001b03b2:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33a],0x0
JMP 0x001b03d2
LAB_001b03d2:
POP RBP
RET
|
void mi_restore_status(long *param_1)
{
param_1[1] = *param_1 + 0x18;
*(int1 *)((long)param_1 + 0x33a) = 0;
return;
}
|
|
10,808 |
nlohmann::json_abi_v3_11_3::detail::out_of_range nlohmann::json_abi_v3_11_3::detail::out_of_range::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t)
|
zkingston[P]unknot/build_O1/_deps/json-src/include/nlohmann/detail/exceptions.hpp
|
static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::out_of_range nlohmann::json_abi_v3_11_3::detail::out_of_range::create<std::nullptr_t, 0>(int, 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 $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x25bdf7(%rip), %rsi # 0x29118a
leaq 0x25bdfc(%rip), %rdx # 0x291196
leaq 0x28(%rsp), %rdi
callq 0x1a83c
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x2b466
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq 0x8(%r15), %rsi
addq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xffe0
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0xf2b0
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0xf2b0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0xf2b0
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x3543d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xfa70
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35458
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xfa70
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x3546f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xfa70
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2b6ce
leaq 0x2fe663(%rip), %rax # 0x333ae8
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3549f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xfa70
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3552d
movq 0x18(%rsp), %rsi
jmp 0x35525
movq %rax, %rbx
jmp 0x35516
movq %rax, %rbx
jmp 0x3552d
movq %rdx, %rbx
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x354ef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xfa70
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0x88(%rsp), %r12
movq %r14, %rsi
movq %r15, %rcx
movl %ebx, %r8d
movq %r12, %r9
callq 0x10dec
movq (%r12), %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x3552d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xfa70
movq %rbx, %rdi
callq 0x101c0
|
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov r15, rdx
mov ebp, esi
mov rbx, rdi
lea r13, [rsp+0C8h+var_90]
mov [r13-10h], r13
lea rsi, aOutOfRange; "out_of_range"
lea rdx, aOutOfRange+0Ch; ""
lea rdi, [rsp+0C8h+var_A0]
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+0C8h+var_80]; int
lea rsi, [rsp+0C8h+var_A0]; 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 r14, [rsp+0C8h+var_50]
mov [r14-10h], r14
xor eax, eax
mov [r14-8], rax
mov [r14], al
lea r12, [rsp+0C8h+var_B0]
mov [r12-10h], r12
mov [r12-8], rax
mov [r12], al
mov rsi, [r15+8]
add rsi, [rsp+0C8h+var_78]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rsi, qword ptr [rsp+0C8h+var_80]
mov rdx, [rsp+0C8h+var_78]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rsi, [rsp+0C8h+var_60]
mov rdx, [rsp+0C8h+var_58]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rsi, [r15]
mov rdx, [r15+8]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+0C8h+var_60]; void *
cmp rdi, r14
jz short loc_3543D
mov rsi, [rsp+0C8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3543D:
lea rax, [rsp+0C8h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_35458
mov rsi, [rsp+0C8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_35458:
mov rdi, [rsp+0C8h+var_A0]; void *
cmp rdi, r13
jz short loc_3546F
mov rsi, [rsp+0C8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3546F:
mov rdx, [rsp+0C8h+var_C0]; 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_333AE8
mov [rbx], rax
mov rdi, [rsp+0C8h+var_C0]; void *
cmp rdi, r12
jz short loc_3549F
mov rsi, [rsp+0C8h+var_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3549F:
mov rax, rbx
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
cmp rdi, r12
jz short loc_3552D
mov rsi, [rsp+arg_10]
jmp short loc_35525
mov rbx, rax
jmp short loc_35516
mov rbx, rax
jmp short loc_3552D
mov rbx, rdx
mov r15, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_354EF
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_354EF:
lea rdi, [rsp+arg_60]
lea rdx, [rsp+arg_40]
lea r12, [rsp+arg_80]
mov rsi, r14
mov rcx, r15
mov r8d, ebx
mov r9, r12
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ__cold_1
mov rbx, [r12]
loc_35516:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_3552D
mov rsi, [rsp+arg_30]
loc_35525:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3552D:
mov rdi, rbx
call __Unwind_Resume
|
nlohmann::json_abi_v3_11_3::detail::exception * ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
nlohmann::json_abi_v3_11_3::detail::exception *this,
int a2,
_QWORD *a3)
{
char *v5[2]; // [rsp+8h] [rbp-C0h] BYREF
_QWORD v6[2]; // [rsp+18h] [rbp-B0h] BYREF
void *v7[2]; // [rsp+28h] [rbp-A0h] BYREF
_QWORD v8[2]; // [rsp+38h] [rbp-90h] BYREF
int v9[2]; // [rsp+48h] [rbp-80h] BYREF
long long v10; // [rsp+50h] [rbp-78h]
long long v11; // [rsp+58h] [rbp-70h] BYREF
void *v12; // [rsp+68h] [rbp-60h]
long long v13; // [rsp+70h] [rbp-58h]
_QWORD v14[10]; // [rsp+78h] [rbp-50h] BYREF
v7[0] = v8;
std::string::_M_construct<char const*>(v7, "out_of_range", (long long)"");
nlohmann::json_abi_v3_11_3::detail::exception::name((long long)v9, (long long)v7, a2);
v12 = v14;
v13 = 0LL;
LOBYTE(v14[0]) = 0;
v5[0] = (char *)v6;
v5[1] = 0LL;
LOBYTE(v6[0]) = 0;
std::string::reserve(v5, v10 + a3[1]);
std::string::_M_append(v5, *(_QWORD *)v9, v10);
std::string::_M_append(v5, v12, v13);
std::string::_M_append(v5, *a3, a3[1]);
if ( v12 != v14 )
operator delete(v12, v14[0] + 1LL);
if ( *(long long **)v9 != &v11 )
operator delete(*(void **)v9, v11 + 1);
if ( v7[0] != v8 )
operator delete(v7[0], v8[0] + 1LL);
nlohmann::json_abi_v3_11_3::detail::exception::exception(this, a2, v5[0]);
*(_QWORD *)this = off_333AE8;
if ( (_QWORD *)v5[0] != v6 )
operator delete(v5[0], v6[0] + 1LL);
return this;
}
|
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV R15,RDX
MOV EBP,ESI
MOV RBX,RDI
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
LAB_0013538c:
LEA RSI,[0x39118a]
LEA RDX,[0x391196]
LEA RDI,[RSP + 0x28]
CALL 0x0011a83c
LAB_001353a4:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x28]
MOV EDX,EBP
CALL 0x0012b466
LEA R14,[RSP + 0x78]
MOV qword ptr [R14 + -0x10],R14
XOR EAX,EAX
MOV qword ptr [R14 + -0x8],RAX
MOV byte ptr [R14],AL
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
MOV qword ptr [R12 + -0x8],RAX
MOV byte ptr [R12],AL
MOV RSI,qword ptr [R15 + 0x8]
ADD RSI,qword ptr [RSP + 0x50]
LAB_001353e3:
LEA RDI,[RSP + 0x8]
CALL 0x0010ffe0
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
LEA RDI,[RSP + 0x8]
CALL 0x0010f2b0
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
LEA RDI,[RSP + 0x8]
CALL 0x0010f2b0
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LEA RDI,[RSP + 0x8]
CALL 0x0010f2b0
MOV RDI,qword ptr [RSP + 0x68]
CMP RDI,R14
JZ 0x0013543d
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x0010fa70
LAB_0013543d:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00135458
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0010fa70
LAB_00135458:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x0013546f
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0010fa70
LAB_0013546f:
MOV RDX,qword ptr [RSP + 0x8]
LAB_00135474:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0012b6ce
LAB_0013547e:
LEA RAX,[0x433ae8]
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x0013549f
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0010fa70
LAB_0013549f:
MOV RAX,RBX
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
exception *
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(exception *param_1,int param_2,ulong *param_3)
{
char *local_c0;
int8 local_b8;
char local_b0;
int7 uStack_af;
long *local_a0 [2];
long local_90 [2];
long *local_80 [2];
long local_70 [2];
int1 *local_60;
int8 local_58;
int1 local_50;
int7 uStack_4f;
/* try { // try from 0013538c to 001353a3 has its CatchHandler @ 001354cd */
local_a0[0] = local_90;
std::__cxx11::string::_M_construct<char_const*>(local_a0,"out_of_range","");
/* try { // try from 001353a4 to 001353b4 has its CatchHandler @ 001354c8 */
nlohmann::json_abi_v3_11_3::detail::exception::name
((exception *)local_80,(string *)local_a0,param_2);
local_58 = 0;
local_50 = 0;
local_b8 = 0;
local_b0 = '\0';
/* try { // try from 001353e3 to 00135425 has its CatchHandler @ 001354d2 */
local_c0 = &local_b0;
local_60 = &local_50;
std::__cxx11::string::reserve((ulong)&local_c0);
std::__cxx11::string::_M_append((char *)&local_c0,(ulong)local_80[0]);
std::__cxx11::string::_M_append((char *)&local_c0,(ulong)local_60);
std::__cxx11::string::_M_append((char *)&local_c0,*param_3);
if (local_60 != &local_50) {
operator_delete(local_60,CONCAT71(uStack_4f,local_50) + 1);
}
if (local_80[0] != local_70) {
operator_delete(local_80[0],local_70[0] + 1);
}
if (local_a0[0] != local_90) {
operator_delete(local_a0[0],local_90[0] + 1);
}
/* try { // try from 00135474 to 0013547d has its CatchHandler @ 001354b4 */
nlohmann::json_abi_v3_11_3::detail::exception::exception(param_1,param_2,local_c0);
*(int ***)param_1 = &PTR__exception_00433ae8;
if (local_c0 != &local_b0) {
operator_delete(local_c0,CONCAT71(uStack_af,local_b0) + 1);
}
return param_1;
}
|
|
10,809 |
downheap
|
eloqsql/mysys/queues.c
|
void _downheap(QUEUE *queue, uint idx)
{
uchar *element= queue->root[idx];
uint next_index,
elements= queue->elements,
half_queue= elements >> 1,
offset_to_key= queue->offset_to_key,
offset_to_queue_pos= queue->offset_to_queue_pos;
while (idx <= half_queue)
{
next_index= idx+idx;
if (next_index < elements &&
(queue->compare(queue->first_cmp_arg,
queue->root[next_index]+offset_to_key,
queue->root[next_index+1]+offset_to_key) *
queue->max_at_top) > 0)
next_index++;
if ((queue->compare(queue->first_cmp_arg,
queue->root[next_index]+offset_to_key,
element+offset_to_key) * queue->max_at_top) >= 0)
break;
queue->root[idx]= queue->root[next_index];
if (offset_to_queue_pos)
(*(uint*) (queue->root[idx] + offset_to_queue_pos-1))= idx;
idx= next_index;
}
queue->root[idx]=element;
if (offset_to_queue_pos)
(*(uint*) (element + offset_to_queue_pos-1))= idx;
}
|
O0
|
c
|
downheap:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
shrl %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x24(%rbp), %eax
ja 0xfdfbd
movl -0xc(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0xfdf39
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
movq (%rcx,%rdx,8), %rsi
movl -0x28(%rbp), %ecx
addq %rcx, %rsi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movl %edx, %edx
movq (%rcx,%rdx,8), %rdx
movl -0x28(%rbp), %ecx
addq %rcx, %rdx
callq *%rax
movq -0x8(%rbp), %rcx
imull 0x24(%rcx), %eax
cmpl $0x0, %eax
jle 0xfdf39
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
movq (%rcx,%rdx,8), %rsi
movl -0x28(%rbp), %ecx
addq %rcx, %rsi
movq -0x18(%rbp), %rdx
movl -0x28(%rbp), %ecx
addq %rcx, %rdx
callq *%rax
movq -0x8(%rbp), %rcx
imull 0x24(%rcx), %eax
cmpl $0x0, %eax
jl 0xfdf78
jmp 0xfdfbd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x2c(%rbp)
je 0xfdfb2
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x2c(%rbp), %ecx
movl %edx, -0x1(%rax,%rcx)
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xfdec7
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x2c(%rbp)
je 0xfdfe3
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %edx, -0x1(%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
_downheap:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_C]
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov eax, [rax+10h]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
shr eax, 1
mov [rbp+var_24], eax
mov rax, [rbp+var_8]
mov eax, [rax+18h]
mov [rbp+var_28], eax
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
mov [rbp+var_2C], eax
loc_FDEC7:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_24]
ja loc_FDFBD
mov eax, [rbp+var_C]
add eax, [rbp+var_C]
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jnb short loc_FDF39
mov rax, [rbp+var_8]
mov rax, [rax+28h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov edx, [rbp+var_1C]
mov rsi, [rcx+rdx*8]
mov ecx, [rbp+var_28]
add rsi, rcx
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov edx, [rbp+var_1C]
add edx, 1
mov edx, edx
mov rdx, [rcx+rdx*8]
mov ecx, [rbp+var_28]
add rdx, rcx
call rax
mov rcx, [rbp+var_8]
imul eax, [rcx+24h]
cmp eax, 0
jle short loc_FDF39
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
loc_FDF39:
mov rax, [rbp+var_8]
mov rax, [rax+28h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov edx, [rbp+var_1C]
mov rsi, [rcx+rdx*8]
mov ecx, [rbp+var_28]
add rsi, rcx
mov rdx, [rbp+var_18]
mov ecx, [rbp+var_28]
add rdx, rcx
call rax
mov rcx, [rbp+var_8]
imul eax, [rcx+24h]
cmp eax, 0
jl short loc_FDF78
jmp short loc_FDFBD
loc_FDF78:
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_1C]
mov rdx, [rax+rcx*8]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_C]
mov [rax+rcx*8], rdx
cmp [rbp+var_2C], 0
jz short loc_FDFB2
mov edx, [rbp+var_C]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_C]
mov rax, [rax+rcx*8]
mov ecx, [rbp+var_2C]
mov [rax+rcx-1], edx
loc_FDFB2:
mov eax, [rbp+var_1C]
mov [rbp+var_C], eax
jmp loc_FDEC7
loc_FDFBD:
mov rdx, [rbp+var_18]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_C]
mov [rax+rcx*8], rdx
cmp [rbp+var_2C], 0
jz short loc_FDFE3
mov edx, [rbp+var_C]
mov rax, [rbp+var_18]
mov ecx, [rbp+var_2C]
mov [rax+rcx-1], edx
loc_FDFE3:
add rsp, 30h
pop rbp
retn
|
long long downheap(long long *a1, unsigned int a2)
{
long long result; // rax
unsigned int v3; // [rsp+4h] [rbp-2Ch]
unsigned int v4; // [rsp+8h] [rbp-28h]
unsigned int v5; // [rsp+10h] [rbp-20h]
unsigned int v6; // [rsp+14h] [rbp-1Ch]
long long v7; // [rsp+18h] [rbp-18h]
unsigned int v8; // [rsp+24h] [rbp-Ch]
v8 = a2;
v7 = *(_QWORD *)(*a1 + 8LL * a2);
v5 = *((_DWORD *)a1 + 4);
v4 = *((_DWORD *)a1 + 6);
v3 = *((_DWORD *)a1 + 7);
while ( v8 <= v5 >> 1 )
{
v6 = 2 * v8;
if ( 2 * v8 < v5
&& (int)(*((_DWORD *)a1 + 9)
* ((long long ( *)(long long, _QWORD, _QWORD))a1[5])(
a1[1],
v4 + *(_QWORD *)(*a1 + 8LL * v6),
v4 + *(_QWORD *)(*a1 + 8LL * (v6 + 1)))) > 0 )
{
++v6;
}
if ( (int)(*((_DWORD *)a1 + 9)
* ((long long ( *)(long long, _QWORD, long long))a1[5])(
a1[1],
v4 + *(_QWORD *)(*a1 + 8LL * v6),
v4 + v7)) >= 0 )
break;
*(_QWORD *)(*a1 + 8LL * v8) = *(_QWORD *)(*a1 + 8LL * v6);
if ( v3 )
*(_DWORD *)(*(_QWORD *)(*a1 + 8LL * v8) + v3 - 1LL) = v8;
v8 = v6;
}
result = *a1;
*(_QWORD *)(*a1 + 8LL * v8) = v7;
if ( v3 )
{
result = v7;
*(_DWORD *)(v7 + v3 - 1) = v8;
}
return result;
}
|
_downheap:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
SHR EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x2c],EAX
LAB_001fdec7:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x24]
JA 0x001fdfbd
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JNC 0x001fdf39
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
MOV EDX,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV ECX,dword ptr [RBP + -0x28]
ADD RSI,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
MOV EDX,dword ptr [RBP + -0x1c]
ADD EDX,0x1
MOV EDX,EDX
MOV RDX,qword ptr [RCX + RDX*0x8]
MOV ECX,dword ptr [RBP + -0x28]
ADD RDX,RCX
CALL RAX
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x24]
CMP EAX,0x0
JLE 0x001fdf39
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
LAB_001fdf39:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
MOV EDX,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV ECX,dword ptr [RBP + -0x28]
ADD RSI,RCX
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x28]
ADD RDX,RCX
CALL RAX
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x24]
CMP EAX,0x0
JL 0x001fdf78
JMP 0x001fdfbd
LAB_001fdf78:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
MOV qword ptr [RAX + RCX*0x8],RDX
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x001fdfb2
MOV EDX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV ECX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX + RCX*0x1 + -0x1],EDX
LAB_001fdfb2:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001fdec7
LAB_001fdfbd:
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
MOV qword ptr [RAX + RCX*0x8],RDX
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x001fdfe3
MOV EDX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX + RCX*0x1 + -0x1],EDX
LAB_001fdfe3:
ADD RSP,0x30
POP RBP
RET
|
void _downheap(long *param_1,uint param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
long lVar4;
int iVar5;
uint local_24;
uint local_14;
lVar4 = *(long *)(*param_1 + (ulong)param_2 * 8);
uVar1 = *(uint *)(param_1 + 2);
uVar2 = *(uint *)(param_1 + 3);
uVar3 = *(uint *)((long)param_1 + 0x1c);
local_14 = param_2;
while (local_14 <= uVar1 >> 1) {
local_24 = local_14 * 2;
if ((local_24 < uVar1) &&
(iVar5 = (*(code *)param_1[5])
(param_1[1],*(long *)(*param_1 + (ulong)local_24 * 8) + (ulong)uVar2,
*(long *)(*param_1 + (ulong)(local_24 + 1) * 8) + (ulong)uVar2),
0 < iVar5 * *(int *)((long)param_1 + 0x24))) {
local_24 = local_24 + 1;
}
iVar5 = (*(code *)param_1[5])
(param_1[1],*(long *)(*param_1 + (ulong)local_24 * 8) + (ulong)uVar2,
lVar4 + (ulong)uVar2);
if (-1 < iVar5 * *(int *)((long)param_1 + 0x24)) break;
*(int8 *)(*param_1 + (ulong)local_14 * 8) =
*(int8 *)(*param_1 + (ulong)local_24 * 8);
if (uVar3 != 0) {
*(uint *)(*(long *)(*param_1 + (ulong)local_14 * 8) + -1 + (ulong)uVar3) = local_14;
}
local_14 = local_24;
}
*(long *)(*param_1 + (ulong)local_14 * 8) = lVar4;
if (uVar3 != 0) {
*(uint *)(lVar4 + -1 + (ulong)uVar3) = local_14;
}
return;
}
|
|
10,810 |
LefDefParser::defiNonDefault::addProperty(char const*, char const*, char)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNonDefault.cpp
|
void defiNonDefault::addProperty(const char* name, const char* value,
const char type) {
int len = strlen(name) + 1;
if (numProps_ == propsAllocated_) {
int i;
int max;
int lim = numProps_;
char** nn;
char** nv;
double* nd;
char* nt;
if (propsAllocated_ == 0)
max = propsAllocated_ = 2;
else
max = propsAllocated_ *= 2;
nn = (char**)malloc(sizeof(char*) * max);
nv = (char**)malloc(sizeof(char*) * max);
nd = (double*)malloc(sizeof(double) * max);
nt = (char*)malloc(sizeof(char) * max);
for (i = 0; i < lim; i++) {
nn[i] = names_[i];
nv[i] = values_[i];
nd[i] = dvalues_[i];
nt[i] = types_[i];
}
free((char*)(names_));
free((char*)(values_));
free((char*)(dvalues_));
free((char*)(types_));
names_ = nn;
values_ = nv;
dvalues_ = nd;
types_ = nt;
}
names_[numProps_] = (char*)malloc(sizeof(char)*len);
strcpy(names_[numProps_],name);
len = strlen(value) + 1;
values_[numProps_] = (char*)malloc(sizeof(char) * len);
strcpy(values_[numProps_],value);
dvalues_[numProps_] = 0;
types_[numProps_] = type;
numProps_ += 1;
}
|
O0
|
cpp
|
LefDefParser::defiNonDefault::addProperty(char const*, char const*, char):
subq $0x58, %rsp
movb %cl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movb %al, 0x3f(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0x70e0
movq (%rsp), %rcx
addq $0x1, %rax
movl %eax, 0x38(%rsp)
movl 0x90(%rcx), %eax
cmpl 0x94(%rcx), %eax
jne 0x45dd1
movq (%rsp), %rax
movl 0x90(%rax), %ecx
movl %ecx, 0x2c(%rsp)
cmpl $0x0, 0x94(%rax)
jne 0x45c59
movq (%rsp), %rax
movl $0x2, 0x94(%rax)
movl $0x2, 0x30(%rsp)
jmp 0x45c6f
movq (%rsp), %rcx
movl 0x94(%rcx), %eax
shll %eax
movl %eax, 0x94(%rcx)
movl %eax, 0x30(%rsp)
movslq 0x30(%rsp), %rdi
shlq $0x3, %rdi
callq 0x72d0
movq %rax, 0x20(%rsp)
movslq 0x30(%rsp), %rdi
shlq $0x3, %rdi
callq 0x72d0
movq %rax, 0x18(%rsp)
movslq 0x30(%rsp), %rdi
shlq $0x3, %rdi
callq 0x72d0
movq %rax, 0x10(%rsp)
movslq 0x30(%rsp), %rdi
shlq $0x0, %rdi
callq 0x72d0
movq %rax, 0x8(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x45d5d
movq (%rsp), %rax
movq 0x98(%rax), %rcx
movslq 0x34(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x20(%rsp), %rcx
movslq 0x34(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0xa0(%rax), %rcx
movslq 0x34(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x18(%rsp), %rcx
movslq 0x34(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0xa8(%rax), %rcx
movslq 0x34(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rsp), %rcx
movslq 0x34(%rsp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0xb0(%rax), %rax
movslq 0x34(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x8(%rsp), %rax
movslq 0x34(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x45cc3
movq (%rsp), %rax
movq 0x98(%rax), %rdi
callq 0x72a0
movq (%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x72a0
movq (%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0x72a0
movq (%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x72a0
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x98(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0xa0(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0xa8(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0xb0(%rax)
movslq 0x38(%rsp), %rdi
shlq $0x0, %rdi
callq 0x72d0
movq (%rsp), %rcx
movq %rax, %rsi
movq 0x98(%rcx), %rax
movslq 0x90(%rcx), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x98(%rcx), %rax
movslq 0x90(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x48(%rsp), %rsi
callq 0x7220
movq 0x40(%rsp), %rdi
callq 0x70e0
addq $0x1, %rax
movl %eax, 0x38(%rsp)
movslq 0x38(%rsp), %rdi
shlq $0x0, %rdi
callq 0x72d0
movq (%rsp), %rcx
movq %rax, %rsi
movq 0xa0(%rcx), %rax
movslq 0x90(%rcx), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0xa0(%rcx), %rax
movslq 0x90(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x40(%rsp), %rsi
callq 0x7220
movq (%rsp), %rax
movq 0xa8(%rax), %rcx
movslq 0x90(%rax), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movb 0x3f(%rsp), %sil
movq 0xb0(%rax), %rcx
movslq 0x90(%rax), %rdx
movb %sil, (%rcx,%rdx)
movl 0x90(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x90(%rax)
addq $0x58, %rsp
retq
nop
|
_ZN12LefDefParser14defiNonDefault11addPropertyEPKcS2_c:
sub rsp, 58h
mov al, cl
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov [rsp+58h+var_18], rdx
mov [rsp+58h+var_19], al
mov rax, [rsp+58h+var_8]
mov [rsp+58h+var_58], rax
mov rdi, [rsp+58h+var_10]
call _strlen
mov rcx, [rsp+58h+var_58]
add rax, 1
mov [rsp+58h+var_20], eax
mov eax, [rcx+90h]
cmp eax, [rcx+94h]
jnz loc_45DD1
mov rax, [rsp+58h+var_58]
mov ecx, [rax+90h]
mov [rsp+58h+var_2C], ecx
cmp dword ptr [rax+94h], 0
jnz short loc_45C59
mov rax, [rsp+58h+var_58]
mov dword ptr [rax+94h], 2
mov [rsp+58h+var_28], 2
jmp short loc_45C6F
loc_45C59:
mov rcx, [rsp+58h+var_58]
mov eax, [rcx+94h]
shl eax, 1
mov [rcx+94h], eax
mov [rsp+58h+var_28], eax
loc_45C6F:
movsxd rdi, [rsp+58h+var_28]
shl rdi, 3
call _malloc
mov [rsp+58h+var_38], rax
movsxd rdi, [rsp+58h+var_28]
shl rdi, 3
call _malloc
mov [rsp+58h+var_40], rax
movsxd rdi, [rsp+58h+var_28]
shl rdi, 3
call _malloc
mov [rsp+58h+var_48], rax
movsxd rdi, [rsp+58h+var_28]
shl rdi, 0
call _malloc
mov [rsp+58h+var_50], rax
mov [rsp+58h+var_24], 0
loc_45CC3:
mov eax, [rsp+58h+var_24]
cmp eax, [rsp+58h+var_2C]
jge loc_45D5D
mov rax, [rsp+58h+var_58]
mov rcx, [rax+98h]
movsxd rdx, [rsp+58h+var_24]
mov rsi, [rcx+rdx*8]
mov rcx, [rsp+58h+var_38]
movsxd rdx, [rsp+58h+var_24]
mov [rcx+rdx*8], rsi
mov rcx, [rax+0A0h]
movsxd rdx, [rsp+58h+var_24]
mov rsi, [rcx+rdx*8]
mov rcx, [rsp+58h+var_40]
movsxd rdx, [rsp+58h+var_24]
mov [rcx+rdx*8], rsi
mov rcx, [rax+0A8h]
movsxd rdx, [rsp+58h+var_24]
movsd xmm0, qword ptr [rcx+rdx*8]
mov rcx, [rsp+58h+var_48]
movsxd rdx, [rsp+58h+var_24]
movsd qword ptr [rcx+rdx*8], xmm0
mov rax, [rax+0B0h]
movsxd rcx, [rsp+58h+var_24]
mov dl, [rax+rcx]
mov rax, [rsp+58h+var_50]
movsxd rcx, [rsp+58h+var_24]
mov [rax+rcx], dl
mov eax, [rsp+58h+var_24]
add eax, 1
mov [rsp+58h+var_24], eax
jmp loc_45CC3
loc_45D5D:
mov rax, [rsp+58h+var_58]
mov rdi, [rax+98h]
call _free
mov rax, [rsp+58h+var_58]
mov rdi, [rax+0A0h]
call _free
mov rax, [rsp+58h+var_58]
mov rdi, [rax+0A8h]
call _free
mov rax, [rsp+58h+var_58]
mov rdi, [rax+0B0h]
call _free
mov rax, [rsp+58h+var_58]
mov rcx, [rsp+58h+var_38]
mov [rax+98h], rcx
mov rcx, [rsp+58h+var_40]
mov [rax+0A0h], rcx
mov rcx, [rsp+58h+var_48]
mov [rax+0A8h], rcx
mov rcx, [rsp+58h+var_50]
mov [rax+0B0h], rcx
loc_45DD1:
movsxd rdi, [rsp+58h+var_20]
shl rdi, 0
call _malloc
mov rcx, [rsp+58h+var_58]
mov rsi, rax
mov rax, [rcx+98h]
movsxd rdx, dword ptr [rcx+90h]
mov [rax+rdx*8], rsi
mov rax, [rcx+98h]
movsxd rcx, dword ptr [rcx+90h]
mov rdi, [rax+rcx*8]
mov rsi, [rsp+58h+var_10]
call _strcpy
mov rdi, [rsp+58h+var_18]
call _strlen
add rax, 1
mov [rsp+58h+var_20], eax
movsxd rdi, [rsp+58h+var_20]
shl rdi, 0
call _malloc
mov rcx, [rsp+58h+var_58]
mov rsi, rax
mov rax, [rcx+0A0h]
movsxd rdx, dword ptr [rcx+90h]
mov [rax+rdx*8], rsi
mov rax, [rcx+0A0h]
movsxd rcx, dword ptr [rcx+90h]
mov rdi, [rax+rcx*8]
mov rsi, [rsp+58h+var_18]
call _strcpy
mov rax, [rsp+58h+var_58]
mov rcx, [rax+0A8h]
movsxd rdx, dword ptr [rax+90h]
xorps xmm0, xmm0
movsd qword ptr [rcx+rdx*8], xmm0
mov sil, [rsp+58h+var_19]
mov rcx, [rax+0B0h]
movsxd rdx, dword ptr [rax+90h]
mov [rcx+rdx], sil
mov ecx, [rax+90h]
add ecx, 1
mov [rax+90h], ecx
add rsp, 58h
retn
|
LefDefParser::defiNonDefault * LefDefParser::defiNonDefault::addProperty(
LefDefParser::defiNonDefault *this,
const char *a2,
const char *a3,
char a4)
{
int v4; // eax
LefDefParser::defiNonDefault *result; // rax
long long v6; // [rsp+8h] [rbp-50h]
long long v7; // [rsp+10h] [rbp-48h]
long long v8; // [rsp+18h] [rbp-40h]
long long v9; // [rsp+20h] [rbp-38h]
int v10; // [rsp+2Ch] [rbp-2Ch]
int v11; // [rsp+30h] [rbp-28h]
int i; // [rsp+34h] [rbp-24h]
int v13; // [rsp+38h] [rbp-20h]
int v14; // [rsp+38h] [rbp-20h]
v13 = strlen(a2) + 1;
if ( *((_DWORD *)this + 36) == *((_DWORD *)this + 37) )
{
v10 = *((_DWORD *)this + 36);
if ( *((_DWORD *)this + 37) )
{
v4 = 2 * *((_DWORD *)this + 37);
*((_DWORD *)this + 37) = v4;
v11 = v4;
}
else
{
*((_DWORD *)this + 37) = 2;
v11 = 2;
}
v9 = malloc(8LL * v11);
v8 = malloc(8LL * v11);
v7 = malloc(8LL * v11);
v6 = malloc(v11);
for ( i = 0; i < v10; ++i )
{
*(_QWORD *)(v9 + 8LL * i) = *(_QWORD *)(*((_QWORD *)this + 19) + 8LL * i);
*(_QWORD *)(v8 + 8LL * i) = *(_QWORD *)(*((_QWORD *)this + 20) + 8LL * i);
*(_QWORD *)(v7 + 8LL * i) = *(_QWORD *)(*((_QWORD *)this + 21) + 8LL * i);
*(_BYTE *)(v6 + i) = *(_BYTE *)(*((_QWORD *)this + 22) + i);
}
free(*((_QWORD *)this + 19));
free(*((_QWORD *)this + 20));
free(*((_QWORD *)this + 21));
free(*((_QWORD *)this + 22));
*((_QWORD *)this + 19) = v9;
*((_QWORD *)this + 20) = v8;
*((_QWORD *)this + 21) = v7;
*((_QWORD *)this + 22) = v6;
}
*(_QWORD *)(*((_QWORD *)this + 19) + 8LL * *((int *)this + 36)) = malloc(v13);
strcpy(*(_QWORD *)(*((_QWORD *)this + 19) + 8LL * *((int *)this + 36)), a2);
v14 = strlen(a3) + 1;
*(_QWORD *)(*((_QWORD *)this + 20) + 8LL * *((int *)this + 36)) = malloc(v14);
strcpy(*(_QWORD *)(*((_QWORD *)this + 20) + 8LL * *((int *)this + 36)), a3);
result = this;
*(_QWORD *)(*((_QWORD *)this + 21) + 8LL * *((int *)this + 36)) = 0LL;
*(_BYTE *)(*((_QWORD *)this + 22) + (int)(*((_DWORD *)this + 36))++) = a4;
return result;
}
|
addProperty:
SUB RSP,0x58
MOV AL,CL
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV byte ptr [RSP + 0x3f],AL
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x001070e0
MOV RCX,qword ptr [RSP]
ADD RAX,0x1
MOV dword ptr [RSP + 0x38],EAX
MOV EAX,dword ptr [RCX + 0x90]
CMP EAX,dword ptr [RCX + 0x94]
JNZ 0x00145dd1
MOV RAX,qword ptr [RSP]
MOV ECX,dword ptr [RAX + 0x90]
MOV dword ptr [RSP + 0x2c],ECX
CMP dword ptr [RAX + 0x94],0x0
JNZ 0x00145c59
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX + 0x94],0x2
MOV dword ptr [RSP + 0x30],0x2
JMP 0x00145c6f
LAB_00145c59:
MOV RCX,qword ptr [RSP]
MOV EAX,dword ptr [RCX + 0x94]
SHL EAX,0x1
MOV dword ptr [RCX + 0x94],EAX
MOV dword ptr [RSP + 0x30],EAX
LAB_00145c6f:
MOVSXD RDI,dword ptr [RSP + 0x30]
SHL RDI,0x3
CALL 0x001072d0
MOV qword ptr [RSP + 0x20],RAX
MOVSXD RDI,dword ptr [RSP + 0x30]
SHL RDI,0x3
CALL 0x001072d0
MOV qword ptr [RSP + 0x18],RAX
MOVSXD RDI,dword ptr [RSP + 0x30]
SHL RDI,0x3
CALL 0x001072d0
MOV qword ptr [RSP + 0x10],RAX
MOVSXD RDI,dword ptr [RSP + 0x30]
SHL RDI,0x0
CALL 0x001072d0
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RSP + 0x34],0x0
LAB_00145cc3:
MOV EAX,dword ptr [RSP + 0x34]
CMP EAX,dword ptr [RSP + 0x2c]
JGE 0x00145d5d
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RAX + 0x98]
MOVSXD RDX,dword ptr [RSP + 0x34]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x20]
MOVSXD RDX,dword ptr [RSP + 0x34]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RCX,qword ptr [RAX + 0xa0]
MOVSXD RDX,dword ptr [RSP + 0x34]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x18]
MOVSXD RDX,dword ptr [RSP + 0x34]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RCX,qword ptr [RAX + 0xa8]
MOVSXD RDX,dword ptr [RSP + 0x34]
MOVSD XMM0,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x10]
MOVSXD RDX,dword ptr [RSP + 0x34]
MOVSD qword ptr [RCX + RDX*0x8],XMM0
MOV RAX,qword ptr [RAX + 0xb0]
MOVSXD RCX,dword ptr [RSP + 0x34]
MOV DL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + 0x8]
MOVSXD RCX,dword ptr [RSP + 0x34]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RSP + 0x34]
ADD EAX,0x1
MOV dword ptr [RSP + 0x34],EAX
JMP 0x00145cc3
LAB_00145d5d:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0x98]
CALL 0x001072a0
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0xa0]
CALL 0x001072a0
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0xa8]
CALL 0x001072a0
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0xb0]
CALL 0x001072a0
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x98],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0xa0],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0xa8],RCX
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0xb0],RCX
LAB_00145dd1:
MOVSXD RDI,dword ptr [RSP + 0x38]
SHL RDI,0x0
CALL 0x001072d0
MOV RCX,qword ptr [RSP]
MOV RSI,RAX
MOV RAX,qword ptr [RCX + 0x98]
MOVSXD RDX,dword ptr [RCX + 0x90]
MOV qword ptr [RAX + RDX*0x8],RSI
MOV RAX,qword ptr [RCX + 0x98]
MOVSXD RCX,dword ptr [RCX + 0x90]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00107220
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x001070e0
ADD RAX,0x1
MOV dword ptr [RSP + 0x38],EAX
MOVSXD RDI,dword ptr [RSP + 0x38]
SHL RDI,0x0
CALL 0x001072d0
MOV RCX,qword ptr [RSP]
MOV RSI,RAX
MOV RAX,qword ptr [RCX + 0xa0]
MOVSXD RDX,dword ptr [RCX + 0x90]
MOV qword ptr [RAX + RDX*0x8],RSI
MOV RAX,qword ptr [RCX + 0xa0]
MOVSXD RCX,dword ptr [RCX + 0x90]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x00107220
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RAX + 0xa8]
MOVSXD RDX,dword ptr [RAX + 0x90]
XORPS XMM0,XMM0
MOVSD qword ptr [RCX + RDX*0x8],XMM0
MOV SIL,byte ptr [RSP + 0x3f]
MOV RCX,qword ptr [RAX + 0xb0]
MOVSXD RDX,dword ptr [RAX + 0x90]
MOV byte ptr [RCX + RDX*0x1],SIL
MOV ECX,dword ptr [RAX + 0x90]
ADD ECX,0x1
MOV dword ptr [RAX + 0x90],ECX
ADD RSP,0x58
RET
|
/* LefDefParser::defiNonDefault::addProperty(char const*, char const*, char) */
void __thiscall
LefDefParser::defiNonDefault::addProperty
(defiNonDefault *this,char *param_1,char *param_2,char param_3)
{
int iVar1;
size_t sVar2;
void *pvVar3;
void *pvVar4;
void *pvVar5;
void *pvVar6;
int local_28;
int local_24;
sVar2 = strlen(param_1);
if (*(int *)(this + 0x90) == *(int *)(this + 0x94)) {
iVar1 = *(int *)(this + 0x90);
if (*(int *)(this + 0x94) == 0) {
*(int4 *)(this + 0x94) = 2;
local_28 = 2;
}
else {
local_28 = *(int *)(this + 0x94) << 1;
*(int *)(this + 0x94) = local_28;
}
pvVar3 = malloc((long)local_28 << 3);
pvVar4 = malloc((long)local_28 << 3);
pvVar5 = malloc((long)local_28 << 3);
pvVar6 = malloc((long)local_28);
for (local_24 = 0; local_24 < iVar1; local_24 = local_24 + 1) {
*(int8 *)((long)pvVar3 + (long)local_24 * 8) =
*(int8 *)(*(long *)(this + 0x98) + (long)local_24 * 8);
*(int8 *)((long)pvVar4 + (long)local_24 * 8) =
*(int8 *)(*(long *)(this + 0xa0) + (long)local_24 * 8);
*(int8 *)((long)pvVar5 + (long)local_24 * 8) =
*(int8 *)(*(long *)(this + 0xa8) + (long)local_24 * 8);
*(int1 *)((long)pvVar6 + (long)local_24) =
*(int1 *)(*(long *)(this + 0xb0) + (long)local_24);
}
free(*(void **)(this + 0x98));
free(*(void **)(this + 0xa0));
free(*(void **)(this + 0xa8));
free(*(void **)(this + 0xb0));
*(void **)(this + 0x98) = pvVar3;
*(void **)(this + 0xa0) = pvVar4;
*(void **)(this + 0xa8) = pvVar5;
*(void **)(this + 0xb0) = pvVar6;
}
pvVar3 = malloc((long)((int)sVar2 + 1));
*(void **)(*(long *)(this + 0x98) + (long)*(int *)(this + 0x90) * 8) = pvVar3;
strcpy(*(char **)(*(long *)(this + 0x98) + (long)*(int *)(this + 0x90) * 8),param_1);
sVar2 = strlen(param_2);
pvVar3 = malloc((long)((int)sVar2 + 1));
*(void **)(*(long *)(this + 0xa0) + (long)*(int *)(this + 0x90) * 8) = pvVar3;
strcpy(*(char **)(*(long *)(this + 0xa0) + (long)*(int *)(this + 0x90) * 8),param_2);
*(int8 *)(*(long *)(this + 0xa8) + (long)*(int *)(this + 0x90) * 8) = 0;
*(char *)(*(long *)(this + 0xb0) + (long)*(int *)(this + 0x90)) = param_3;
*(int *)(this + 0x90) = *(int *)(this + 0x90) + 1;
return;
}
|
|
10,811 |
intx::div_result<intx::uint<256u>, intx::uint<256u>> intx::udivrem<256u, 256u>(intx::uint<256u> const&, intx::uint<256u> const&)
|
corpus-core[P]colibri-stateless/build_O2/_deps/intx-src/include/intx/intx.hpp
|
constexpr div_result<uint<M>, uint<N>> udivrem(const uint<M>& u, const uint<N>& v) noexcept
{
auto na = internal::normalize(u, v);
if (na.num_numerator_words <= na.num_divisor_words)
return {0, static_cast<uint<N>>(u)};
if (na.num_divisor_words == 1)
{
const auto r = internal::udivrem_by1(
as_words(na.numerator), na.num_numerator_words, as_words(na.divisor)[0]);
return {static_cast<uint<M>>(na.numerator), r >> na.shift};
}
if (na.num_divisor_words == 2)
{
const auto d = as_words(na.divisor);
const auto r =
internal::udivrem_by2(as_words(na.numerator), na.num_numerator_words, {d[0], d[1]});
return {static_cast<uint<M>>(na.numerator), r >> na.shift};
}
auto un = as_words(na.numerator); // Will be modified.
uint<M> q;
internal::udivrem_knuth(
as_words(q), &un[0], na.num_numerator_words, as_words(na.divisor), na.num_divisor_words);
uint<N> r;
auto rw = as_words(r);
for (int i = 0; i < na.num_divisor_words - 1; ++i)
rw[i] = na.shift ? (un[i] >> na.shift) | (un[i + 1] << (64 - na.shift)) : un[i];
rw[na.num_divisor_words - 1] = un[na.num_divisor_words - 1] >> na.shift;
return {q, r};
}
|
O2
|
cpp
|
intx::div_result<intx::uint<256u>, intx::uint<256u>> intx::udivrem<256u, 256u>(intx::uint<256u> const&, intx::uint<256u> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movaps %xmm0, -0x10(%rax)
movaps %xmm0, -0x20(%rax)
andq $0x0, 0x40(%rax)
pushq $0xc
popq %rbx
leaq -0x4(%rbx), %r15
cmpl $0x4, %ebx
je 0x3a53b
movl %r15d, %eax
cmpq $0x0, -0x8(%r12,%rax,8)
jne 0x3a53b
decq %rbx
jmp 0x3a522
movl %r15d, 0x7c(%rsp)
pushq $0x3
popq %r14
cmpl $-0x1, %r14d
je 0x3a55d
leaq 0x1(%r14), %rax
movl %eax, %eax
cmpq $0x0, -0x8(%rbp,%rax,8)
jne 0x3a55d
decq %r14
jmp 0x3a544
leal 0x1(%r14), %eax
movl %eax, 0x78(%rsp)
movq (%rbp,%r14,8), %rdi
callq 0x395f1
movl %eax, 0x80(%rsp)
pushq $0x40
popq %r13
testl %eax, %eax
je 0x3a609
movl %eax, %esi
movl %r13d, %edx
subl %eax, %edx
pushq $0x18
popq %rax
testq %rax, %rax
je 0x3a5b3
movq -0x8(%rbp,%rax), %rdi
movq (%rbp,%rax), %r8
movl %esi, %ecx
shlq %cl, %r8
movl %edx, %ecx
shrq %cl, %rdi
orq %r8, %rdi
movq %rdi, 0x10(%rsp,%rax)
addq $-0x8, %rax
jmp 0x3a58c
movq (%rbp), %rax
movl %esi, %ecx
shlq %cl, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%r12), %rax
movl %edx, %ecx
shrq %cl, %rax
movq %rax, 0x70(%rsp)
pushq $0x6
popq %rax
cmpq $-0x1, %rax
je 0x3a5f9
movq (%r12,%rax,8), %rdi
movq 0x8(%r12,%rax,8), %r8
movl %esi, %ecx
shlq %cl, %r8
movl %edx, %ecx
shrq %cl, %rdi
orq %r8, %rdi
movq %rdi, 0x38(%rsp,%rax,8)
decq %rax
jmp 0x3a5d3
movq (%r12), %rax
movl %esi, %ecx
shlq %cl, %rax
movq %rax, 0x30(%rsp)
jmp 0x3a628
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x3a912
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp,%rbx,8)
jne 0x3a641
movq 0x8(%rsp,%rbx,8), %rax
cmpq 0x10(%rsp,%r14,8), %rax
jae 0x3a641
movl %r15d, %ebx
jmp 0x3a648
addl $-0x3, %ebx
movl %ebx, 0x7c(%rsp)
movl 0x78(%rsp), %r8d
cmpl %r8d, %ebx
jle 0x3a6a8
cmpl $0x2, %r8d
je 0x3a6d0
cmpl $0x1, %r8d
jne 0x3a73e
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x39285
movq %rax, %r15
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a8e6
movb 0x80(%rsp), %cl
shrq %cl, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
andq $0x0, 0x58(%rbx)
movq %r15, 0x40(%rbx)
jmp 0x3a823
movq 0x8(%rsp), %rbx
leaq 0x40(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %r12, %rsi
callq 0x3a8c2
jmp 0x3a823
leaq 0x80(%rsp), %r12
movq -0x70(%r12), %rdx
movq -0x68(%r12), %rcx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x39327
leaq 0xb0(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a8e6
movq %rbx, %r14
addq $0x40, %r14
movq %r15, %rdi
movq %r12, %rsi
callq 0x393de
leaq 0x90(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r14, %rdi
callq 0x39400
jmp 0x3a823
xorps %xmm0, %xmm0
leaq 0xb0(%rsp), %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0x39420
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movslq 0x68(%r12), %rdx
leal -0x1(%rdx), %esi
movl 0x70(%r12), %eax
subl %eax, %r13d
xorl %edi, %edi
testl %esi, %esi
cmovlel %edi, %esi
movq 0x8(%rsp), %rbx
cmpq %rdi, %rsi
je 0x3a7ca
movq 0x30(%rsp,%rdi,8), %r8
testq %rax, %rax
je 0x3a7bd
movl %eax, %ecx
shrq %cl, %r8
movq 0x38(%rsp,%rdi,8), %r9
movl %r13d, %ecx
shlq %cl, %r9
orq %r9, %r8
movq %r8, 0x90(%rsp,%rdi,8)
incq %rdi
jmp 0x3a79b
movq 0x28(%rsp,%rdx,8), %rsi
movl %eax, %ecx
shrq %cl, %rsi
movq %rsi, 0x88(%rsp,%rdx,8)
movaps 0xb0(%rsp), %xmm0
movaps 0xc0(%rsp), %xmm1
movaps 0xd0(%rsp), %xmm2
movaps 0xe0(%rsp), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movaps 0x90(%rsp), %xmm0
movaps 0xa0(%rsp), %xmm1
movups %xmm0, 0x40(%rbx)
movups %xmm1, 0x50(%rbx)
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN4intx7udivremILj512ELj256EEENS_10div_resultINS_4uintIXT_EEENS2_IXT0_EEEEERKS3_RKS4_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov rbp, rdx
mov r12, rsi
mov [rsp+128h+var_120], rdi
xorps xmm0, xmm0
lea rax, [rsp+128h+var_F8]
movaps xmmword ptr [rax+30h], xmm0
movaps xmmword ptr [rax+20h], xmm0
movaps xmmword ptr [rax+10h], xmm0
movaps xmmword ptr [rax], xmm0
movaps xmmword ptr [rax-10h], xmm0
movaps xmmword ptr [rax-20h], xmm0
and qword ptr [rax+40h], 0
push 0Ch
pop rbx
loc_3A522:
lea r15, [rbx-4]
cmp ebx, 4
jz short loc_3A53B
mov eax, r15d
cmp qword ptr [r12+rax*8-8], 0
jnz short loc_3A53B
dec rbx
jmp short loc_3A522
loc_3A53B:
mov dword ptr [rsp+128h+var_B0+4], r15d
push 3
pop r14
loc_3A544:
cmp r14d, 0FFFFFFFFh
jz short loc_3A55D
lea rax, [r14+1]
mov eax, eax
cmp qword ptr [rbp+rax*8-8], 0
jnz short loc_3A55D
dec r14
jmp short loc_3A544
loc_3A55D:
lea eax, [r14+1]
mov dword ptr [rsp+128h+var_B0], eax
mov rdi, [rbp+r14*8+0]; this
call _ZN4intx8internal11clz_nonzeroEm; intx::internal::clz_nonzero(ulong)
mov [rsp+128h+var_A8], eax
push 40h ; '@'
pop r13
test eax, eax
jz loc_3A609
mov esi, eax
mov edx, r13d
sub edx, eax
push 18h
pop rax
loc_3A58C:
test rax, rax
jz short loc_3A5B3
mov rdi, [rbp+rax-8]
mov r8, [rbp+rax+0]
mov ecx, esi
shl r8, cl
mov ecx, edx
shr rdi, cl
or rdi, r8
mov qword ptr [rsp+rax+128h+var_118], rdi
add rax, 0FFFFFFFFFFFFFFF8h
jmp short loc_3A58C
loc_3A5B3:
mov rax, [rbp+0]
mov ecx, esi
shl rax, cl
mov qword ptr [rsp+128h+var_118], rax
mov rax, [r12+38h]
mov ecx, edx
shr rax, cl
mov [rsp+128h+var_B8], rax
push 6
pop rax
loc_3A5D3:
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_3A5F9
mov rdi, [r12+rax*8]
mov r8, [r12+rax*8+8]
mov ecx, esi
shl r8, cl
mov ecx, edx
shr rdi, cl
or rdi, r8
mov [rsp+rax*8+128h+var_F0], rdi
dec rax
jmp short loc_3A5D3
loc_3A5F9:
mov rax, [r12]
mov ecx, esi
shl rax, cl
mov [rsp+128h+var_F8], rax
jmp short loc_3A628
loc_3A609:
lea rdi, [rsp+128h+var_F8]
mov rsi, r12
call _ZN4intx4uintILj576EEC2ILj512EvEERKNS0_IXT_EEE; intx::uint<576u>::uint<512u,void>(intx::uint<512u> const&)
movups xmm0, xmmword ptr [rbp+0]
movups xmm1, xmmword ptr [rbp+10h]
movaps [rsp+128h+var_108], xmm1
movaps xmmword ptr [rsp+128h+var_118], xmm0
loc_3A628:
cmp qword ptr [rsp+rbx*8+128h+var_118], 0
jnz short loc_3A641
mov rax, [rsp+rbx*8+128h+var_120]
cmp rax, qword ptr [rsp+r14*8+128h+var_118]
jnb short loc_3A641
mov ebx, r15d
jmp short loc_3A648
loc_3A641:
add ebx, 0FFFFFFFDh
mov dword ptr [rsp+128h+var_B0+4], ebx
loc_3A648:
mov r8d, dword ptr [rsp+128h+var_B0]; unsigned __int64 *
cmp ebx, r8d
jle short loc_3A6A8
cmp r8d, 2
jz short loc_3A6D0
cmp r8d, 1
jnz loc_3A73E
mov rdx, qword ptr [rsp+128h+var_118]; int
lea r14, [rsp+128h+var_F8]
mov rdi, r14; this
mov esi, ebx; unsigned __int64 *
call _ZN4intx8internal11udivrem_by1EPmim; intx::internal::udivrem_by1(ulong *,int,ulong)
mov r15, rax
mov rbx, [rsp+128h+var_120]
mov rdi, rbx
mov rsi, r14
call _ZNK4intx4uintILj576EEcvNS0_IXT_EEEILj512EvEEv; intx::uint<576u>::operator intx::uint<576u><512u,void>(void)
mov cl, byte ptr [rsp+128h+var_A8]
shr r15, cl
xorps xmm0, xmm0
movups xmmword ptr [rbx+48h], xmm0
and qword ptr [rbx+58h], 0
mov [rbx+40h], r15
jmp loc_3A823
loc_3A6A8:
mov rbx, [rsp+128h+var_120]
lea rdi, [rbx+40h]
xorps xmm0, 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 rsi, r12
call _ZNK4intx4uintILj512EEcvNS0_IXT_EEEILj256EvEEv; intx::uint<512u>::operator intx::uint<512u><256u,void>(void)
jmp loc_3A823
loc_3A6D0:
lea r12, [rsp+128h+var_A8]
mov rdx, [r12-70h]
mov rcx, [r12-68h]
lea r14, [rsp+128h+var_F8]
mov rdi, r14
mov esi, ebx
call _ZN4intx8internal11udivrem_by2EPmiNS_4uintILj128EEE; intx::internal::udivrem_by2(ulong *,int,intx::uint<128u>)
lea r15, [rsp+128h+var_78]
mov [r15], rax
mov [r15+8], rdx
mov rbx, [rsp+128h+var_120]
mov rdi, rbx
mov rsi, r14
call _ZNK4intx4uintILj576EEcvNS0_IXT_EEEILj512EvEEv; intx::uint<576u>::operator intx::uint<576u><512u,void>(void)
mov r14, rbx
add r14, 40h ; '@'
mov rdi, r15
mov rsi, r12
call _ZN4intxrsILj128EjvEENS_4uintIXT_EEERKS2_RKT0_; intx::operator>><128u,uint,void>(intx::uint<128u> const&,uint const&)
lea rsi, [rsp+128h+var_98]
mov [rsi], rax
mov [rsi+8], rdx
mov rdi, r14
call _ZN4intx4uintILj256EEC2ILj128EvEERKNS0_IXT_EEE; intx::uint<256u>::uint<128u,void>(intx::uint<128u> const&)
jmp loc_3A823
loc_3A73E:
xorps xmm0, xmm0
lea rdi, [rsp+128h+var_78]; this
movaps xmmword ptr [rdi+30h], xmm0
movaps xmmword ptr [rdi+20h], xmm0
movaps xmmword ptr [rdi+10h], xmm0
movaps xmmword ptr [rdi], xmm0
lea r12, [rsp+128h+var_118]
lea rsi, [rsp+128h+var_F8]; unsigned __int64 *
mov edx, ebx; unsigned __int64 *
mov rcx, r12; int
call _ZN4intx8internal13udivrem_knuthEPmS1_iPKmi; intx::internal::udivrem_knuth(ulong *,ulong *,int,ulong const*,int)
xorps xmm0, xmm0
movaps [rsp+128h+var_88], xmm0
movaps [rsp+128h+var_98], xmm0
movsxd rdx, dword ptr [r12+68h]
lea esi, [rdx-1]
mov eax, [r12+70h]
sub r13d, eax
xor edi, edi
test esi, esi
cmovle esi, edi
mov rbx, [rsp+128h+var_120]
loc_3A79B:
cmp rsi, rdi
jz short loc_3A7CA
mov r8, [rsp+rdi*8+128h+var_F8]
test rax, rax
jz short loc_3A7BD
mov ecx, eax
shr r8, cl
mov r9, [rsp+rdi*8+128h+var_F0]
mov ecx, r13d
shl r9, cl
or r8, r9
loc_3A7BD:
mov qword ptr [rsp+rdi*8+128h+var_98], r8
inc rdi
jmp short loc_3A79B
loc_3A7CA:
mov rsi, qword ptr [rsp+rdx*8+128h+var_108+8]
mov ecx, eax
shr rsi, cl
mov [rsp+rdx*8+128h+var_A0], rsi
movaps xmm0, [rsp+128h+var_78]
movaps xmm1, [rsp+128h+var_68]
movaps xmm2, [rsp+128h+var_58]
movaps xmm3, [rsp+128h+var_48]
movups xmmword ptr [rbx+30h], xmm3
movups xmmword ptr [rbx+20h], xmm2
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
movaps xmm0, [rsp+128h+var_98]
movaps xmm1, [rsp+128h+var_88]
movups xmmword ptr [rbx+40h], xmm0
movups xmmword ptr [rbx+50h], xmm1
loc_3A823:
mov rax, rbx
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long intx::udivrem<512u,256u>(long long a1, _QWORD *a2, __int128 *a3)
{
long long i; // rbx
long long j; // r14
unsigned int v7; // eax
char v8; // si
char v9; // dl
unsigned long long k; // rax
long long m; // rax
__int128 v12; // xmm0
unsigned int v13; // ebx
unsigned long long v14; // r15
long long v15; // rbx
unsigned long long v16; // r15
long long v17; // rdi
__int128 v18; // rax
__int128 v19; // rax
long long v20; // rdx
long long v21; // rsi
long long v22; // rax
char v23; // r13
long long v24; // rdi
unsigned long long v25; // r8
__int128 v26; // xmm0
__int128 v27; // xmm1
__int128 v28; // xmm2
__int128 v29; // xmm1
long long v31; // [rsp+8h] [rbp-120h]
int v32[4]; // [rsp+10h] [rbp-118h] BYREF
__int128 v33; // [rsp+20h] [rbp-108h]
unsigned long long v34[2]; // [rsp+30h] [rbp-F8h] BYREF
__int128 v35; // [rsp+40h] [rbp-E8h]
__int128 v36; // [rsp+50h] [rbp-D8h]
__int128 v37; // [rsp+60h] [rbp-C8h]
long long v38; // [rsp+70h] [rbp-B8h]
signed int v39; // [rsp+78h] [rbp-B0h]
unsigned int v40; // [rsp+7Ch] [rbp-ACh]
unsigned int v41[4]; // [rsp+80h] [rbp-A8h] BYREF
__int128 v42; // [rsp+90h] [rbp-98h] BYREF
__int128 v43; // [rsp+A0h] [rbp-88h]
__int128 v44; // [rsp+B0h] [rbp-78h] BYREF
__int128 v45; // [rsp+C0h] [rbp-68h]
__int128 v46; // [rsp+D0h] [rbp-58h]
__int128 v47; // [rsp+E0h] [rbp-48h]
v31 = a1;
v37 = 0LL;
v36 = 0LL;
v35 = 0LL;
*(_OWORD *)v34 = 0LL;
v33 = 0LL;
*(_OWORD *)v32 = 0LL;
v38 = 0LL;
for ( i = 12LL; (_DWORD)i != 4 && !a2[(unsigned int)(i - 4) - 1]; --i )
;
v40 = i - 4;
for ( j = 3LL; (_DWORD)j != -1 && !*((_QWORD *)a3 + (unsigned int)(j + 1) - 1); --j )
;
v39 = j + 1;
v7 = intx::internal::clz_nonzero(*((intx::internal **)a3 + j));
v41[0] = v7;
if ( v7 )
{
v8 = v7;
v9 = 64 - v7;
for ( k = 24LL; k; k -= 8LL )
*(_QWORD *)&v32[k / 4] = (*(_QWORD *)((char *)a3 + k) << v8) | (*(_QWORD *)((char *)a3 + k - 8) >> v9);
*(_QWORD *)v32 = *(_QWORD *)a3 << v8;
v38 = a2[7] >> v9;
for ( m = 6LL; m != -1; --m )
v34[m + 1] = (a2[m + 1] << v8) | (a2[m] >> v9);
v34[0] = *a2 << v8;
}
else
{
intx::uint<576u>::uint<512u,void>(v34, a2);
v12 = *a3;
v33 = a3[1];
*(_OWORD *)v32 = v12;
}
if ( *(_QWORD *)&v32[2 * i] || *(unsigned long long *)&v32[2 * i - 2] >= *(_QWORD *)&v32[2 * j] )
{
v13 = i - 3;
v40 = v13;
}
else
{
v13 = i - 4;
}
if ( (int)v13 <= v39 )
{
v15 = v31;
v17 = v31 + 64;
*(_OWORD *)(v31 + 48) = 0LL;
*(_OWORD *)(v15 + 32) = 0LL;
*(_OWORD *)(v15 + 16) = 0LL;
*(_OWORD *)v15 = 0LL;
intx::uint<512u>::operator intx::uint<512u><256u,void>(v17, a2);
}
else if ( v39 == 2 )
{
*(_QWORD *)&v18 = intx::internal::udivrem_by2((long long)v34, v13, *(long long *)v32, *(long long *)&v32[2]);
v44 = v18;
v15 = v31;
intx::uint<576u>::operator intx::uint<576u><512u,void>(v31, v34);
*(_QWORD *)&v19 = intx::operator>><128u,unsigned int,void>(&v44, v41);
v42 = v19;
intx::uint<256u>::uint<128u,void>((_OWORD *)(v15 + 64), (long long)&v42);
}
else if ( v39 == 1 )
{
v14 = intx::internal::udivrem_by1((intx::internal *)v34, (unsigned long long *)v13, *(intx **)v32);
v15 = v31;
intx::uint<576u>::operator intx::uint<576u><512u,void>(v31, v34);
v16 = v14 >> SLOBYTE(v41[0]);
*(_OWORD *)(v15 + 72) = 0LL;
*(_QWORD *)(v15 + 88) = 0LL;
*(_QWORD *)(v15 + 64) = v16;
}
else
{
v47 = 0LL;
v46 = 0LL;
v45 = 0LL;
v44 = 0LL;
intx::internal::udivrem_knuth(
(intx::internal *)&v44,
v34,
(unsigned long long *)v13,
(const unsigned long long *)v32,
(unsigned long long *)(unsigned int)v39);
v43 = 0LL;
v42 = 0LL;
v20 = v39;
v21 = (unsigned int)(v39 - 1);
v22 = v41[0];
v23 = 64 - LOBYTE(v41[0]);
v24 = 0LL;
if ( v39 - 1 <= 0 )
v21 = 0LL;
v15 = v31;
while ( v21 != v24 )
{
v25 = v34[v24];
if ( v22 )
v25 = (v34[v24 + 1] << v23) | (v25 >> v22);
*((_QWORD *)&v42 + v24++) = v25;
}
*(_QWORD *)&v41[2 * v20 + 2] = v34[v20 - 1] >> v22;
v26 = v44;
v27 = v45;
v28 = v46;
*(_OWORD *)(v15 + 48) = v47;
*(_OWORD *)(v15 + 32) = v28;
*(_OWORD *)(v15 + 16) = v27;
*(_OWORD *)v15 = v26;
v29 = v43;
*(_OWORD *)(v15 + 64) = v42;
*(_OWORD *)(v15 + 80) = v29;
}
return v15;
}
|
udivrem<512u,256u>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV RBP,RDX
MOV R12,RSI
MOV qword ptr [RSP + 0x8],RDI
XORPS XMM0,XMM0
LEA RAX,[RSP + 0x30]
MOVAPS xmmword ptr [RAX + 0x30],XMM0
MOVAPS xmmword ptr [RAX + 0x20],XMM0
MOVAPS xmmword ptr [RAX + 0x10],XMM0
MOVAPS xmmword ptr [RAX],XMM0
MOVAPS xmmword ptr [RAX + -0x10],XMM0
MOVAPS xmmword ptr [RAX + -0x20],XMM0
AND qword ptr [RAX + 0x40],0x0
PUSH 0xc
POP RBX
LAB_0013a522:
LEA R15,[RBX + -0x4]
CMP EBX,0x4
JZ 0x0013a53b
MOV EAX,R15D
CMP qword ptr [R12 + RAX*0x8 + -0x8],0x0
JNZ 0x0013a53b
DEC RBX
JMP 0x0013a522
LAB_0013a53b:
MOV dword ptr [RSP + 0x7c],R15D
PUSH 0x3
POP R14
LAB_0013a544:
CMP R14D,-0x1
JZ 0x0013a55d
LEA RAX,[R14 + 0x1]
MOV EAX,EAX
CMP qword ptr [RBP + RAX*0x8 + -0x8],0x0
JNZ 0x0013a55d
DEC R14
JMP 0x0013a544
LAB_0013a55d:
LEA EAX,[R14 + 0x1]
MOV dword ptr [RSP + 0x78],EAX
MOV RDI,qword ptr [RBP + R14*0x8]
CALL 0x001395f1
MOV dword ptr [RSP + 0x80],EAX
PUSH 0x40
POP R13
TEST EAX,EAX
JZ 0x0013a609
MOV ESI,EAX
MOV EDX,R13D
SUB EDX,EAX
PUSH 0x18
POP RAX
LAB_0013a58c:
TEST RAX,RAX
JZ 0x0013a5b3
MOV RDI,qword ptr [RBP + RAX*0x1 + -0x8]
MOV R8,qword ptr [RBP + RAX*0x1]
MOV ECX,ESI
SHL R8,CL
MOV ECX,EDX
SHR RDI,CL
OR RDI,R8
MOV qword ptr [RSP + RAX*0x1 + 0x10],RDI
ADD RAX,-0x8
JMP 0x0013a58c
LAB_0013a5b3:
MOV RAX,qword ptr [RBP]
MOV ECX,ESI
SHL RAX,CL
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [R12 + 0x38]
MOV ECX,EDX
SHR RAX,CL
MOV qword ptr [RSP + 0x70],RAX
PUSH 0x6
POP RAX
LAB_0013a5d3:
CMP RAX,-0x1
JZ 0x0013a5f9
MOV RDI,qword ptr [R12 + RAX*0x8]
MOV R8,qword ptr [R12 + RAX*0x8 + 0x8]
MOV ECX,ESI
SHL R8,CL
MOV ECX,EDX
SHR RDI,CL
OR RDI,R8
MOV qword ptr [RSP + RAX*0x8 + 0x38],RDI
DEC RAX
JMP 0x0013a5d3
LAB_0013a5f9:
MOV RAX,qword ptr [R12]
MOV ECX,ESI
SHL RAX,CL
MOV qword ptr [RSP + 0x30],RAX
JMP 0x0013a628
LAB_0013a609:
LEA RDI,[RSP + 0x30]
MOV RSI,R12
CALL 0x0013a912
MOVUPS XMM0,xmmword ptr [RBP]
MOVUPS XMM1,xmmword ptr [RBP + 0x10]
MOVAPS xmmword ptr [RSP + 0x20],XMM1
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LAB_0013a628:
CMP qword ptr [RSP + RBX*0x8 + 0x10],0x0
JNZ 0x0013a641
MOV RAX,qword ptr [RSP + RBX*0x8 + 0x8]
CMP RAX,qword ptr [RSP + R14*0x8 + 0x10]
JNC 0x0013a641
MOV EBX,R15D
JMP 0x0013a648
LAB_0013a641:
ADD EBX,-0x3
MOV dword ptr [RSP + 0x7c],EBX
LAB_0013a648:
MOV R8D,dword ptr [RSP + 0x78]
CMP EBX,R8D
JLE 0x0013a6a8
CMP R8D,0x2
JZ 0x0013a6d0
CMP R8D,0x1
JNZ 0x0013a73e
MOV RDX,qword ptr [RSP + 0x10]
LEA R14,[RSP + 0x30]
MOV RDI,R14
MOV ESI,EBX
CALL 0x00139285
MOV R15,RAX
MOV RBX,qword ptr [RSP + 0x8]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0013a8e6
MOV CL,byte ptr [RSP + 0x80]
SHR R15,CL
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x48],XMM0
AND qword ptr [RBX + 0x58],0x0
MOV qword ptr [RBX + 0x40],R15
JMP 0x0013a823
LAB_0013a6a8:
MOV RBX,qword ptr [RSP + 0x8]
LEA RDI,[RBX + 0x40]
XORPS XMM0,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 RSI,R12
CALL 0x0013a8c2
JMP 0x0013a823
LAB_0013a6d0:
LEA R12,[RSP + 0x80]
MOV RDX,qword ptr [R12 + -0x70]
MOV RCX,qword ptr [R12 + -0x68]
LEA R14,[RSP + 0x30]
MOV RDI,R14
MOV ESI,EBX
CALL 0x00139327
LEA R15,[RSP + 0xb0]
MOV qword ptr [R15],RAX
MOV qword ptr [R15 + 0x8],RDX
MOV RBX,qword ptr [RSP + 0x8]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0013a8e6
MOV R14,RBX
ADD R14,0x40
MOV RDI,R15
MOV RSI,R12
CALL 0x001393de
LEA RSI,[RSP + 0x90]
MOV qword ptr [RSI],RAX
MOV qword ptr [RSI + 0x8],RDX
MOV RDI,R14
CALL 0x00139400
JMP 0x0013a823
LAB_0013a73e:
XORPS XMM0,XMM0
LEA RDI,[RSP + 0xb0]
MOVAPS xmmword ptr [RDI + 0x30],XMM0
MOVAPS xmmword ptr [RDI + 0x20],XMM0
MOVAPS xmmword ptr [RDI + 0x10],XMM0
MOVAPS xmmword ptr [RDI],XMM0
LEA R12,[RSP + 0x10]
LEA RSI,[RSP + 0x30]
MOV EDX,EBX
MOV RCX,R12
CALL 0x00139420
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVSXD RDX,dword ptr [R12 + 0x68]
LEA ESI,[RDX + -0x1]
MOV EAX,dword ptr [R12 + 0x70]
SUB R13D,EAX
XOR EDI,EDI
TEST ESI,ESI
CMOVLE ESI,EDI
MOV RBX,qword ptr [RSP + 0x8]
LAB_0013a79b:
CMP RSI,RDI
JZ 0x0013a7ca
MOV R8,qword ptr [RSP + RDI*0x8 + 0x30]
TEST RAX,RAX
JZ 0x0013a7bd
MOV ECX,EAX
SHR R8,CL
MOV R9,qword ptr [RSP + RDI*0x8 + 0x38]
MOV ECX,R13D
SHL R9,CL
OR R8,R9
LAB_0013a7bd:
MOV qword ptr [RSP + RDI*0x8 + 0x90],R8
INC RDI
JMP 0x0013a79b
LAB_0013a7ca:
MOV RSI,qword ptr [RSP + RDX*0x8 + 0x28]
MOV ECX,EAX
SHR RSI,CL
MOV qword ptr [RSP + RDX*0x8 + 0x88],RSI
MOVAPS XMM0,xmmword ptr [RSP + 0xb0]
MOVAPS XMM1,xmmword ptr [RSP + 0xc0]
MOVAPS XMM2,xmmword ptr [RSP + 0xd0]
MOVAPS XMM3,xmmword ptr [RSP + 0xe0]
MOVUPS xmmword ptr [RBX + 0x30],XMM3
MOVUPS xmmword ptr [RBX + 0x20],XMM2
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
MOVAPS XMM0,xmmword ptr [RSP + 0x90]
MOVAPS XMM1,xmmword ptr [RSP + 0xa0]
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOVUPS xmmword ptr [RBX + 0x50],XMM1
LAB_0013a823:
MOV RAX,RBX
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Type propagation algorithm not settling */
/* intx::div_result<intx::uint<512u>, intx::uint<256u> > intx::udivrem<512u, 256u>(intx::uint<512u>
const&, intx::uint<256u> const&) */
intx * __thiscall intx::udivrem<512u,256u>(intx *this,uint *param_1,uint *param_2)
{
byte bVar1;
long lVar2;
ulong uVar3;
byte bVar4;
int iVar5;
long lVar6;
ulong uVar7;
ulong uVar8;
long lVar9;
ulong local_120 [5];
ulong local_f8 [9];
int local_b0;
int local_ac;
uint local_a8 [2];
ulong uStack_a0;
int1 local_98 [16];
int8 local_88;
int8 uStack_80;
int1 local_78 [16];
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
local_f8[6] = 0;
local_f8[7] = 0;
local_f8[4] = 0;
local_f8[5] = 0;
local_f8[2] = 0;
local_f8[3] = 0;
local_f8[0] = 0;
local_f8[1] = 0;
local_120[3] = 0;
local_120[4] = 0;
local_120[1] = 0;
local_120[2] = 0;
local_f8[8] = 0;
lVar6 = 0xc;
while( true ) {
iVar5 = (int)(lVar6 - 4U);
if (((int)lVar6 == 4) || (*(long *)(param_1 + (lVar6 - 4U & 0xffffffff) * 8 + -8) != 0)) break;
lVar6 = lVar6 + -1;
}
lVar9 = 3;
while (((int)lVar9 != -1 && (*(long *)(param_2 + (lVar9 + 1U & 0xffffffff) * 8 + -8) == 0))) {
lVar9 = lVar9 + -1;
}
local_b0 = (int)lVar9 + 1;
local_ac = iVar5;
local_a8[0] = internal::clz_nonzero(*(ulong *)(param_2 + lVar9 * 8));
if (local_a8[0] == 0) {
uint<576u>::uint<512u,void>((uint<576u> *)local_f8,param_1);
local_120[3] = *(int8 *)(param_2 + 0x10);
local_120[4] = *(int8 *)(param_2 + 0x18);
local_120[1] = *(ulong *)param_2;
local_120[2] = *(int8 *)(param_2 + 8);
}
else {
bVar1 = (byte)local_a8[0];
bVar4 = 0x40 - bVar1;
for (lVar2 = 0x18; lVar2 != 0; lVar2 = lVar2 + -8) {
*(ulong *)((long)local_120 + lVar2 + 8) =
*(ulong *)(param_2 + lVar2 + -8) >> (bVar4 & 0x3f) |
*(long *)(param_2 + lVar2) << (bVar1 & 0x3f);
}
local_120[1] = *(long *)param_2 << (bVar1 & 0x3f);
local_f8[8] = *(ulong *)(param_1 + 0x38) >> (bVar4 & 0x3f);
for (lVar2 = 6; lVar2 != -1; lVar2 = lVar2 + -1) {
local_f8[lVar2 + 1] =
*(ulong *)(param_1 + lVar2 * 8) >> (bVar4 & 0x3f) |
*(long *)(param_1 + lVar2 * 8 + 8) << (bVar1 & 0x3f);
}
local_f8[0] = *(long *)param_1 << (bVar1 & 0x3f);
}
if ((local_120[lVar6 + 1] != 0) || (local_120[lVar9 + 1] <= local_120[lVar6])) {
iVar5 = (int)lVar6 + -3;
local_ac = iVar5;
}
if (local_b0 < iVar5) {
if (local_b0 == 2) {
local_78 = internal::udivrem_by2((internal *)local_f8,iVar5,local_120[1],local_120[2]);
uint::operator_cast_to_uint((uint *)this);
local_98 = operator>>((uint *)local_78,local_a8);
uint<256u>::uint<128u,void>((uint<256u> *)(this + 0x40),(uint *)local_98);
}
else if (local_b0 == 1) {
uVar3 = internal::udivrem_by1(local_f8,iVar5,local_120[1]);
uint::operator_cast_to_uint((uint *)this);
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(ulong *)(this + 0x40) = uVar3 >> ((byte)local_a8[0] & 0x3f);
}
else {
local_48 = 0;
uStack_40 = 0;
local_58 = 0;
uStack_50 = 0;
local_68 = 0;
uStack_60 = 0;
local_78._0_8_ = 0;
local_78._8_8_ = 0;
internal::udivrem_knuth((ulong *)local_78,local_f8,iVar5,local_120 + 1,local_b0);
local_88 = 0;
uStack_80 = 0;
local_98._0_8_ = 0;
local_98._8_8_ = 0;
bVar1 = (byte)local_a8[0];
uVar7 = 0;
uVar3 = (ulong)(local_b0 - 1U);
if ((int)(local_b0 - 1U) < 1) {
uVar3 = uVar7;
}
for (; uVar3 != uVar7; uVar7 = uVar7 + 1) {
uVar8 = local_f8[uVar7];
if (local_a8[0] != 0) {
uVar8 = uVar8 >> (bVar1 & 0x3f) | local_f8[uVar7 + 1] << (0x40 - bVar1 & 0x3f);
}
*(ulong *)(local_98 + uVar7 * 8) = uVar8;
}
*(ulong *)(local_98 + (long)local_b0 * 8 + -8) =
local_120[(long)local_b0 + 4] >> (bVar1 & 0x3f);
*(int8 *)(this + 0x30) = local_48;
*(int8 *)(this + 0x38) = uStack_40;
*(int8 *)(this + 0x20) = local_58;
*(int8 *)(this + 0x28) = uStack_50;
*(int8 *)(this + 0x10) = local_68;
*(int8 *)(this + 0x18) = uStack_60;
*(int8 *)this = local_78._0_8_;
*(int8 *)(this + 8) = local_78._8_8_;
*(int8 *)(this + 0x40) = local_98._0_8_;
*(int8 *)(this + 0x48) = local_98._8_8_;
*(int8 *)(this + 0x50) = local_88;
*(int8 *)(this + 0x58) = uStack_80;
}
}
else {
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
uint::operator_cast_to_uint((uint *)(this + 0x40));
}
return this;
}
|
|
10,812 |
my_hash_sort_ucs2_nopad
|
eloqsql/strings/ctype-ucs2.c
|
static void
my_hash_sort_ucs2_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e=s+slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((s < e) && (res=my_ucs2_uni(cs,&wc, (uchar *)s, (uchar*)e)) >0)
{
my_tosort_ucs2(uni_plane, &wc);
MY_HASH_ADD_16(m1, m2, wc);
s+=res;
}
*nr1= m1;
*nr2= m2;
}
|
O3
|
c
|
my_hash_sort_ucs2_nopad:
movq (%rcx), %r9
movq (%r8), %rax
cmpq $0x2, %rdx
jl 0x4c569
pushq %rbp
movq %rsp, %rbp
pushq %rbx
addq %rsi, %rdx
movq 0x78(%rdi), %rdi
movq 0x8(%rdi), %rdi
movzbl (%rsi), %r10d
movzbl 0x1(%rsi), %r11d
movq (%rdi,%r10,8), %rbx
testq %rbx, %rbx
je 0x4c505
leaq (%r11,%r11,2), %r10
movl 0x8(%rbx,%r10,4), %r10d
jmp 0x4c50c
shll $0x8, %r10d
orq %r11, %r10
movl %r9d, %r11d
andl $0x3f, %r11d
addq %rax, %r11
movzbl %r10b, %ebx
imulq %r11, %rbx
movq %r9, %r11
shlq $0x8, %r11
addq %rbx, %r11
xorq %r9, %r11
movl %r11d, %r9d
andl $0x3f, %r9d
addq %rax, %r9
addq $0x3, %r9
shrl $0x8, %r10d
imulq %r9, %r10
movq %r11, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r11, %r9
addq $0x6, %rax
leaq 0x2(%rsi), %r10
cmpq %rdx, %r10
jae 0x4c567
addq $0x4, %rsi
cmpq %rdx, %rsi
movq %r10, %rsi
jbe 0x4c4e8
popq %rbx
popq %rbp
movq %r9, (%rcx)
movq %rax, (%r8)
retq
|
my_hash_sort_ucs2_nopad:
mov r9, [rcx]
mov rax, [r8]
cmp rdx, 2
jl loc_4C569
push rbp
mov rbp, rsp
push rbx
add rdx, rsi
mov rdi, [rdi+78h]
mov rdi, [rdi+8]
loc_4C4E8:
movzx r10d, byte ptr [rsi]
movzx r11d, byte ptr [rsi+1]
mov rbx, [rdi+r10*8]
test rbx, rbx
jz short loc_4C505
lea r10, [r11+r11*2]
mov r10d, [rbx+r10*4+8]
jmp short loc_4C50C
loc_4C505:
shl r10d, 8
or r10, r11
loc_4C50C:
mov r11d, r9d
and r11d, 3Fh
add r11, rax
movzx ebx, r10b
imul rbx, r11
mov r11, r9
shl r11, 8
add r11, rbx
xor r11, r9
mov r9d, r11d
and r9d, 3Fh
add r9, rax
add r9, 3
shr r10d, 8
imul r10, r9
mov r9, r11
shl r9, 8
add r9, r10
xor r9, r11
add rax, 6
lea r10, [rsi+2]
cmp r10, rdx
jnb short loc_4C567
add rsi, 4
cmp rsi, rdx
mov rsi, r10
jbe short loc_4C4E8
loc_4C567:
pop rbx
pop rbp
loc_4C569:
mov [rcx], r9
mov [r8], rax
retn
|
long long my_hash_sort_ucs2_nopad(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long v5; // r9
long long result; // rax
unsigned long long v7; // rdx
long long v8; // rdi
long long v9; // r10
long long v10; // r11
long long v11; // rbx
unsigned int v12; // r10d
long long v13; // rbx
bool v14; // cc
v5 = *a4;
result = *a5;
if ( a3 >= 2 )
{
v7 = (unsigned long long)&a2[a3];
v8 = *(_QWORD *)(*(_QWORD *)(a1 + 120) + 8LL);
do
{
v9 = *a2;
v10 = a2[1];
v11 = *(_QWORD *)(v8 + 8 * v9);
if ( v11 )
v12 = *(_DWORD *)(v11 + 12 * v10 + 8);
else
v12 = v10 | ((_DWORD)v9 << 8);
v13 = (result + (v5 & 0x3F)) * (unsigned __int8)v12;
v5 ^= (v13 + (v5 << 8)) ^ ((result + (((unsigned __int8)v5 ^ (unsigned __int8)v13) & 0x3F) + 3) * (v12 >> 8)
+ ((v5 ^ (v13 + (v5 << 8))) << 8));
result += 6LL;
if ( (unsigned long long)(a2 + 2) >= v7 )
break;
v14 = (unsigned long long)(a2 + 4) <= v7;
a2 += 2;
}
while ( v14 );
}
*a4 = v5;
*a5 = result;
return result;
}
|
my_hash_sort_ucs2_nopad:
MOV R9,qword ptr [RCX]
MOV RAX,qword ptr [R8]
CMP RDX,0x2
JL 0x0014c569
PUSH RBP
MOV RBP,RSP
PUSH RBX
ADD RDX,RSI
MOV RDI,qword ptr [RDI + 0x78]
MOV RDI,qword ptr [RDI + 0x8]
LAB_0014c4e8:
MOVZX R10D,byte ptr [RSI]
MOVZX R11D,byte ptr [RSI + 0x1]
MOV RBX,qword ptr [RDI + R10*0x8]
TEST RBX,RBX
JZ 0x0014c505
LEA R10,[R11 + R11*0x2]
MOV R10D,dword ptr [RBX + R10*0x4 + 0x8]
JMP 0x0014c50c
LAB_0014c505:
SHL R10D,0x8
OR R10,R11
LAB_0014c50c:
MOV R11D,R9D
AND R11D,0x3f
ADD R11,RAX
MOVZX EBX,R10B
IMUL RBX,R11
MOV R11,R9
SHL R11,0x8
ADD R11,RBX
XOR R11,R9
MOV R9D,R11D
AND R9D,0x3f
ADD R9,RAX
ADD R9,0x3
SHR R10D,0x8
IMUL R10,R9
MOV R9,R11
SHL R9,0x8
ADD R9,R10
XOR R9,R11
ADD RAX,0x6
LEA R10,[RSI + 0x2]
CMP R10,RDX
JNC 0x0014c567
ADD RSI,0x4
CMP RSI,RDX
MOV RSI,R10
JBE 0x0014c4e8
LAB_0014c567:
POP RBX
POP RBP
LAB_0014c569:
MOV qword ptr [RCX],R9
MOV qword ptr [R8],RAX
RET
|
void my_hash_sort_ucs2_nopad(long param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
long lVar1;
long lVar2;
byte *pbVar3;
byte *pbVar4;
ulong uVar5;
ulong uVar6;
uVar6 = *param_4;
lVar2 = *param_5;
if (1 < param_3) {
pbVar3 = param_2;
do {
lVar1 = *(long *)(*(long *)(*(long *)(param_1 + 0x78) + 8) + (ulong)*pbVar3 * 8);
if (lVar1 == 0) {
uVar5 = (ulong)CONCAT11(*pbVar3,pbVar3[1]);
}
else {
uVar5 = (ulong)*(uint *)(lVar1 + 8 + (ulong)pbVar3[1] * 0xc);
}
uVar6 = uVar6 * 0x100 + (uVar5 & 0xff) * ((ulong)((uint)uVar6 & 0x3f) + lVar2) ^ uVar6;
uVar6 = uVar6 * 0x100 + (uVar5 >> 8) * ((ulong)((uint)uVar6 & 0x3f) + lVar2 + 3) ^ uVar6;
lVar2 = lVar2 + 6;
} while ((pbVar3 + 2 < param_2 + param_3) &&
(pbVar4 = pbVar3 + 4, pbVar3 = pbVar3 + 2, pbVar4 <= param_2 + param_3));
}
*param_4 = uVar6;
*param_5 = lVar2;
return;
}
|
|
10,813 |
ggml_backend_reg_by_name
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend-reg.cpp
|
ggml_backend_reg_t ggml_backend_reg_by_name(const char * name) {
for (size_t i = 0; i < ggml_backend_reg_count(); i++) {
ggml_backend_reg_t reg = ggml_backend_reg_get(i);
if (striequals(ggml_backend_reg_name(reg), name)) {
return reg;
}
}
return nullptr;
}
|
O0
|
cpp
|
ggml_backend_reg_by_name:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x18500
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1afbf
movq -0x18(%rbp), %rdi
callq 0x18e30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x19ac0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1afe0
testb $0x1, %al
jne 0x1afa5
jmp 0x1afaf
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1afc7
jmp 0x1afb1
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1af64
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ggml_backend_reg_by_name:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], 0
loc_1AF64:
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
call _ggml_backend_reg_count
mov rcx, rax
mov rax, [rbp+var_28]
cmp rax, rcx
jnb short loc_1AFBF
mov rdi, [rbp+var_18]
call _ggml_backend_reg_get
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
call _ggml_backend_reg_name
mov rdi, rax; char *
mov rsi, [rbp+var_10]; char *
call _ZL10striequalsPKcS0_; striequals(char const*,char const*)
test al, 1
jnz short loc_1AFA5
jmp short loc_1AFAF
loc_1AFA5:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp short loc_1AFC7
loc_1AFAF:
jmp short $+2
loc_1AFB1:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_1AF64
loc_1AFBF:
mov [rbp+var_8], 0
loc_1AFC7:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
long long ggml_backend_reg_by_name(const char *a1)
{
const char *v1; // rdi
long long v3; // [rsp+10h] [rbp-20h]
unsigned long long i; // [rsp+18h] [rbp-18h]
for ( i = 0LL; i < ggml_backend_reg_count(); ++i )
{
v3 = ggml_backend_reg_get(i);
v1 = (const char *)ggml_backend_reg_name(v3);
if ( (striequals(v1, a1) & 1) != 0 )
return v3;
}
return 0LL;
}
|
ggml_backend_reg_by_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],0x0
LAB_0011af64:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
CALL 0x00118500
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,RCX
JNC 0x0011afbf
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00118e30
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00119ac0
MOV RDI,RAX
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0011afe0
TEST AL,0x1
JNZ 0x0011afa5
JMP 0x0011afaf
LAB_0011afa5:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0011afc7
LAB_0011afaf:
JMP 0x0011afb1
LAB_0011afb1:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0011af64
LAB_0011afbf:
MOV qword ptr [RBP + -0x8],0x0
LAB_0011afc7:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int8 ggml_backend_reg_by_name(char *param_1)
{
ulong uVar1;
int8 uVar2;
char *pcVar3;
ulong local_20;
local_20 = 0;
while( true ) {
uVar1 = ggml_backend_reg_count();
if (uVar1 <= local_20) {
return 0;
}
uVar2 = ggml_backend_reg_get(local_20);
pcVar3 = (char *)ggml_backend_reg_name(uVar2);
uVar1 = striequals(pcVar3,param_1);
if ((uVar1 & 1) != 0) break;
local_20 = local_20 + 1;
}
return uVar2;
}
|
|
10,814 |
ggml_backend_reg_by_name
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend-reg.cpp
|
ggml_backend_reg_t ggml_backend_reg_by_name(const char * name) {
for (size_t i = 0; i < ggml_backend_reg_count(); i++) {
ggml_backend_reg_t reg = ggml_backend_reg_get(i);
if (striequals(ggml_backend_reg_name(reg), name)) {
return reg;
}
}
return nullptr;
}
|
O1
|
cpp
|
ggml_backend_reg_by_name:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6db5
movq 0x95cb(%rip), %rax # 0x104a0
cmpq 0x95bc(%rip), %rax # 0x10498
je 0x6f26
xorl %r15d, %r15d
movq %r15, %rdi
callq 0x6360
movq %rax, %r12
movq %rax, %rdi
callq 0x65c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6f38
testb %al, %al
cmovneq %r12, %r14
jne 0x6f29
incq %r15
callq 0x6db5
movq 0x958a(%rip), %rax # 0x104a0
subq 0x957b(%rip), %rax # 0x10498
sarq $0x4, %rax
cmpq %rax, %r15
jb 0x6ee1
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
ggml_backend_reg_by_name:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
call _ZL7get_regv; get_reg(void)
mov rax, cs:qword_104A0
cmp rax, cs:_ZZL7get_regvE3reg; get_reg(void)::reg
jz short loc_6F26
xor r15d, r15d
loc_6EE1:
mov rdi, r15
call _ggml_backend_reg_get
mov r12, rax
mov rdi, rax
call _ggml_backend_reg_name
mov rdi, rax; char *
mov rsi, rbx; char *
call _ZL10striequalsPKcS0_; striequals(char const*,char const*)
test al, al
cmovnz r14, r12
jnz short loc_6F29
inc r15
call _ZL7get_regv; get_reg(void)
mov rax, cs:qword_104A0
sub rax, cs:_ZZL7get_regvE3reg; get_reg(void)::reg
sar rax, 4
cmp r15, rax
jb short loc_6EE1
loc_6F26:
xor r14d, r14d
loc_6F29:
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long ggml_backend_reg_by_name(char *a1)
{
unsigned long long v1; // r15
long long v2; // r12
const char *v3; // rax
get_reg();
if ( qword_104A0 == get_reg(void)::reg )
return 0LL;
v1 = 0LL;
while ( 1 )
{
v2 = ggml_backend_reg_get(v1);
v3 = (const char *)ggml_backend_reg_name(v2);
if ( (unsigned __int8)striequals(v3, a1) )
break;
++v1;
get_reg();
if ( v1 >= (qword_104A0 - get_reg(void)::reg) >> 4 )
return 0LL;
}
return v2;
}
|
ggml_backend_reg_by_name:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00106db5
MOV RAX,qword ptr [0x001104a0]
CMP RAX,qword ptr [0x00110498]
JZ 0x00106f26
XOR R15D,R15D
LAB_00106ee1:
MOV RDI,R15
CALL 0x00106360
MOV R12,RAX
MOV RDI,RAX
CALL 0x001065c0
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00106f38
TEST AL,AL
CMOVNZ R14,R12
JNZ 0x00106f29
INC R15
CALL 0x00106db5
MOV RAX,qword ptr [0x001104a0]
SUB RAX,qword ptr [0x00110498]
SAR RAX,0x4
CMP R15,RAX
JC 0x00106ee1
LAB_00106f26:
XOR R14D,R14D
LAB_00106f29:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8 ggml_backend_reg_by_name(char *param_1)
{
char cVar1;
int8 uVar2;
char *pcVar3;
ulong uVar4;
get_reg();
if (DAT_001104a0 != get_reg()::reg) {
uVar4 = 0;
do {
uVar2 = ggml_backend_reg_get(uVar4);
pcVar3 = (char *)ggml_backend_reg_name(uVar2);
cVar1 = striequals(pcVar3,param_1);
if (cVar1 != '\0') {
return uVar2;
}
uVar4 = uVar4 + 1;
get_reg();
} while (uVar4 < (ulong)(DAT_001104a0 - get_reg()::reg >> 4));
}
return 0;
}
|
|
10,815 |
set_dynamic
|
eloqsql/mysys/array.c
|
my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element, uint idx)
{
if (idx >= array->elements)
{
if (idx >= array->max_element && allocate_dynamic(array, idx))
return TRUE;
bzero((uchar*) (array->buffer+array->elements*array->size_of_element),
(idx - array->elements)*array->size_of_element);
array->elements=idx+1;
}
memcpy(array->buffer+(idx * array->size_of_element),element,
(size_t) array->size_of_element);
return FALSE;
}
|
O3
|
c
|
set_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %eax
cmpl %edx, %eax
ja 0x918fe
cmpl %r14d, 0xc(%r15)
ja 0x918db
movq %r15, %rdi
movl %r14d, %esi
callq 0x91921
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x91916
movl 0x8(%r15), %eax
movl 0x14(%r15), %ecx
movl %r14d, %edx
subl %eax, %edx
imull %ecx, %edx
movl %ecx, %edi
imull %eax, %edi
addq (%r15), %rdi
xorl %esi, %esi
callq 0x292c0
leal 0x1(%r14), %eax
movl %eax, 0x8(%r15)
movl 0x14(%r15), %edx
imull %edx, %r14d
addq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29080
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
set_dynamic:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, edx
mov rbx, rsi
mov r15, rdi
mov eax, [rdi+8]
cmp eax, edx
ja short loc_918FE
cmp [r15+0Ch], r14d
ja short loc_918DB
mov rdi, r15
mov esi, r14d
call allocate_dynamic
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_91916
mov eax, [r15+8]
loc_918DB:
mov ecx, [r15+14h]
mov edx, r14d
sub edx, eax
imul edx, ecx
mov edi, ecx
imul edi, eax
add rdi, [r15]
xor esi, esi
call _memset
lea eax, [r14+1]
mov [r15+8], eax
loc_918FE:
mov edx, [r15+14h]
imul r14d, edx
add r14, [r15]
mov rdi, r14
mov rsi, rbx
call _memcpy
xor eax, eax
loc_91916:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
char set_dynamic(long long a1, long long a2, long long a3)
{
int v3; // r14d
unsigned int v4; // eax
char dynamic; // cl
char result; // al
v3 = a3;
v4 = *(_DWORD *)(a1 + 8);
if ( v4 <= (unsigned int)a3 )
{
if ( *(_DWORD *)(a1 + 12) <= (unsigned int)a3 )
{
dynamic = allocate_dynamic(a1, (unsigned int)a3, a3);
result = 1;
if ( dynamic )
return result;
v4 = *(_DWORD *)(a1 + 8);
}
memset(*(_QWORD *)a1 + v4 * *(_DWORD *)(a1 + 20), 0LL, *(_DWORD *)(a1 + 20) * (v3 - v4));
*(_DWORD *)(a1 + 8) = v3 + 1;
}
memcpy(*(_QWORD *)a1 + (unsigned int)(*(_DWORD *)(a1 + 20) * v3), a2, *(unsigned int *)(a1 + 20));
return 0;
}
|
set_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,EDX
MOV RBX,RSI
MOV R15,RDI
MOV EAX,dword ptr [RDI + 0x8]
CMP EAX,EDX
JA 0x001918fe
CMP dword ptr [R15 + 0xc],R14D
JA 0x001918db
MOV RDI,R15
MOV ESI,R14D
CALL 0x00191921
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x00191916
MOV EAX,dword ptr [R15 + 0x8]
LAB_001918db:
MOV ECX,dword ptr [R15 + 0x14]
MOV EDX,R14D
SUB EDX,EAX
IMUL EDX,ECX
MOV EDI,ECX
IMUL EDI,EAX
ADD RDI,qword ptr [R15]
XOR ESI,ESI
CALL 0x001292c0
LEA EAX,[R14 + 0x1]
MOV dword ptr [R15 + 0x8],EAX
LAB_001918fe:
MOV EDX,dword ptr [R15 + 0x14]
IMUL R14D,EDX
ADD R14,qword ptr [R15]
MOV RDI,R14
MOV RSI,RBX
CALL 0x00129080
XOR EAX,EAX
LAB_00191916:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 set_dynamic(long *param_1,void *param_2,uint param_3)
{
char cVar1;
uint uVar2;
uVar2 = *(uint *)(param_1 + 1);
if (uVar2 <= param_3) {
if (*(uint *)((long)param_1 + 0xc) <= param_3) {
cVar1 = allocate_dynamic(param_1);
if (cVar1 != '\0') {
return 1;
}
uVar2 = *(uint *)(param_1 + 1);
}
memset((void *)((ulong)(*(int *)((long)param_1 + 0x14) * uVar2) + *param_1),0,
(ulong)((param_3 - uVar2) * *(int *)((long)param_1 + 0x14)));
*(uint *)(param_1 + 1) = param_3 + 1;
}
memcpy((void *)((ulong)(param_3 * *(uint *)((long)param_1 + 0x14)) + *param_1),param_2,
(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
|
|
10,816 |
js_cond_timedwait
|
bluesky950520[P]quickjs/cutils.c
|
int js_cond_timedwait(js_cond_t *cond, js_mutex_t *mutex, uint64_t timeout) {
int r;
struct timespec ts;
#if !defined(__APPLE__)
timeout += js__hrtime_ns();
#endif
ts.tv_sec = timeout / NANOSEC;
ts.tv_nsec = timeout % NANOSEC;
#if defined(__APPLE__) && defined(__MACH__)
r = pthread_cond_timedwait_relative_np(cond, mutex, &ts);
#else
r = pthread_cond_timedwait(cond, mutex, &ts);
#endif
if (r == 0)
return 0;
if (r == ETIMEDOUT)
return -1;
abort();
/* Pacify some compilers. */
return -1;
}
|
O1
|
c
|
js_cond_timedwait:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2073c
movq %rax, %rcx
addq %rbx, %rcx
movq %rcx, %rax
shrq $0x9, %rax
movabsq $0x44b82fa09b5a53, %rdx # imm = 0x44B82FA09B5A53
mulq %rdx
shrq $0xb, %rdx
movq %rsp, %rax
movq %rdx, (%rax)
imulq $0x3b9aca00, %rdx, %rdx # imm = 0x3B9ACA00
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xe7b0
testl %eax, %eax
je 0x208e1
cmpl $0x6e, %eax
jne 0x208eb
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xe090
|
js_cond_timedwait:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
call js__hrtime_ns
mov rcx, rax
add rcx, rbx
mov rax, rcx
shr rax, 9
mov rdx, 44B82FA09B5A53h
mul rdx
shr rdx, 0Bh
mov rax, rsp
mov [rax], rdx
imul rdx, 3B9ACA00h
sub rcx, rdx
mov [rax+8], rcx
mov rdi, r15
mov rsi, r14
mov rdx, rax
call _pthread_cond_timedwait
test eax, eax
jz short loc_208E1
cmp eax, 6Eh ; 'n'
jnz short loc_208EB
mov eax, 0FFFFFFFFh
loc_208E1:
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_208EB:
call _abort
|
long long js_cond_timedwait(long long a1, long long a2, long long a3)
{
long long v4; // rax
long long result; // rax
_QWORD v6[5]; // [rsp+0h] [rbp-28h] BYREF
v4 = js__hrtime_ns();
v6[0] = (a3 + v4) / 0x3B9ACA00uLL;
v6[1] = (a3 + v4) % 0x3B9ACA00uLL;
result = pthread_cond_timedwait(a1, a2, v6);
if ( (_DWORD)result )
{
if ( (_DWORD)result != 110 )
abort();
return 0xFFFFFFFFLL;
}
return result;
}
|
js_cond_timedwait:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
CALL 0x0012073c
MOV RCX,RAX
ADD RCX,RBX
MOV RAX,RCX
SHR RAX,0x9
MOV RDX,0x44b82fa09b5a53
MUL RDX
SHR RDX,0xb
MOV RAX,RSP
MOV qword ptr [RAX],RDX
IMUL RDX,RDX,0x3b9aca00
SUB RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RAX
CALL 0x0010e7b0
TEST EAX,EAX
JZ 0x001208e1
CMP EAX,0x6e
JNZ 0x001208eb
MOV EAX,0xffffffff
LAB_001208e1:
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
LAB_001208eb:
CALL 0x0010e090
|
int js_cond_timedwait(pthread_cond_t *param_1,pthread_mutex_t *param_2,long param_3)
{
int iVar1;
long lVar2;
timespec local_28;
lVar2 = js__hrtime_ns();
local_28.tv_sec = (ulong)(lVar2 + param_3) / 1000000000;
local_28.tv_nsec = (ulong)(lVar2 + param_3) % 1000000000;
iVar1 = pthread_cond_timedwait(param_1,param_2,&local_28);
if (iVar1 != 0) {
if (iVar1 != 0x6e) {
/* WARNING: Subroutine does not return */
abort();
}
iVar1 = -1;
}
return iVar1;
}
|
|
10,817 |
js_cond_timedwait
|
bluesky950520[P]quickjs/cutils.c
|
int js_cond_timedwait(js_cond_t *cond, js_mutex_t *mutex, uint64_t timeout) {
int r;
struct timespec ts;
#if !defined(__APPLE__)
timeout += js__hrtime_ns();
#endif
ts.tv_sec = timeout / NANOSEC;
ts.tv_nsec = timeout % NANOSEC;
#if defined(__APPLE__) && defined(__MACH__)
r = pthread_cond_timedwait_relative_np(cond, mutex, &ts);
#else
r = pthread_cond_timedwait(cond, mutex, &ts);
#endif
if (r == 0)
return 0;
if (r == ETIMEDOUT)
return -1;
abort();
/* Pacify some compilers. */
return -1;
}
|
O2
|
c
|
js_cond_timedwait:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1a8c4
addq %rbx, %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rsp, %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movq %r15, %rdi
movq %r14, %rsi
movq %rcx, %rdx
callq 0xe7d0
testl %eax, %eax
je 0x1aa48
cmpl $0x6e, %eax
jne 0x1aa52
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xe090
|
js_cond_timedwait:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
call js__hrtime_ns
add rax, rbx
mov ecx, 3B9ACA00h
xor edx, edx
div rcx
mov rcx, rsp
mov [rcx], rax
mov [rcx+8], rdx
mov rdi, r15
mov rsi, r14
mov rdx, rcx
call _pthread_cond_timedwait
test eax, eax
jz short loc_1AA48
cmp eax, 6Eh ; 'n'
jnz short loc_1AA52
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_1AA48:
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_1AA52:
call _abort
|
long long js_cond_timedwait(long long a1, long long a2, long long a3)
{
long long v4; // rax
long long result; // rax
_QWORD v6[5]; // [rsp+0h] [rbp-28h] BYREF
v4 = js__hrtime_ns();
v6[0] = (a3 + v4) / 0x3B9ACA00uLL;
v6[1] = (a3 + v4) % 0x3B9ACA00uLL;
result = pthread_cond_timedwait(a1, a2, v6);
if ( (_DWORD)result )
{
if ( (_DWORD)result != 110 )
abort();
return -1LL;
}
return result;
}
|
js_cond_timedwait:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
CALL 0x0011a8c4
ADD RAX,RBX
MOV ECX,0x3b9aca00
XOR EDX,EDX
DIV RCX
MOV RCX,RSP
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RDX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RCX
CALL 0x0010e7d0
TEST EAX,EAX
JZ 0x0011aa48
CMP EAX,0x6e
JNZ 0x0011aa52
PUSH -0x1
POP RAX
LAB_0011aa48:
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
LAB_0011aa52:
CALL 0x0010e090
|
int js_cond_timedwait(pthread_cond_t *param_1,pthread_mutex_t *param_2,long param_3)
{
int iVar1;
long lVar2;
timespec local_28;
lVar2 = js__hrtime_ns();
local_28.tv_sec = (ulong)(lVar2 + param_3) / 1000000000;
local_28.tv_nsec = (ulong)(lVar2 + param_3) % 1000000000;
iVar1 = pthread_cond_timedwait(param_1,param_2,&local_28);
if (iVar1 != 0) {
if (iVar1 != 0x6e) {
/* WARNING: Subroutine does not return */
abort();
}
iVar1 = -1;
}
return iVar1;
}
|
|
10,818 |
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::~ansicolor_sink()
|
AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink.h
|
~ansicolor_sink() override = default;
|
O3
|
c
|
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::~ansicolor_sink():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x75def(%rip), %rax # 0xb2638
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x2b0(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rax
movq -0x10(%r14,%r15), %rdi
cmpq %rdi, %rax
je 0x3c873
movq (%rax), %rsi
incq %rsi
callq 0x11120
addq $-0x20, %r15
cmpq $-0xe0, %r15
jne 0x3c85a
movq 0x1d8(%rbx), %rdi
testq %rdi, %rdi
je 0x3c892
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x1d8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
|
_ZN6spdlog5sinks14ansicolor_sinkINS_7details13console_mutexEED2Ev:
push r15
push r14
push rbx
mov rbx, rdi
lea rax, _ZTVN6spdlog5sinks14ansicolor_sinkINS_7details13console_mutexEEE; `vtable for'spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>
add rax, 10h
mov [rdi], rax
lea r14, [rdi+2B0h]
xor r15d, r15d
loc_3C85A:
lea rax, [r14+r15]
mov rdi, [r14+r15-10h]; void *
cmp rax, rdi
jz short loc_3C873
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C873:
add r15, 0FFFFFFFFFFFFFFE0h
cmp r15, 0FFFFFFFFFFFFFF20h
jnz short loc_3C85A
mov rdi, [rbx+1D8h]
test rdi, rdi
jz short loc_3C892
mov rax, [rdi]
call qword ptr [rax+8]
loc_3C892:
mov qword ptr [rbx+1D8h], 0
pop rbx
pop r14
pop r15
retn
|
void spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::~ansicolor_sink(_QWORD *a1)
{
_QWORD *v2; // r14
long long i; // r15
_QWORD *v4; // rdi
long long v5; // rdi
*a1 = &`vtable for'spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex> + 2;
v2 = a1 + 86;
for ( i = 0LL; i != -28; i -= 4LL )
{
v4 = (_QWORD *)v2[i - 2];
if ( &v2[i] != v4 )
operator delete(v4, v2[i] + 1LL);
}
v5 = a1[59];
if ( v5 )
(*(void ( **)(long long))(*(_QWORD *)v5 + 8LL))(v5);
a1[59] = 0LL;
}
|
~ansicolor_sink:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1b2638]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
LEA R14,[RDI + 0x2b0]
XOR R15D,R15D
LAB_0013c85a:
LEA RAX,[R14 + R15*0x1]
MOV RDI,qword ptr [R14 + R15*0x1 + -0x10]
CMP RAX,RDI
JZ 0x0013c873
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00111120
LAB_0013c873:
ADD R15,-0x20
CMP R15,-0xe0
JNZ 0x0013c85a
MOV RDI,qword ptr [RBX + 0x1d8]
TEST RDI,RDI
JZ 0x0013c892
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0013c892:
MOV qword ptr [RBX + 0x1d8],0x0
POP RBX
POP R14
POP R15
RET
|
/* spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::~ansicolor_sink() */
void __thiscall
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::~ansicolor_sink
(ansicolor_sink<spdlog::details::console_mutex> *this)
{
long lVar1;
*(int ***)this = &PTR__ansicolor_sink_001b2648;
lVar1 = 0;
do {
if (this + lVar1 + 0x2b0 !=
*(ansicolor_sink<spdlog::details::console_mutex> **)(this + lVar1 + 0x2a0)) {
operator_delete(*(ansicolor_sink<spdlog::details::console_mutex> **)(this + lVar1 + 0x2a0),
*(long *)(this + lVar1 + 0x2b0) + 1);
}
lVar1 = lVar1 + -0x20;
} while (lVar1 != -0xe0);
if (*(long **)(this + 0x1d8) != (long *)0x0) {
(**(code **)(**(long **)(this + 0x1d8) + 8))();
}
*(int8 *)(this + 0x1d8) = 0;
return;
}
|
|
10,819 |
mysql_stmt_fetch_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_stmt_fetch_start(int *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_fetch,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
1,
r_int,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_fetch(stmt);
return 0;
})
}
|
O3
|
c
|
mysql_stmt_fetch_start:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x2ee5b
movq 0x480(%rax), %rax
movq 0x28(%rax), %r15
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
movb $0x1, 0x14(%r15)
leaq 0x38(%r15), %rdi
leaq 0xa2(%rip), %rsi # 0x2eee3
callq 0x305a4
movw $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x2ee65
movb $0x1, 0x15(%r15)
movl (%r15), %eax
jmp 0x2eed8
movq %r14, %rdi
callq 0x233bf
jmp 0x2eed4
js 0x2ee6d
movl 0x8(%r15), %eax
jmp 0x2eed4
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1eef5(%rip), %rax # 0x4dd80
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x1eeda(%rip), %rax # 0x4dd90
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movl $0x1, %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
mysql_stmt_fetch_start:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
test rax, rax
jz short loc_2EE5B
mov rax, [rax+480h]
mov r15, [rax+28h]
lea rdx, [rbp+var_20]
mov [rdx], r14
mov byte ptr [r15+14h], 1
lea rdi, [r15+38h]
lea rsi, mysql_stmt_fetch_start_internal
call my_context_spawn
mov word ptr [r15+14h], 0
test eax, eax
jle short loc_2EE65
mov byte ptr [r15+15h], 1
mov eax, [r15]
jmp short loc_2EED8
loc_2EE5B:
mov rdi, r14
call mysql_stmt_fetch
jmp short loc_2EED4
loc_2EE65:
js short loc_2EE6D
mov eax, [r15+8]
jmp short loc_2EED4
loc_2EE6D:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov eax, 1
loc_2EED4:
mov [rbx], eax
xor eax, eax
loc_2EED8:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long mysql_stmt_fetch_start(int *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
int v7; // eax
long long v8[4]; // [rsp+0h] [rbp-20h] BYREF
v8[0] = v2;
v3 = *(_QWORD *)(a2 + 56);
if ( v3 )
{
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
v8[0] = a2;
*((_BYTE *)v4 + 20) = 1;
v5 = my_context_spawn(v4 + 14, mysql_stmt_fetch_start_internal, v8);
*((_WORD *)v4 + 10) = 0;
if ( v5 > 0 )
{
*((_BYTE *)v4 + 21) = 1;
return *v4;
}
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v7 = 1;
}
else
{
v7 = v4[2];
}
}
else
{
v7 = mysql_stmt_fetch(a2);
}
*a1 = v7;
return 0LL;
}
|
mysql_stmt_fetch_start:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
TEST RAX,RAX
JZ 0x0012ee5b
MOV RAX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RAX + 0x28]
LEA RDX,[RBP + -0x20]
MOV qword ptr [RDX],R14
MOV byte ptr [R15 + 0x14],0x1
LEA RDI,[R15 + 0x38]
LEA RSI,[0x12eee3]
CALL 0x001305a4
MOV word ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012ee65
MOV byte ptr [R15 + 0x15],0x1
MOV EAX,dword ptr [R15]
JMP 0x0012eed8
LAB_0012ee5b:
MOV RDI,R14
CALL 0x001233bf
JMP 0x0012eed4
LAB_0012ee65:
JS 0x0012ee6d
MOV EAX,dword ptr [R15 + 0x8]
JMP 0x0012eed4
LAB_0012ee6d:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x14dd80]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x14dd90]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV EAX,0x1
LAB_0012eed4:
MOV dword ptr [RBX],EAX
XOR EAX,EAX
LAB_0012eed8:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_fetch_start(int4 *param_1,long param_2)
{
int4 *puVar1;
int iVar2;
int4 uVar3;
if (*(long *)(param_2 + 0x38) == 0) {
uVar3 = mysql_stmt_fetch(param_2);
}
else {
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(puVar1 + 5) = 1;
iVar2 = my_context_spawn(puVar1 + 0xe,mysql_stmt_fetch_start_internal);
*(int2 *)(puVar1 + 5) = 0;
if (0 < iVar2) {
*(int1 *)((long)puVar1 + 0x15) = 1;
return *puVar1;
}
if (iVar2 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_0014ddd0,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar3 = 1;
}
else {
uVar3 = puVar1[2];
}
}
*param_1 = uVar3;
return 0;
}
|
|
10,820 |
SchemaConverter::check_errors()
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
void check_errors() {
if (!_errors.empty()) {
throw std::runtime_error("JSON schema conversion failed:\n" + string_join(_errors, "\n"));
}
if (!_warnings.empty()) {
fprintf(stderr, "WARNING: JSON schema conversion was incomplete: %s\n", string_join(_warnings, "; ").c_str());
}
}
|
O1
|
cpp
|
SchemaConverter::check_errors():
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0xc8(%rdi), %rax
cmpq 0xd0(%rdi), %rax
jne 0xe3c4b
movq 0xe0(%r14), %rax
cmpq 0xe8(%r14), %rax
jne 0xe3bf0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x75391(%rip), %rax # 0x158f88
movq (%rax), %r15
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x3924c(%rip), %rsi # 0x11ce56
leaq 0x39247(%rip), %rdx # 0x11ce58
leaq 0x8(%rsp), %rdi
callq 0x2698a
addq $0xe0, %r14
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x966b4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1fee4
jmp 0xe3be5
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x284d1(%rip), %rsi # 0x10c139
leaq 0x284cb(%rip), %rdx # 0x10c13a
leaq 0x48(%rsp), %rdi
callq 0x2698a
addq $0xc8, %r14
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r14, %rsi
callq 0x966b4
leaq 0x39169(%rip), %rsi # 0x11ce02
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x9d29f
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1e420
xorl %ebp, %ebp
movq 0x75327(%rip), %rsi # 0x158fe8
movq 0x75290(%rip), %rdx # 0x158f58
movq %rbx, %rdi
callq 0x1e5a0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe3cf6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1dc40
jmp 0xe3cf6
movq %rax, %r14
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe3d19
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1dc40
jmp 0xe3d19
movq %rax, %r14
movb $0x1, %bpl
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xe3d38
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1dc40
jmp 0xe3d38
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xe3d66
movq %rbx, %rdi
callq 0x1d8b0
jmp 0xe3d66
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0xe3d66
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1dc40
jmp 0xe3d66
movq %rax, %r14
movq %r14, %rdi
callq 0x1e650
|
_ZN15SchemaConverter12check_errorsEv:
push rbp
push r15
push r14
push rbx
sub rsp, 68h
mov r14, rdi
mov rax, [rdi+0C8h]
cmp rax, [rdi+0D0h]
jnz short loc_E3C4B
mov rax, [r14+0E0h]
cmp rax, [r14+0E8h]
jnz short loc_E3BF0
loc_E3BE5:
add rsp, 68h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_E3BF0:
mov rax, cs:stderr_ptr
mov r15, [rax]
lea rbx, [rsp+88h+var_70]
mov [rbx-10h], rbx
lea rsi, asc_11CE56; "; "
lea rdx, asc_11CE56+2; ""
lea rdi, [rsp+88h+var_80]
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)
add r14, 0E0h
lea rdi, [rsp+88h+var_60]
lea rdx, [rsp+88h+var_80]
mov rsi, r14
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
lea rdi, [rsp+88h+var_60]
lea rdx, [rsp+88h+var_80]
mov rsi, r15
mov rcx, rbx
call _ZN15SchemaConverter12check_errorsEv_cold_1; SchemaConverter::check_errors(void) [clone]
jmp short loc_E3BE5
loc_E3C4B:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+88h+var_30]
mov [r15-10h], r15
lea rsi, aSFailedToLoadI+29h; "\n"
lea rdx, aSFailedToLoadI+2Ah; ""
lea rdi, [rsp+88h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
add r14, 0C8h
lea rdi, [rsp+88h+var_80]
lea rdx, [rsp+88h+var_40]
mov rsi, r14
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
lea rsi, aJsonSchemaConv; "JSON schema conversion failed:\n"
lea rdi, [rsp+88h+var_60]
lea rdx, [rsp+88h+var_80]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+88h+var_60]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+88h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E3CF6
mov rsi, [rsp+88h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_E3CF6
mov r14, rax
mov bpl, 1
loc_E3CF6:
lea rax, [rsp+88h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E3D19
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_E3D19
mov r14, rax
mov bpl, 1
loc_E3D19:
mov rdi, [rsp+88h+var_40]; void *
cmp rdi, r15
jz short loc_E3D38
mov rsi, [rsp+88h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_E3D38
mov r14, rax
mov bpl, 1
loc_E3D38:
test bpl, bpl
jz short loc_E3D66
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_E3D66
mov r14, rax
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, rbx
jz short loc_E3D66
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_E3D66
mov r14, rax
loc_E3D66:
mov rdi, r14
call __Unwind_Resume
|
void SchemaConverter::check_errors(SchemaConverter *this)
{
long long v1; // r15
void *exception; // rbx
void *v3[2]; // [rsp+8h] [rbp-80h] BYREF
_QWORD v4[2]; // [rsp+18h] [rbp-70h] BYREF
const char *v5[2]; // [rsp+28h] [rbp-60h] BYREF
void *v6[2]; // [rsp+48h] [rbp-40h] BYREF
long long v7; // [rsp+58h] [rbp-30h] BYREF
if ( *((_QWORD *)this + 25) != *((_QWORD *)this + 26) )
{
exception = __cxa_allocate_exception(0x10uLL);
v6[0] = &v7;
std::string::_M_construct<char const*>(v6, "\n", (long long)"");
string_join((long long)v3, (_QWORD *)this + 25, v6);
std::operator+<char>((long long)v5, (long long)"JSON schema conversion failed:\n", (long long)v3);
std::runtime_error::runtime_error(exception, v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( *((_QWORD *)this + 28) != *((_QWORD *)this + 29) )
{
v1 = stderr;
v3[0] = v4;
std::string::_M_construct<char const*>(v3, "; ", (long long)"");
string_join((long long)v5, (_QWORD *)this + 28, v3);
SchemaConverter::check_errors(v5, v1, v3, v4);
}
}
|
check_errors:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x68
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0xc8]
CMP RAX,qword ptr [RDI + 0xd0]
JNZ 0x001e3c4b
MOV RAX,qword ptr [R14 + 0xe0]
CMP RAX,qword ptr [R14 + 0xe8]
JNZ 0x001e3bf0
LAB_001e3be5:
ADD RSP,0x68
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001e3bf0:
MOV RAX,qword ptr [0x00258f88]
MOV R15,qword ptr [RAX]
LEA RBX,[RSP + 0x18]
MOV qword ptr [RBX + -0x10],RBX
LAB_001e3c03:
LEA RSI,[0x21ce56]
LEA RDX,[0x21ce58]
LEA RDI,[RSP + 0x8]
CALL 0x0012698a
LAB_001e3c1b:
ADD R14,0xe0
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
MOV RSI,R14
CALL 0x001966b4
LAB_001e3c34:
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
MOV RSI,R15
MOV RCX,RBX
CALL 0x0011fee4
JMP 0x001e3be5
LAB_001e3c4b:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LEA R15,[RSP + 0x58]
MOV qword ptr [R15 + -0x10],R15
LAB_001e3c61:
LEA RSI,[0x20c139]
LEA RDX,[0x20c13a]
LEA RDI,[RSP + 0x48]
CALL 0x0012698a
LAB_001e3c79:
ADD R14,0xc8
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x48]
MOV RSI,R14
CALL 0x001966b4
LAB_001e3c92:
LEA RSI,[0x21ce02]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x0019d29f
MOV BPL,0x1
LAB_001e3cab:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0011e420
XOR EBP,EBP
MOV RSI,qword ptr [0x00258fe8]
MOV RDX,qword ptr [0x00258f58]
MOV RDI,RBX
CALL 0x0011e5a0
|
/* SchemaConverter::check_errors() */
void __thiscall SchemaConverter::check_errors(SchemaConverter *this)
{
runtime_error *this_00;
int1 *local_80 [2];
int1 local_70 [16];
vector local_60 [32];
int1 *local_40 [2];
int1 local_30 [16];
if (*(long *)(this + 200) == *(long *)(this + 0xd0)) {
if (*(long *)(this + 0xe0) != *(long *)(this + 0xe8)) {
local_80[0] = local_70;
/* try { // try from 001e3c03 to 001e3c1a has its CatchHandler @ 001e3d63 */
std::__cxx11::string::_M_construct<char_const*>(local_80,&DAT_0021ce56,&DAT_0021ce58);
/* try { // try from 001e3c1b to 001e3c33 has its CatchHandler @ 001e3d47 */
string_join(local_60,(string *)(this + 0xe0));
check_errors();
}
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
local_40[0] = local_30;
/* try { // try from 001e3c61 to 001e3c78 has its CatchHandler @ 001e3d32 */
std::__cxx11::string::_M_construct<char_const*>(local_40,"\n","");
/* try { // try from 001e3c79 to 001e3c91 has its CatchHandler @ 001e3d13 */
string_join((vector *)local_80,(string *)(this + 200));
/* try { // try from 001e3c92 to 001e3ca7 has its CatchHandler @ 001e3cf0 */
std::operator+((char *)local_60,(string *)"JSON schema conversion failed:\n");
/* try { // try from 001e3cab to 001e3ccf has its CatchHandler @ 001e3cd0 */
std::runtime_error::runtime_error(this_00,(string *)local_60);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00258fe8,PTR__runtime_error_00258f58);
}
|
|
10,821 |
my_hash_free
|
eloqsql/mysys/hash.c
|
void my_hash_free(HASH *hash)
{
DBUG_ENTER("my_hash_free");
DBUG_PRINT("enter",("hash:%p elements: %ld",
hash, hash->records));
my_hash_free_elements(hash);
hash->free= 0;
delete_dynamic(&hash->array);
hash->blength= 0;
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_hash_free:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %r14d
testq %r14, %r14
je 0x93c31
movq $0x0, 0x18(%rbx)
cmpq $0x0, 0x60(%rbx)
je 0x93c31
movq 0x28(%rbx), %r15
shlq $0x4, %r14
addq %r15, %r14
movq 0x8(%r15), %rdi
addq $0x10, %r15
callq *0x60(%rbx)
cmpq %r14, %r15
jb 0x93c21
xorl %r14d, %r14d
movq %r14, 0x60(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x91e20
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
my_hash_free:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r14d, [rdi+18h]
test r14, r14
jz short loc_93C31
mov qword ptr [rbx+18h], 0
cmp qword ptr [rbx+60h], 0
jz short loc_93C31
mov r15, [rbx+28h]
shl r14, 4
add r14, r15
loc_93C21:
mov rdi, [r15+8]
add r15, 10h
call qword ptr [rbx+60h]
cmp r15, r14
jb short loc_93C21
loc_93C31:
xor r14d, r14d
mov [rbx+60h], r14
lea rdi, [rbx+28h]
call delete_dynamic
mov [rbx+10h], r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long my_hash_free(long long a1)
{
long long v2; // r14
unsigned long long v3; // r15
unsigned long long v4; // r14
long long v5; // rdi
long long result; // rax
v2 = *(unsigned int *)(a1 + 24);
if ( *(_DWORD *)(a1 + 24) )
{
*(_QWORD *)(a1 + 24) = 0LL;
if ( *(_QWORD *)(a1 + 96) )
{
v3 = *(_QWORD *)(a1 + 40);
v4 = v3 + 16 * v2;
do
{
v5 = *(_QWORD *)(v3 + 8);
v3 += 16LL;
(*(void ( **)(long long))(a1 + 96))(v5);
}
while ( v3 < v4 );
}
}
*(_QWORD *)(a1 + 96) = 0LL;
result = delete_dynamic((long long *)(a1 + 40));
*(_QWORD *)(a1 + 16) = 0LL;
return result;
}
|
my_hash_free:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14D,dword ptr [RDI + 0x18]
TEST R14,R14
JZ 0x00193c31
MOV qword ptr [RBX + 0x18],0x0
CMP qword ptr [RBX + 0x60],0x0
JZ 0x00193c31
MOV R15,qword ptr [RBX + 0x28]
SHL R14,0x4
ADD R14,R15
LAB_00193c21:
MOV RDI,qword ptr [R15 + 0x8]
ADD R15,0x10
CALL qword ptr [RBX + 0x60]
CMP R15,R14
JC 0x00193c21
LAB_00193c31:
XOR R14D,R14D
MOV qword ptr [RBX + 0x60],R14
LEA RDI,[RBX + 0x28]
CALL 0x00191e20
MOV qword ptr [RBX + 0x10],R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void my_hash_free(long param_1)
{
int8 *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
uVar2 = *(uint *)(param_1 + 0x18);
if (((ulong)uVar2 != 0) && (*(int8 *)(param_1 + 0x18) = 0, *(long *)(param_1 + 0x60) != 0))
{
uVar4 = *(ulong *)(param_1 + 0x28);
uVar3 = (ulong)uVar2 * 0x10 + uVar4;
do {
puVar1 = (int8 *)(uVar4 + 8);
uVar4 = uVar4 + 0x10;
(**(code **)(param_1 + 0x60))(*puVar1);
} while (uVar4 < uVar3);
}
*(int8 *)(param_1 + 0x60) = 0;
delete_dynamic(param_1 + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
return;
}
|
|
10,822 |
memset
|
seiftnesse[P]memoryallocator/src/custom_alloc_util.c
|
void *_memset(void *dest, int value, size_t count) {
// Validate parameters
if (!dest || count == 0) {
return dest;
}
// Safety check for size
if (count > HEAP_SIZE) {
HEAP_LOG("WARNING: Attempted to set unreasonably large block: %zu bytes\n", count);
return dest;
}
// Cast to byte pointer
uint8_t *d = (uint8_t *) dest;
uint8_t v = (uint8_t) value;
// If setting to zero, we can potentially use a faster method
if (v == 0 && count >= 8) {
// Check if pointer is 8-byte aligned
if (!((uintptr_t) dest & 7)) {
// Fast path: 64-bit aligned zero-fill
uint64_t *d64 = (uint64_t *) dest;
// Set 8 bytes at a time with zero
size_t qwords = count / 8;
for (size_t i = 0; i < qwords; i++) {
*d64++ = 0;
}
// Set remaining bytes
size_t offset = qwords * 8;
for (size_t i = offset; i < count; i++) {
d[i] = 0;
}
return dest;
}
}
// For non-zero values or small sizes, use byte-by-byte approach
// Fill the first few bytes until we reach 8-byte alignment
size_t i = 0;
while (i < count && ((uintptr_t) &d[i] & 7)) {
d[i++] = v;
}
// If the value is the same for each byte, use 64-bit optimization
if (count - i >= 8) {
// Create a 64-bit pattern from the byte
uint64_t pattern = 0;
for (int j = 0; j < 8; j++) {
pattern = (pattern << 8) | v;
}
// Set 8 bytes at a time with the pattern
uint64_t *d64 = (uint64_t *) &d[i];
size_t qwords = (count - i) / 8;
for (size_t j = 0; j < qwords; j++) {
*d64++ = pattern;
}
// Update index
i += qwords * 8;
}
// Set any remaining bytes
while (i < count) {
d[i++] = v;
}
return dest;
}
|
O0
|
c
|
memset:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2db1
cmpq $0x0, -0x20(%rbp)
jne 0x2dbe
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2fda
cmpq $0x4000000, -0x20(%rbp) # imm = 0x4000000
jbe 0x2dd5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2fda
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x0, %eax
jne 0x2e9e
cmpq $0x8, -0x20(%rbp)
jb 0x2e9e
movq -0x10(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x2e9c
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x2e57
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movq $0x0, (%rax)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x2e29
movq -0x40(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2e8f
movq -0x28(%rbp), %rax
movq -0x58(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x2e6b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2fda
jmp 0x2e9e
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x89(%rbp)
jae 0x2ed1
movq -0x28(%rbp), %rax
addq -0x60(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x2edd
jmp 0x2ef8
movb -0x29(%rbp), %dl
movq -0x28(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x60(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x2ea6
movq -0x20(%rbp), %rax
subq -0x60(%rbp), %rax
cmpq $0x8, %rax
jb 0x2fab
movq $0x0, -0x68(%rbp)
movl $0x0, -0x6c(%rbp)
cmpl $0x8, -0x6c(%rbp)
jge 0x2f3d
movq -0x68(%rbp), %rax
shlq $0x8, %rax
movzbl -0x29(%rbp), %ecx
orq %rcx, %rax
movq %rax, -0x68(%rbp)
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x2f19
movq -0x28(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
subq -0x60(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x80(%rbp)
movq $0x0, -0x88(%rbp)
movq -0x88(%rbp), %rax
cmpq -0x80(%rbp), %rax
jae 0x2f9b
movq -0x68(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x78(%rbp)
movq %rcx, (%rax)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x2f64
movq -0x80(%rbp), %rax
shlq $0x3, %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x2fad
movq -0x60(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2fd2
movb -0x29(%rbp), %dl
movq -0x28(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x60(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x2fad
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
|
_memset:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
cmp [rbp+var_10], 0
jz short loc_2DB1
cmp [rbp+var_20], 0
jnz short loc_2DBE
loc_2DB1:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_2FDA
loc_2DBE:
cmp [rbp+var_20], offset unk_4000000
jbe short loc_2DD5
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_2FDA
loc_2DD5:
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov eax, [rbp+var_14]
mov [rbp+var_29], al
movzx eax, [rbp+var_29]
cmp eax, 0
jnz loc_2E9E
cmp [rbp+var_20], 8
jb loc_2E9E
mov rax, [rbp+var_10]
and rax, 7
cmp rax, 0
jnz loc_2E9C
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
shr rax, 3
mov [rbp+var_40], rax
mov [rbp+var_48], 0
loc_2E29:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_40]
jnb short loc_2E57
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 8
mov [rbp+var_38], rcx
mov qword ptr [rax], 0
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_48], rax
jmp short loc_2E29
loc_2E57:
mov rax, [rbp+var_40]
shl rax, 3
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov [rbp+var_58], rax
loc_2E6B:
mov rax, [rbp+var_58]
cmp rax, [rbp+var_20]
jnb short loc_2E8F
mov rax, [rbp+var_28]
mov rcx, [rbp+var_58]
mov byte ptr [rax+rcx], 0
mov rax, [rbp+var_58]
add rax, 1
mov [rbp+var_58], rax
jmp short loc_2E6B
loc_2E8F:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_2FDA
loc_2E9C:
jmp short $+2
loc_2E9E:
mov [rbp+var_60], 0
loc_2EA6:
mov rcx, [rbp+var_60]
xor eax, eax
cmp rcx, [rbp+var_20]
mov [rbp+var_89], al
jnb short loc_2ED1
mov rax, [rbp+var_28]
add rax, [rbp+var_60]
and rax, 7
cmp rax, 0
setnz al
mov [rbp+var_89], al
loc_2ED1:
mov al, [rbp+var_89]
test al, 1
jnz short loc_2EDD
jmp short loc_2EF8
loc_2EDD:
mov dl, [rbp+var_29]
mov rax, [rbp+var_28]
mov rcx, [rbp+var_60]
mov rsi, rcx
add rsi, 1
mov [rbp+var_60], rsi
mov [rax+rcx], dl
jmp short loc_2EA6
loc_2EF8:
mov rax, [rbp+var_20]
sub rax, [rbp+var_60]
cmp rax, 8
jb loc_2FAB
mov [rbp+var_68], 0
mov [rbp+var_6C], 0
loc_2F19:
cmp [rbp+var_6C], 8
jge short loc_2F3D
mov rax, [rbp+var_68]
shl rax, 8
movzx ecx, [rbp+var_29]
or rax, rcx
mov [rbp+var_68], rax
mov eax, [rbp+var_6C]
add eax, 1
mov [rbp+var_6C], eax
jmp short loc_2F19
loc_2F3D:
mov rax, [rbp+var_28]
add rax, [rbp+var_60]
mov [rbp+var_78], rax
mov rax, [rbp+var_20]
sub rax, [rbp+var_60]
shr rax, 3
mov [rbp+var_80], rax
mov [rbp+var_88], 0
loc_2F64:
mov rax, [rbp+var_88]
cmp rax, [rbp+var_80]
jnb short loc_2F9B
mov rcx, [rbp+var_68]
mov rax, [rbp+var_78]
mov rdx, rax
add rdx, 8
mov [rbp+var_78], rdx
mov [rax], rcx
mov rax, [rbp+var_88]
add rax, 1
mov [rbp+var_88], rax
jmp short loc_2F64
loc_2F9B:
mov rax, [rbp+var_80]
shl rax, 3
add rax, [rbp+var_60]
mov [rbp+var_60], rax
loc_2FAB:
jmp short $+2
loc_2FAD:
mov rax, [rbp+var_60]
cmp rax, [rbp+var_20]
jnb short loc_2FD2
mov dl, [rbp+var_29]
mov rax, [rbp+var_28]
mov rcx, [rbp+var_60]
mov rsi, rcx
add rsi, 1
mov [rbp+var_60], rsi
mov [rax+rcx], dl
jmp short loc_2FAD
loc_2FD2:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_2FDA:
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
|
_QWORD * memset(_QWORD *a1, unsigned __int8 a2, unsigned long long a3)
{
_QWORD *v3; // rax
unsigned long long v4; // rcx
unsigned long long *v5; // rax
unsigned long long v6; // rcx
bool v8; // [rsp+1h] [rbp-89h]
unsigned long long k; // [rsp+2h] [rbp-88h]
unsigned long long v10; // [rsp+Ah] [rbp-80h]
unsigned long long *v11; // [rsp+12h] [rbp-78h]
int j; // [rsp+1Eh] [rbp-6Ch]
unsigned long long v13; // [rsp+22h] [rbp-68h]
unsigned long long i; // [rsp+2Ah] [rbp-60h]
unsigned long long n; // [rsp+32h] [rbp-58h]
unsigned long long m; // [rsp+42h] [rbp-48h]
unsigned long long v17; // [rsp+4Ah] [rbp-40h]
_QWORD *v18; // [rsp+52h] [rbp-38h]
if ( !a1 || !a3 )
return a1;
if ( a3 > (unsigned long long)&unk_4000000 )
return a1;
if ( a2 || a3 < 8 || ((unsigned __int8)a1 & 7) != 0 )
{
for ( i = 0LL; ; ++i )
{
v8 = 0;
if ( i < a3 )
v8 = (((_BYTE)i + (_BYTE)a1) & 7) != 0LL;
if ( !v8 )
break;
v4 = i;
*((_BYTE *)a1 + v4) = a2;
}
if ( a3 - i >= 8 )
{
v13 = 0LL;
for ( j = 0; j < 8; ++j )
v13 = a2 | (v13 << 8);
v11 = (_QWORD *)((char *)a1 + i);
v10 = (a3 - i) >> 3;
for ( k = 0LL; k < v10; ++k )
{
v5 = v11++;
*v5 = v13;
}
i += 8 * v10;
}
while ( i < a3 )
{
v6 = i++;
*((_BYTE *)a1 + v6) = a2;
}
return a1;
}
else
{
v18 = a1;
v17 = a3 >> 3;
for ( m = 0LL; m < v17; ++m )
{
v3 = v18++;
*v3 = 0LL;
}
for ( n = 8 * v17; n < a3; ++n )
*((_BYTE *)a1 + n) = 0;
return a1;
}
}
|
_memset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00102db1
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00102dbe
LAB_00102db1:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00102fda
LAB_00102dbe:
CMP qword ptr [RBP + -0x20],0x4000000
JBE 0x00102dd5
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00102fda
LAB_00102dd5:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0x29],AL
MOVZX EAX,byte ptr [RBP + -0x29]
CMP EAX,0x0
JNZ 0x00102e9e
CMP qword ptr [RBP + -0x20],0x8
JC 0x00102e9e
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x7
CMP RAX,0x0
JNZ 0x00102e9c
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
SHR RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x48],0x0
LAB_00102e29:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00102e57
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0x38],RCX
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00102e29
LAB_00102e57:
MOV RAX,qword ptr [RBP + -0x40]
SHL RAX,0x3
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x58],RAX
LAB_00102e6b:
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00102e8f
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x58]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x1
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00102e6b
LAB_00102e8f:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00102fda
LAB_00102e9c:
JMP 0x00102e9e
LAB_00102e9e:
MOV qword ptr [RBP + -0x60],0x0
LAB_00102ea6:
MOV RCX,qword ptr [RBP + -0x60]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x89],AL
JNC 0x00102ed1
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x60]
AND RAX,0x7
CMP RAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x89],AL
LAB_00102ed1:
MOV AL,byte ptr [RBP + -0x89]
TEST AL,0x1
JNZ 0x00102edd
JMP 0x00102ef8
LAB_00102edd:
MOV DL,byte ptr [RBP + -0x29]
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x60]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RBP + -0x60],RSI
MOV byte ptr [RAX + RCX*0x1],DL
JMP 0x00102ea6
LAB_00102ef8:
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,qword ptr [RBP + -0x60]
CMP RAX,0x8
JC 0x00102fab
MOV qword ptr [RBP + -0x68],0x0
MOV dword ptr [RBP + -0x6c],0x0
LAB_00102f19:
CMP dword ptr [RBP + -0x6c],0x8
JGE 0x00102f3d
MOV RAX,qword ptr [RBP + -0x68]
SHL RAX,0x8
MOVZX ECX,byte ptr [RBP + -0x29]
OR RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV EAX,dword ptr [RBP + -0x6c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x00102f19
LAB_00102f3d:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,qword ptr [RBP + -0x60]
SHR RAX,0x3
MOV qword ptr [RBP + -0x80],RAX
MOV qword ptr [RBP + -0x88],0x0
LAB_00102f64:
MOV RAX,qword ptr [RBP + -0x88]
CMP RAX,qword ptr [RBP + -0x80]
JNC 0x00102f9b
MOV RCX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x78],RDX
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,0x1
MOV qword ptr [RBP + -0x88],RAX
JMP 0x00102f64
LAB_00102f9b:
MOV RAX,qword ptr [RBP + -0x80]
SHL RAX,0x3
ADD RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x60],RAX
LAB_00102fab:
JMP 0x00102fad
LAB_00102fad:
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00102fd2
MOV DL,byte ptr [RBP + -0x29]
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x60]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RBP + -0x60],RSI
MOV byte ptr [RAX + RCX*0x1],DL
JMP 0x00102fad
LAB_00102fd2:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_00102fda:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
int8 * _memset(int8 *param_1,byte param_2,ulong param_3)
{
ulong uVar1;
ulong local_90;
ulong *local_80;
int local_74;
ulong local_70;
ulong local_68;
ulong local_60;
ulong local_50;
int8 *local_40;
if (((param_1 != (int8 *)0x0) && (param_3 != 0)) && (param_3 < 0x4000001)) {
if (((param_2 == 0) && (7 < param_3)) && (((ulong)param_1 & 7) == 0)) {
local_40 = param_1;
for (local_50 = 0; local_50 < param_3 >> 3; local_50 = local_50 + 1) {
*local_40 = 0;
local_40 = local_40 + 1;
}
for (local_60 = (param_3 >> 3) << 3; local_60 < param_3; local_60 = local_60 + 1) {
*(int1 *)((long)param_1 + local_60) = 0;
}
}
else {
local_68 = 0;
while (local_68 < param_3 && ((long)param_1 + local_68 & 7) != 0) {
*(byte *)((long)param_1 + local_68) = param_2;
local_68 = local_68 + 1;
}
if (7 < param_3 - local_68) {
local_70 = 0;
for (local_74 = 0; local_74 < 8; local_74 = local_74 + 1) {
local_70 = local_70 << 8 | (ulong)param_2;
}
uVar1 = param_3 - local_68 >> 3;
local_80 = (ulong *)((long)param_1 + local_68);
for (local_90 = 0; local_90 < uVar1; local_90 = local_90 + 1) {
*local_80 = local_70;
local_80 = local_80 + 1;
}
local_68 = uVar1 * 8 + local_68;
}
while (local_68 < param_3) {
*(byte *)((long)param_1 + local_68) = param_2;
local_68 = local_68 + 1;
}
}
}
return param_1;
}
|
|
10,823 |
memset
|
seiftnesse[P]memoryallocator/src/custom_alloc_util.c
|
void *_memset(void *dest, int value, size_t count) {
// Validate parameters
if (!dest || count == 0) {
return dest;
}
// Safety check for size
if (count > HEAP_SIZE) {
HEAP_LOG("WARNING: Attempted to set unreasonably large block: %zu bytes\n", count);
return dest;
}
// Cast to byte pointer
uint8_t *d = (uint8_t *) dest;
uint8_t v = (uint8_t) value;
// If setting to zero, we can potentially use a faster method
if (v == 0 && count >= 8) {
// Check if pointer is 8-byte aligned
if (!((uintptr_t) dest & 7)) {
// Fast path: 64-bit aligned zero-fill
uint64_t *d64 = (uint64_t *) dest;
// Set 8 bytes at a time with zero
size_t qwords = count / 8;
for (size_t i = 0; i < qwords; i++) {
*d64++ = 0;
}
// Set remaining bytes
size_t offset = qwords * 8;
for (size_t i = offset; i < count; i++) {
d[i] = 0;
}
return dest;
}
}
// For non-zero values or small sizes, use byte-by-byte approach
// Fill the first few bytes until we reach 8-byte alignment
size_t i = 0;
while (i < count && ((uintptr_t) &d[i] & 7)) {
d[i++] = v;
}
// If the value is the same for each byte, use 64-bit optimization
if (count - i >= 8) {
// Create a 64-bit pattern from the byte
uint64_t pattern = 0;
for (int j = 0; j < 8; j++) {
pattern = (pattern << 8) | v;
}
// Set 8 bytes at a time with the pattern
uint64_t *d64 = (uint64_t *) &d[i];
size_t qwords = (count - i) / 8;
for (size_t j = 0; j < qwords; j++) {
*d64++ = pattern;
}
// Update index
i += qwords * 8;
}
// Set any remaining bytes
while (i < count) {
d[i++] = v;
}
return dest;
}
|
O3
|
c
|
memset:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
leaq -0x4000001(%rdx), %rcx
cmpq $-0x4000000, %rcx # imm = 0xFC000000
setb %cl
orb %al, %cl
jne 0x2224
movq %rdx, %r14
movzbl %sil, %ebp
testb $0x7, %bl
jne 0x2102
testl %ebp, %ebp
jne 0x2102
cmpq $0x7, %r14
jbe 0x2102
movl %r14d, %r15d
andl $0x7fffff8, %r15d # imm = 0x7FFFFF8
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1040
cmpq %r14, %r15
je 0x2224
leaq (%rbx,%r15), %rdi
movq %r15, %rdx
orq $0x1, %rdx
cmpq %rdx, %r14
cmovaq %r14, %rdx
subq %r15, %rdx
xorl %esi, %esi
jmp 0x221f
testb $0x7, %bl
je 0x2137
movl %ebx, %r12d
notl %r12d
leaq -0x1(%r14), %rax
andl $0x7, %r12d
cmpq %r12, %rax
cmovbq %rax, %r12
leaq 0x1(%r12), %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x1040
leaq (%rbx,%r12), %rax
incq %rax
jmp 0x213d
xorl %r15d, %r15d
movq %rbx, %rax
movq %r14, %rcx
subq %r15, %rcx
cmpq $0x8, %rcx
jb 0x220f
movl %ebp, %esi
movl $0x8, %edi
xorl %edx, %edx
shlq $0x8, %rdx
orq %rsi, %rdx
decl %edi
jne 0x2156
movq %rcx, %rdi
shrq $0x3, %rdi
cmpq $0x1, %rdi
adcq $0x0, %rdi
leaq 0x1(%rdi), %r8
movabsq $0x3ffffffffffffffe, %rsi # imm = 0x3FFFFFFFFFFFFFFE
andq %r8, %rsi
decq %rdi
movq %rdi, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
xorl %edi, %edi
movdqa 0xf28(%rip), %xmm1 # 0x30c0
movdqa 0xf30(%rip), %xmm2 # 0x30d0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdi, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %r8d
notl %r8d
testb $0x1, %r8b
je 0x21ea
movq %rdx, (%rax,%rdi,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %r8d
testb $0x1, %r8b
je 0x21ff
movq %rdx, 0x8(%rax,%rdi,8)
addq $0x2, %rdi
cmpq %rdi, %rsi
jne 0x21a8
andq $-0x8, %rcx
addq %rcx, %r15
subq %r15, %r14
jbe 0x2224
addq %rbx, %r15
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x1040
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_memset:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rdi
test rdi, rdi
setz al
lea rcx, [rdx-4000001h]
cmp rcx, 0FFFFFFFFFC000000h
setb cl
or cl, al
jnz loc_2224
mov r14, rdx
movzx ebp, sil
test bl, 7
jnz short loc_2102
test ebp, ebp
jnz short loc_2102
cmp r14, 7
jbe short loc_2102
mov r15d, r14d
and r15d, 7FFFFF8h
mov rdi, rbx
xor esi, esi
mov rdx, r15
call _memset
cmp r15, r14
jz loc_2224
lea rdi, [rbx+r15]
mov rdx, r15
or rdx, 1
cmp r14, rdx
cmova rdx, r14
sub rdx, r15
xor esi, esi
jmp loc_221F
loc_2102:
test bl, 7
jz short loc_2137
mov r12d, ebx
not r12d
lea rax, [r14-1]
and r12d, 7
cmp rax, r12
cmovb r12, rax
lea r15, [r12+1]
mov rdi, rbx
mov esi, ebp
mov rdx, r15
call _memset
lea rax, [rbx+r12]
inc rax
jmp short loc_213D
loc_2137:
xor r15d, r15d
mov rax, rbx
loc_213D:
mov rcx, r14
sub rcx, r15
cmp rcx, 8
jb loc_220F
mov esi, ebp
mov edi, 8
xor edx, edx
loc_2156:
shl rdx, 8
or rdx, rsi
dec edi
jnz short loc_2156
mov rdi, rcx
shr rdi, 3
cmp rdi, 1
adc rdi, 0
lea r8, [rdi+1]
mov rsi, 3FFFFFFFFFFFFFFEh
and rsi, r8
dec rdi
movq xmm0, rdi
pshufd xmm0, xmm0, 44h ; 'D'
xor edi, edi
movdqa xmm1, cs:xmmword_30C0
movdqa xmm2, cs:xmmword_30D0
pxor xmm0, xmm2
pcmpeqd xmm3, xmm3
loc_21A8:
movq xmm4, rdi
pshufd xmm4, xmm4, 44h ; 'D'
por xmm4, xmm1
pxor xmm4, xmm2
movdqa xmm5, xmm4
pcmpgtd xmm5, xmm0
pcmpeqd xmm4, xmm0
pshufd xmm6, xmm4, 0F5h
pand xmm6, xmm5
pshufd xmm4, xmm5, 0F5h
por xmm4, xmm6
movd r8d, xmm4
not r8d
test r8b, 1
jz short loc_21EA
mov [rax+rdi*8], rdx
loc_21EA:
pxor xmm4, xmm3
pextrw r8d, xmm4, 4
test r8b, 1
jz short loc_21FF
mov [rax+rdi*8+8], rdx
loc_21FF:
add rdi, 2
cmp rsi, rdi
jnz short loc_21A8
and rcx, 0FFFFFFFFFFFFFFF8h
add r15, rcx
loc_220F:
sub r14, r15
jbe short loc_2224
add r15, rbx
mov rdi, r15
mov esi, ebp
mov rdx, r14
loc_221F:
call _memset
loc_2224:
mov rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long memset(long long a1, unsigned __int8 a2, unsigned long long a3)
{
unsigned int v5; // ebp
unsigned long long v6; // r15
unsigned long long v7; // rdi
long long v8; // rdx
unsigned long long v9; // rdx
long long v10; // rsi
unsigned long long v11; // r12
unsigned long long v12; // r15
long long v13; // rax
unsigned long long v14; // rcx
int v15; // edi
unsigned long long v16; // rdx
unsigned long long v17; // rdi
long long v18; // rsi
__m128i v19; // xmm0
unsigned long long v20; // rdi
__m128i si128; // xmm1
__m128i v22; // xmm2
__m128i v23; // xmm0
__m128i v24; // xmm4
__m128i v25; // xmm5
__m128i v26; // xmm4
bool v27; // cc
unsigned long long v28; // r14
if ( a1 != 0 && a3 - 67108865 >= 0xFFFFFFFFFC000000LL )
{
v5 = a2;
if ( (a1 & 7) != 0 || a2 || a3 <= 7 )
{
if ( (a1 & 7) != 0 )
{
v11 = ~(_BYTE)a1 & 7;
if ( a3 - 1 < v11 )
v11 = a3 - 1;
v12 = v11 + 1;
memset(a1, a2, v11 + 1);
v13 = a1 + v11 + 1;
}
else
{
v12 = 0LL;
v13 = a1;
}
v14 = a3 - v12;
if ( a3 - v12 >= 8 )
{
v15 = 8;
v16 = 0LL;
do
{
v16 = a2 | (v16 << 8);
--v15;
}
while ( v15 );
v17 = (v14 >> 3 == 0) + (v14 >> 3);
v18 = (v17 + 1) & 0x3FFFFFFFFFFFFFFELL;
v19 = _mm_shuffle_epi32((__m128i)(v17 - 1), 68);
v20 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_30C0);
v22 = _mm_load_si128((const __m128i *)&xmmword_30D0);
v23 = _mm_xor_si128(v19, v22);
do
{
v24 = _mm_xor_si128(_mm_or_si128(_mm_shuffle_epi32((__m128i)v20, 68), si128), v22);
v25 = _mm_cmpgt_epi32(v24, v23);
v26 = _mm_or_si128(
_mm_shuffle_epi32(v25, 245),
_mm_and_si128(_mm_shuffle_epi32(_mm_cmpeq_epi32(v24, v23), 245), v25));
if ( (~_mm_cvtsi128_si32(v26) & 1) != 0 )
*(_QWORD *)(v13 + 8 * v20) = v16;
if ( (_mm_extract_epi16(_mm_xor_si128(v26, (__m128i)-1LL), 4) & 1) != 0 )
*(_QWORD *)(v13 + 8 * v20 + 8) = v16;
v20 += 2LL;
}
while ( v18 != v20 );
v12 += v14 & 0xFFFFFFFFFFFFFFF8LL;
}
v27 = a3 <= v12;
v28 = a3 - v12;
if ( !v27 )
{
v7 = a1 + v12;
v10 = v5;
v9 = v28;
LABEL_26:
memset(v7, v10, v9);
}
}
else
{
v6 = a3 & 0x7FFFFF8;
memset(a1, 0LL, v6);
if ( v6 != a3 )
{
v7 = a1 + v6;
v8 = v6 | 1;
if ( a3 > (v6 | 1) )
v8 = a3;
v9 = v8 - v6;
v10 = 0LL;
goto LABEL_26;
}
}
}
return a1;
}
|
_memset:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
TEST RDI,RDI
SETZ AL
LEA RCX,[RDX + -0x4000001]
CMP RCX,-0x4000000
SETC CL
OR CL,AL
JNZ 0x00102224
MOV R14,RDX
MOVZX EBP,SIL
TEST BL,0x7
JNZ 0x00102102
TEST EBP,EBP
JNZ 0x00102102
CMP R14,0x7
JBE 0x00102102
MOV R15D,R14D
AND R15D,0x7fffff8
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R15
CALL 0x00101040
CMP R15,R14
JZ 0x00102224
LEA RDI,[RBX + R15*0x1]
MOV RDX,R15
OR RDX,0x1
CMP R14,RDX
CMOVA RDX,R14
SUB RDX,R15
XOR ESI,ESI
JMP 0x0010221f
LAB_00102102:
TEST BL,0x7
JZ 0x00102137
MOV R12D,EBX
NOT R12D
LEA RAX,[R14 + -0x1]
AND R12D,0x7
CMP RAX,R12
CMOVC R12,RAX
LEA R15,[R12 + 0x1]
MOV RDI,RBX
MOV ESI,EBP
MOV RDX,R15
CALL 0x00101040
LEA RAX,[RBX + R12*0x1]
INC RAX
JMP 0x0010213d
LAB_00102137:
XOR R15D,R15D
MOV RAX,RBX
LAB_0010213d:
MOV RCX,R14
SUB RCX,R15
CMP RCX,0x8
JC 0x0010220f
MOV ESI,EBP
MOV EDI,0x8
XOR EDX,EDX
LAB_00102156:
SHL RDX,0x8
OR RDX,RSI
DEC EDI
JNZ 0x00102156
MOV RDI,RCX
SHR RDI,0x3
CMP RDI,0x1
ADC RDI,0x0
LEA R8,[RDI + 0x1]
MOV RSI,0x3ffffffffffffffe
AND RSI,R8
DEC RDI
MOVQ XMM0,RDI
PSHUFD XMM0,XMM0,0x44
XOR EDI,EDI
MOVDQA XMM1,xmmword ptr [0x001030c0]
MOVDQA XMM2,xmmword ptr [0x001030d0]
PXOR XMM0,XMM2
PCMPEQD XMM3,XMM3
LAB_001021a8:
MOVQ XMM4,RDI
PSHUFD XMM4,XMM4,0x44
POR XMM4,XMM1
PXOR XMM4,XMM2
MOVDQA XMM5,XMM4
PCMPGTD XMM5,XMM0
PCMPEQD XMM4,XMM0
PSHUFD XMM6,XMM4,0xf5
PAND XMM6,XMM5
PSHUFD XMM4,XMM5,0xf5
POR XMM4,XMM6
MOVD R8D,XMM4
NOT R8D
TEST R8B,0x1
JZ 0x001021ea
MOV qword ptr [RAX + RDI*0x8],RDX
LAB_001021ea:
PXOR XMM4,XMM3
PEXTRW R8D,XMM4,0x4
TEST R8B,0x1
JZ 0x001021ff
MOV qword ptr [RAX + RDI*0x8 + 0x8],RDX
LAB_001021ff:
ADD RDI,0x2
CMP RSI,RDI
JNZ 0x001021a8
AND RCX,-0x8
ADD R15,RCX
LAB_0010220f:
SUB R14,R15
JBE 0x00102224
ADD R15,RBX
MOV RDI,R15
MOV ESI,EBP
MOV RDX,R14
LAB_0010221f:
CALL 0x00101040
LAB_00102224:
MOV RAX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void * _memset(void *param_1,uint param_2,ulong param_3)
{
int1 auVar1 [16];
int1 auVar2 [16];
void *pvVar3;
ulong uVar4;
size_t __n;
ulong uVar5;
int iVar6;
long lVar7;
long lVar8;
ulong uVar9;
size_t __n_00;
int1 auVar10 [16];
int1 auVar11 [16];
if (0xfffffffffbffffff < param_3 - 0x4000001 && param_1 != (void *)0x0) {
param_2 = param_2 & 0xff;
if (((((ulong)param_1 & 7) == 0) && (param_2 == 0)) && (7 < param_3)) {
__n_00 = (size_t)((uint)param_3 & 0x7fffff8);
memset(param_1,0,__n_00);
if (__n_00 == param_3) {
return param_1;
}
uVar4 = __n_00 | 1;
if ((__n_00 | 1) < param_3) {
uVar4 = param_3;
}
__n = uVar4 - __n_00;
param_2 = 0;
}
else {
if (((ulong)param_1 & 7) == 0) {
__n_00 = 0;
pvVar3 = param_1;
}
else {
uVar4 = (ulong)(~(uint)param_1 & 7);
if (param_3 - 1 < uVar4) {
uVar4 = param_3 - 1;
}
__n_00 = uVar4 + 1;
memset(param_1,param_2,__n_00);
pvVar3 = (void *)((long)param_1 + uVar4 + 1);
}
auVar2 = _DAT_001030d0;
auVar1 = _DAT_001030c0;
uVar4 = param_3 - __n_00;
if (7 < uVar4) {
iVar6 = 8;
uVar5 = 0;
do {
uVar5 = uVar5 << 8 | (ulong)param_2;
iVar6 = iVar6 + -1;
} while (iVar6 != 0);
lVar7 = (uVar4 >> 3) + (ulong)(uVar4 >> 3 == 0);
lVar8 = lVar7 + -1;
auVar10._8_4_ = (int)lVar8;
auVar10._0_8_ = lVar8;
auVar10._12_4_ = (int)((ulong)lVar8 >> 0x20);
uVar9 = 0;
auVar10 = auVar10 ^ _DAT_001030d0;
do {
auVar11._8_4_ = (int)uVar9;
auVar11._0_8_ = uVar9;
auVar11._12_4_ = (int)(uVar9 >> 0x20);
auVar11 = (auVar11 | auVar1) ^ auVar2;
if ((bool)(~(auVar11._4_4_ == auVar10._4_4_ && auVar10._0_4_ < auVar11._0_4_ ||
auVar10._4_4_ < auVar11._4_4_) & 1)) {
*(ulong *)((long)pvVar3 + uVar9 * 8) = uVar5;
}
if ((auVar11._12_4_ != auVar10._12_4_ || auVar11._8_4_ <= auVar10._8_4_) &&
auVar11._12_4_ <= auVar10._12_4_) {
*(ulong *)((long)pvVar3 + uVar9 * 8 + 8) = uVar5;
}
uVar9 = uVar9 + 2;
} while ((lVar7 + 1U & 0x3ffffffffffffffe) != uVar9);
__n_00 = __n_00 + (uVar4 & 0xfffffffffffffff8);
}
__n = param_3 - __n_00;
if (param_3 < __n_00 || __n == 0) {
return param_1;
}
}
memset((void *)((long)param_1 + __n_00),param_2,__n);
}
return param_1;
}
|
|
10,824 |
tbb::detail::r1::allowed_parallelism_control::active_value()
|
aimrt_mujoco_sim/_deps/tbb-src/src/tbb/global_control.cpp
|
std::size_t active_value() override {
spin_mutex::scoped_lock lock(my_list_mutex); // protect my_list.empty() call
if (my_list.empty()) {
return default_value();
}
// non-zero, if market is active
const std::size_t workers = threading_control::max_num_workers();
// We can't exceed market's maximal number of workers.
// +1 to take external thread into account
return workers ? min(workers + 1, my_active_value) : my_active_value;
}
|
O0
|
cpp
|
tbb::detail::r1::allowed_parallelism_control::active_value():
subq $0x78, %rsp
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x30(%rsp)
addq $0x40, %rsi
leaq 0x68(%rsp), %rdi
callq 0x22ba70
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
callq 0x36eb70
testb $0x1, %al
jne 0x36e583
jmp 0x36e5cc
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, 0x28(%rsp)
jmp 0x36e598
movq 0x28(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x1, 0x40(%rsp)
jmp 0x36e63d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x22baa0
jmp 0x36e66e
callq 0x372df0
movl %eax, 0x24(%rsp)
jmp 0x36e5d7
movl 0x24(%rsp), %eax
movl %eax, %eax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x36e61d
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rax
incq %rax
movq %rax, 0x60(%rsp)
addq $0x8, %rsi
leaq 0x60(%rsp), %rdi
callq 0x36ec60
movq %rax, 0x18(%rsp)
jmp 0x36e611
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x36e62b
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x1, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x22baa0
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %fs:0x28, %rax
movq 0x70(%rsp), %rcx
cmpq %rcx, %rax
jne 0x36e693
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq %fs:0x28, %rax
movq 0x70(%rsp), %rcx
cmpq %rcx, %rax
jne 0x36e693
movq (%rsp), %rdi
callq 0x198ce0
callq 0x190f00
nopl (%rax,%rax)
|
_ZN3tbb6detail2r127allowed_parallelism_control12active_valueEv:
sub rsp, 78h
mov rax, fs:28h
mov [rsp+78h+var_8], rax
mov [rsp+78h+var_28], rdi
mov rsi, [rsp+78h+var_28]
mov [rsp+78h+var_48], rsi
add rsi, 40h ; '@'
lea rdi, [rsp+78h+var_10]
call _ZN3tbb6detail2d118unique_scoped_lockINS1_10spin_mutexEEC2ERS3_; tbb::detail::d1::unique_scoped_lock<tbb::detail::d1::spin_mutex>::unique_scoped_lock(tbb::detail::d1::spin_mutex&)
mov rdi, [rsp+78h+var_48]
add rdi, 10h; this
call _ZNKSt3setIPN3tbb6detail2d114global_controlENS1_2r126control_storage_comparatorENS2_13tbb_allocatorIS4_EEE5emptyEv; std::set<tbb::detail::d1::global_control *,tbb::detail::r1::control_storage_comparator,tbb::detail::d1::tbb_allocator<tbb::detail::d1::global_control *>>::empty(void)
test al, 1
jnz short loc_36E583
jmp short loc_36E5CC
loc_36E583:
mov rdi, [rsp+78h+var_48]
mov rax, [rdi]
mov rax, [rax+10h]
call rax
mov [rsp+78h+var_50], rax
jmp short $+2
loc_36E598:
mov rax, [rsp+78h+var_50]
mov [rsp+78h+var_20], rax
mov [rsp+78h+var_38], 1
jmp loc_36E63D
mov rcx, rax
mov eax, edx
mov [rsp+78h+var_30], rcx
mov [rsp+78h+var_34], eax
lea rdi, [rsp+78h+var_10]
call _ZN3tbb6detail2d118unique_scoped_lockINS1_10spin_mutexEED2Ev; tbb::detail::d1::unique_scoped_lock<tbb::detail::d1::spin_mutex>::~unique_scoped_lock()
jmp loc_36E66E
loc_36E5CC:
call _ZN3tbb6detail2r117threading_control15max_num_workersEv; tbb::detail::r1::threading_control::max_num_workers(void)
mov [rsp+78h+var_54], eax
jmp short $+2
loc_36E5D7:
mov eax, [rsp+78h+var_54]
mov eax, eax
mov [rsp+78h+var_40], rax
cmp [rsp+78h+var_40], 0
jz short loc_36E61D
mov rsi, [rsp+78h+var_48]
mov rax, [rsp+78h+var_40]
inc rax
mov [rsp+78h+var_18], rax
add rsi, 8
lea rdi, [rsp+78h+var_18]
call _ZN3tbb6detail2r13minImEET_RKS3_S5_; tbb::detail::r1::min<ulong>(ulong const&,ulong const&)
mov [rsp+78h+var_60], rax
jmp short $+2
loc_36E611:
mov rax, [rsp+78h+var_60]
mov [rsp+78h+var_68], rax
jmp short loc_36E62B
loc_36E61D:
mov rax, [rsp+78h+var_48]
mov rax, [rax+8]
mov [rsp+78h+var_68], rax
loc_36E62B:
mov rax, [rsp+78h+var_68]
mov [rsp+78h+var_20], rax
mov [rsp+78h+var_38], 1
loc_36E63D:
lea rdi, [rsp+78h+var_10]
call _ZN3tbb6detail2d118unique_scoped_lockINS1_10spin_mutexEED2Ev; tbb::detail::d1::unique_scoped_lock<tbb::detail::d1::spin_mutex>::~unique_scoped_lock()
mov rax, [rsp+78h+var_20]
mov [rsp+78h+var_70], rax
mov rax, fs:28h
mov rcx, [rsp+78h+var_8]
cmp rax, rcx
jnz short loc_36E693
mov rax, [rsp+78h+var_70]
add rsp, 78h
retn
loc_36E66E:
mov rax, [rsp+78h+var_30]
mov [rsp+78h+var_78], rax
mov rax, fs:28h
mov rcx, [rsp+78h+var_8]
cmp rax, rcx
jnz short loc_36E693
mov rdi, [rsp+78h+var_78]
call __Unwind_Resume
loc_36E693:
call ___stack_chk_fail
|
long long tbb::detail::r1::allowed_parallelism_control::active_value(
tbb::detail::r1::allowed_parallelism_control *this)
{
tbb::detail::r1::threading_control *v1; // rdi
long long v3; // [rsp+10h] [rbp-68h]
unsigned int v4; // [rsp+24h] [rbp-54h]
long long v6; // [rsp+58h] [rbp-20h]
long long v7; // [rsp+60h] [rbp-18h] BYREF
_QWORD v8[2]; // [rsp+68h] [rbp-10h] BYREF
v8[1] = __readfsqword(0x28u);
tbb::detail::d1::unique_scoped_lock<tbb::detail::d1::spin_mutex>::unique_scoped_lock(v8, (long long)this + 64);
v1 = (tbb::detail::r1::allowed_parallelism_control *)((char *)this + 16);
if ( (std::set<tbb::detail::d1::global_control *,tbb::detail::r1::control_storage_comparator,tbb::detail::d1::tbb_allocator<tbb::detail::d1::global_control *>>::empty(v1) & 1) != 0 )
{
v6 = (*(long long ( **)(tbb::detail::r1::allowed_parallelism_control *))(*(_QWORD *)this + 16LL))(this);
}
else
{
v4 = tbb::detail::r1::threading_control::max_num_workers(v1);
if ( v4 )
{
v7 = v4 + 1LL;
v3 = tbb::detail::r1::min<unsigned long>(&v7, (char *)this + 8);
}
else
{
v3 = *((_QWORD *)this + 1);
}
v6 = v3;
}
tbb::detail::d1::unique_scoped_lock<tbb::detail::d1::spin_mutex>::~unique_scoped_lock(v8);
return v6;
}
|
_M_insert_bracket_matcher<false,false>:
SUB RSP,0x138
MOV AL,SIL
MOV qword ptr [RSP + 0x130],RDI
AND AL,0x1
MOV byte ptr [RSP + 0x12f],AL
MOV RAX,qword ptr [RSP + 0x130]
MOV qword ptr [RSP + 0x30],RAX
MOV RDX,qword ptr [RAX + 0x180]
MOVZX ESI,byte ptr [RSP + 0x12f]
AND ESI,0x1
LEA RDI,[RSP + 0x90]
CALL 0x002a5160
LEA RDI,[RSP + 0x8e]
CALL 0x0029ff00
MOV RDI,qword ptr [RSP + 0x30]
LAB_0036e599:
CALL 0x00290cd0
MOV byte ptr [RSP + 0x3f],AL
JMP 0x0036e5a4
LAB_0036e5a4:
MOV AL,byte ptr [RSP + 0x3f]
TEST AL,0x1
JNZ 0x0036e5ae
JMP 0x0036e5eb
LAB_0036e5ae:
MOV RDI,qword ptr [RSP + 0x30]
ADD RDI,0x110
XOR EAX,EAX
MOV ESI,EAX
CALL 0x002a67e0
LEA RDI,[RSP + 0x8e]
MOVSX ESI,byte ptr [RAX]
CALL 0x002920b0
JMP 0x0036e61e
LAB_0036e5eb:
MOV RDI,qword ptr [RSP + 0x30]
MOV ESI,0x1c
CALL 0x00292790
MOV byte ptr [RSP + 0x2f],AL
JMP 0x0036e600
LAB_0036e600:
MOV AL,byte ptr [RSP + 0x2f]
TEST AL,0x1
JNZ 0x0036e60a
JMP 0x0036e61c
LAB_0036e60a:
LEA RDI,[RSP + 0x8e]
MOV ESI,0x2d
CALL 0x002920b0
LAB_0036e61c:
JMP 0x0036e61e
LAB_0036e61e:
JMP 0x0036e620
LAB_0036e620:
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[RSP + 0x8e]
LEA RDX,[RSP + 0x90]
CALL 0x002944b0
MOV byte ptr [RSP + 0x2e],AL
JMP 0x0036e640
LAB_0036e640:
MOV AL,byte ptr [RSP + 0x2e]
TEST AL,0x1
JNZ 0x0036e64a
JMP 0x0036e64c
LAB_0036e64a:
JMP 0x0036e620
LAB_0036e64c:
LEA RDI,[RSP + 0x8e]
CALL 0x002a43a0
TEST AL,0x1
JNZ 0x0036e65f
JMP 0x0036e680
LAB_0036e65f:
LEA RDI,[RSP + 0x8e]
CALL 0x002950f0
MOVSX ESI,AL
LEA RDI,[RSP + 0x90]
CALL 0x0029a5b0
JMP 0x0036e67e
LAB_0036e67e:
JMP 0x0036e680
LAB_0036e680:
LEA RDI,[RSP + 0x90]
CALL 0x00293f90
JMP 0x0036e68f
LAB_0036e68f:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,RDI
ADD RAX,0x130
MOV qword ptr [RSP + 0x8],RAX
ADD RDI,0x100
MOV qword ptr [RSP + 0x10],RDI
CALL 0x002a69f0
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x18],RAX
CALL 0x0029ded0
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x40]
LEA RSI,[RSP + 0x90]
CALL 0x0029e140
JMP 0x0036e6db
LAB_0036e6db:
MOV RDI,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0x40]
CALL 0x0028fb60
MOV qword ptr [RSP],RAX
JMP 0x0036e6f0
LAB_0036e6f0:
MOV RDX,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x18]
LEA RDI,[RSP + 0x60]
CALL 0x002a7540
JMP 0x0036e705
LAB_0036e705:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x60]
CALL 0x00290840
LAB_0036e714:
JMP 0x0036e716
LAB_0036e716:
LEA RDI,[RSP + 0x40]
CALL 0x00293f40
LEA RDI,[RSP + 0x90]
CALL 0x002a0bb0
ADD RSP,0x138
RET
|
/* void std::__detail::_Compiler<std::__cxx11::regex_traits<char>
>::_M_insert_bracket_matcher<false, false>(bool) */
void __thiscall
std::__detail::_Compiler<std::__cxx11::regex_traits<char>>::_M_insert_bracket_matcher<false,false>
(_Compiler<std::__cxx11::regex_traits<char>> *this,bool param_1)
{
byte bVar1;
bool bVar2;
char cVar3;
char *pcVar4;
ulong uVar5;
_NFA *p_Var6;
_NFA<std::__cxx11::regex_traits<char>> *p_Var7;
long lVar8;
function<bool(char)> local_f8 [32];
_StateSeq<std::__cxx11::regex_traits<char>> local_d8 [46];
_BracketState local_aa [2];
_BracketMatcher<std::__cxx11::regex_traits<char>,false,false> local_a8 [159];
int1 local_9;
_Compiler<std::__cxx11::regex_traits<char>> *local_8;
local_9 = param_1;
local_8 = this;
_BracketMatcher<std::__cxx11::regex_traits<char>,false,false>::_BracketMatcher
(local_a8,param_1,*(regex_traits **)(this + 0x180));
_BracketState::_BracketState(local_aa);
/* try { // try from 0036e599 to 0036e6d8 has its CatchHandler @ 0036e5d5 */
bVar1 = _M_try_char(this);
if ((bVar1 & 1) == 0) {
bVar1 = _M_match_token(this,0x1c);
if ((bVar1 & 1) != 0) {
_BracketState::set(local_aa,'-');
}
}
else {
pcVar4 = (char *)__cxx11::string::operator[]((string *)(this + 0x110),0);
_BracketState::set(local_aa,*pcVar4);
}
do {
bVar2 = _M_expression_term<false,false>(this,local_aa,(_BracketMatcher *)local_a8);
} while (bVar2);
uVar5 = _BracketState::_M_is_char(local_aa);
if ((uVar5 & 1) != 0) {
cVar3 = _BracketState::get(local_aa);
_BracketMatcher<std::__cxx11::regex_traits<char>,false,false>::_M_add_char(local_a8,cVar3);
}
_BracketMatcher<std::__cxx11::regex_traits<char>,false,false>::_M_ready(local_a8);
p_Var6 = (_NFA *)__shared_ptr_access<std::__detail::_NFA<std::__cxx11::regex_traits<char>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator*((__shared_ptr_access<std::__detail::_NFA<std::__cxx11::regex_traits<char>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x100));
p_Var7 = (_NFA<std::__cxx11::regex_traits<char>> *)
__shared_ptr_access<std::__detail::_NFA<std::__cxx11::regex_traits<char>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<std::__detail::_NFA<std::__cxx11::regex_traits<char>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x100));
function<bool(char)>::
function<std::__detail::_BracketMatcher<std::__cxx11::regex_traits<char>,false,false>,void>
(local_f8,(_BracketMatcher *)local_a8);
/* try { // try from 0036e6db to 0036e713 has its CatchHandler @ 0036e735 */
lVar8 = _NFA<std::__cxx11::regex_traits<char>>::_M_insert_matcher(p_Var7,local_f8);
_StateSeq<std::__cxx11::regex_traits<char>>::_StateSeq(local_d8,p_Var6,lVar8);
stack<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>,std::deque<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>,std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>>
::push((stack<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>,std::deque<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>,std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>>
*)(this + 0x130),(_StateSeq *)local_d8);
function<bool(char)>::~function(local_f8);
_BracketMatcher<std::__cxx11::regex_traits<char>,false,false>::~_BracketMatcher(local_a8);
return;
}
|
|
10,825 |
trnman_get_min_safe_trid
|
eloqsql/storage/maria/trnman.c
|
TrID trnman_get_min_safe_trid()
{
TrID trid;
mysql_mutex_lock(&LOCK_trn_list);
trid= MY_MIN(active_list_min.next->min_read_from,
global_trid_generator);
mysql_mutex_unlock(&LOCK_trn_list);
return trid;
}
|
O0
|
c
|
trnman_get_min_safe_trid:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc00331(%rip), %rdi # 0xc7a090
leaq 0xd895f(%rip), %rsi # 0x1526c5
movl $0x37a, %edx # imm = 0x37A
callq 0x78e20
movq 0xbfffd9(%rip), %rax # 0xc79d50
movq 0x80(%rax), %rax
cmpq 0xc0023b(%rip), %rax # 0xc79fc0
jae 0x79d9b
movq 0xbfffc2(%rip), %rax # 0xc79d50
movq 0x80(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x79da6
movq 0xc0021e(%rip), %rax # 0xc79fc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0xc002db(%rip), %rdi # 0xc7a090
callq 0x78e90
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
trnman_get_min_safe_trid:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rdi, LOCK_trn_list
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 37Ah
call inline_mysql_mutex_lock_11
mov rax, cs:qword_C79D50
mov rax, [rax+80h]
cmp rax, cs:global_trid_generator
jnb short loc_79D9B
mov rax, cs:qword_C79D50
mov rax, [rax+80h]
mov [rbp+var_10], rax
jmp short loc_79DA6
loc_79D9B:
mov rax, cs:global_trid_generator
mov [rbp+var_10], rax
loc_79DA6:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock_12
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
|
long long trnman_get_min_safe_trid()
{
long long v1; // [rsp+0h] [rbp-10h]
inline_mysql_mutex_lock_11(
(long long)&LOCK_trn_list,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",
0x37Au);
if ( *(_QWORD *)(qword_C79D50 + 128) >= (unsigned long long)global_trid_generator )
v1 = global_trid_generator;
else
v1 = *(_QWORD *)(qword_C79D50 + 128);
inline_mysql_mutex_unlock_12((long long)&LOCK_trn_list);
return v1;
}
|
trnman_get_min_safe_trid:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RDI,[0xd7a090]
LEA RSI,[0x2526c5]
MOV EDX,0x37a
CALL 0x00178e20
MOV RAX,qword ptr [0x00d79d50]
MOV RAX,qword ptr [RAX + 0x80]
CMP RAX,qword ptr [0x00d79fc0]
JNC 0x00179d9b
MOV RAX,qword ptr [0x00d79d50]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00179da6
LAB_00179d9b:
MOV RAX,qword ptr [0x00d79fc0]
MOV qword ptr [RBP + -0x10],RAX
LAB_00179da6:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[0xd7a090]
CALL 0x00178e90
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
ulong trnman_get_min_safe_trid(void)
{
ulong local_18;
inline_mysql_mutex_lock
(LOCK_trn_list,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x37a);
if (*(ulong *)(active_list_min._104_8_ + 0x80) < global_trid_generator) {
local_18 = *(ulong *)(active_list_min._104_8_ + 0x80);
}
else {
local_18 = global_trid_generator;
}
inline_mysql_mutex_unlock(LOCK_trn_list);
return local_18;
}
|
|
10,826 |
unreg_request
|
eloqsql/mysys/mf_keycache.c
|
static void unreg_request(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, int at_end)
{
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/
DBUG_ASSERT(block->requests);
DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
DBUG_ASSERT(!block->next_used);
DBUG_ASSERT(!block->prev_used);
/*
Unregister the request, but do not link erroneous blocks into the
LRU ring.
*/
if (!--block->requests && !(block->status & BLOCK_ERROR))
{
my_bool hot;
if (block->hits_left)
block->hits_left--;
hot= !block->hits_left && at_end &&
keycache->warm_blocks > keycache->min_warm_blocks;
if (hot)
{
if (block->temperature == BLOCK_WARM)
keycache->warm_blocks--;
block->temperature= BLOCK_HOT;
KEYCACHE_DBUG_PRINT("unreg_request", ("#warm_blocks: %lu",
keycache->warm_blocks));
}
link_block(keycache, block, hot, (my_bool)at_end);
block->last_hit_time= keycache->keycache_time;
keycache->keycache_time++;
/*
At this place, the block might be in the LRU ring or not. If an
evicter was waiting for a block, it was selected for eviction and
not linked in the LRU ring.
*/
/*
Check if we should link a hot block to the warm block sub-chain.
It is possible that we select the same block as above. But it can
also be another block. In any case a block from the LRU ring is
selected. In other words it works even if the above block was
selected for eviction and not linked in the LRU ring. Since this
happens only if the LRU ring is empty, the block selected below
would be NULL and the rest of the function skipped.
*/
block= keycache->used_ins;
if (block && keycache->keycache_time - block->last_hit_time >
keycache->age_threshold)
{
unlink_block(keycache, block);
link_block(keycache, block, 0, 0);
if (block->temperature != BLOCK_WARM)
{
keycache->warm_blocks++;
block->temperature= BLOCK_WARM;
}
KEYCACHE_DBUG_PRINT("unreg_request", ("#warm_blocks: %lu",
keycache->warm_blocks));
}
}
}
|
O3
|
c
|
unreg_request:
decl 0x38(%rsi)
je 0x97eae
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
testb $0x1, 0x50(%rsi)
jne 0x97f94
movq %rdi, %rbx
movl 0x58(%r14), %eax
testl %eax, %eax
je 0x97ed8
decl %eax
movl %eax, 0x58(%r14)
sete %al
jmp 0x97eda
movb $0x1, %al
testl %edx, %edx
sete %cl
xorb $0x1, %al
orb %cl, %al
jne 0x97f32
movq 0x68(%rbx), %rax
cmpq 0x20(%rbx), %rax
jbe 0x97f32
cmpl $0x1, 0x54(%r14)
jne 0x97efd
decq %rax
movq %rax, 0x68(%rbx)
movl $0x2, 0x54(%r14)
movq 0xb8(%rbx), %rax
testq %rax, %rax
je 0x97f99
movq (%rax), %rcx
movq %r14, 0x8(%rcx)
movq (%rax), %rcx
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0xb8(%rbx)
jmp 0x97f42
movsbl %dl, %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x9890f
movq 0x30(%rbx), %rax
movq %rax, 0x60(%r14)
incq %rax
movq %rax, 0x30(%rbx)
movq 0xb8(%rbx), %r14
testq %r14, %r14
je 0x97f94
subq 0x60(%r14), %rax
cmpq 0x28(%rbx), %rax
jbe 0x97f94
movq %rbx, %rdi
movq %r14, %rsi
callq 0x988b8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x9890f
cmpl $0x1, 0x54(%r14)
je 0x97f94
incq 0x68(%rbx)
movl $0x1, 0x54(%r14)
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, (%r14)
movq %r14, 0xb8(%rbx)
movq %r14, 0xb0(%rbx)
movq %r14, 0x8(%r14)
jmp 0x97f42
|
unreg_request_0:
dec dword ptr [rsi+38h]
jz short loc_97EAE
retn
loc_97EAE:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
test byte ptr [rsi+50h], 1
jnz loc_97F94
mov rbx, rdi
mov eax, [r14+58h]
test eax, eax
jz short loc_97ED8
dec eax
mov [r14+58h], eax
setz al
jmp short loc_97EDA
loc_97ED8:
mov al, 1
loc_97EDA:
test edx, edx
setz cl
xor al, 1
or al, cl
jnz short loc_97F32
mov rax, [rbx+68h]
cmp rax, [rbx+20h]
jbe short loc_97F32
cmp dword ptr [r14+54h], 1
jnz short loc_97EFD
dec rax
mov [rbx+68h], rax
loc_97EFD:
mov dword ptr [r14+54h], 2
mov rax, [rbx+0B8h]
test rax, rax
jz loc_97F99
mov rcx, [rax]
mov [rcx+8], r14
mov rcx, [rax]
mov [r14], rcx
mov [r14+8], rax
mov [rax], r14
mov [rbx+0B8h], r14
jmp short loc_97F42
loc_97F32:
movsx ecx, dl
mov rdi, rbx
mov rsi, r14
xor edx, edx
call link_block_0
loc_97F42:
mov rax, [rbx+30h]
mov [r14+60h], rax
inc rax
mov [rbx+30h], rax
mov r14, [rbx+0B8h]
test r14, r14
jz short loc_97F94
sub rax, [r14+60h]
cmp rax, [rbx+28h]
jbe short loc_97F94
mov rdi, rbx
mov rsi, r14
call unlink_block_0
mov rdi, rbx
mov rsi, r14
xor edx, edx
xor ecx, ecx
call link_block_0
cmp dword ptr [r14+54h], 1
jz short loc_97F94
inc qword ptr [rbx+68h]
mov dword ptr [r14+54h], 1
loc_97F94:
pop rbx
pop r14
pop rbp
retn
loc_97F99:
mov [r14], r14
mov [rbx+0B8h], r14
mov [rbx+0B0h], r14
mov [r14+8], r14
jmp short loc_97F42
|
void unreg_request_0(_QWORD *a1, long long a2, long long a3)
{
bool v3; // zf
int v4; // eax
int v5; // eax
bool v6; // al
unsigned long long v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
long long v11; // r14
v3 = (*(_DWORD *)(a2 + 56))-- == 1;
if ( v3 && (*(_BYTE *)(a2 + 80) & 1) == 0 )
{
v4 = *(_DWORD *)(a2 + 88);
if ( v4 )
{
v5 = v4 - 1;
*(_DWORD *)(a2 + 88) = v5;
v6 = v5 == 0;
}
else
{
v6 = 1;
}
if ( (_DWORD)a3 == 0 || !v6 || (v7 = a1[13], v7 <= a1[4]) )
{
link_block_0(a1, a2, 0LL, (unsigned int)(char)a3);
}
else
{
if ( *(_DWORD *)(a2 + 84) == 1 )
a1[13] = v7 - 1;
*(_DWORD *)(a2 + 84) = 2;
v8 = a1[23];
if ( v8 )
{
*(_QWORD *)(*(_QWORD *)v8 + 8LL) = a2;
*(_QWORD *)a2 = *(_QWORD *)v8;
*(_QWORD *)(a2 + 8) = v8;
*(_QWORD *)v8 = a2;
a1[23] = a2;
}
else
{
*(_QWORD *)a2 = a2;
a1[23] = a2;
a1[22] = a2;
*(_QWORD *)(a2 + 8) = a2;
}
}
v9 = a1[6];
*(_QWORD *)(a2 + 96) = v9;
v10 = v9 + 1;
a1[6] = v10;
v11 = a1[23];
if ( v11 && (unsigned long long)(v10 - *(_QWORD *)(v11 + 96)) > a1[5] )
{
unlink_block_0(a1, a1[23], a3);
link_block_0(a1, v11, 0LL, 0LL);
if ( *(_DWORD *)(v11 + 84) != 1 )
{
++a1[13];
*(_DWORD *)(v11 + 84) = 1;
}
}
}
}
|
unreg_request:
DEC dword ptr [RSI + 0x38]
JZ 0x00197eae
RET
LAB_00197eae:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
TEST byte ptr [RSI + 0x50],0x1
JNZ 0x00197f94
MOV RBX,RDI
MOV EAX,dword ptr [R14 + 0x58]
TEST EAX,EAX
JZ 0x00197ed8
DEC EAX
MOV dword ptr [R14 + 0x58],EAX
SETZ AL
JMP 0x00197eda
LAB_00197ed8:
MOV AL,0x1
LAB_00197eda:
TEST EDX,EDX
SETZ CL
XOR AL,0x1
OR AL,CL
JNZ 0x00197f32
MOV RAX,qword ptr [RBX + 0x68]
CMP RAX,qword ptr [RBX + 0x20]
JBE 0x00197f32
CMP dword ptr [R14 + 0x54],0x1
JNZ 0x00197efd
DEC RAX
MOV qword ptr [RBX + 0x68],RAX
LAB_00197efd:
MOV dword ptr [R14 + 0x54],0x2
MOV RAX,qword ptr [RBX + 0xb8]
TEST RAX,RAX
JZ 0x00197f99
MOV RCX,qword ptr [RAX]
MOV qword ptr [RCX + 0x8],R14
MOV RCX,qword ptr [RAX]
MOV qword ptr [R14],RCX
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [RAX],R14
MOV qword ptr [RBX + 0xb8],R14
JMP 0x00197f42
LAB_00197f32:
MOVSX ECX,DL
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x0019890f
LAB_00197f42:
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [R14 + 0x60],RAX
INC RAX
MOV qword ptr [RBX + 0x30],RAX
MOV R14,qword ptr [RBX + 0xb8]
TEST R14,R14
JZ 0x00197f94
SUB RAX,qword ptr [R14 + 0x60]
CMP RAX,qword ptr [RBX + 0x28]
JBE 0x00197f94
MOV RDI,RBX
MOV RSI,R14
CALL 0x001988b8
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0019890f
CMP dword ptr [R14 + 0x54],0x1
JZ 0x00197f94
INC qword ptr [RBX + 0x68]
MOV dword ptr [R14 + 0x54],0x1
LAB_00197f94:
POP RBX
POP R14
POP RBP
RET
LAB_00197f99:
MOV qword ptr [R14],R14
MOV qword ptr [RBX + 0xb8],R14
MOV qword ptr [RBX + 0xb0],R14
MOV qword ptr [R14 + 0x8],R14
JMP 0x00197f42
|
void unreg_request(long param_1,long *param_2,int param_3)
{
long *plVar1;
long lVar2;
int iVar3;
long lVar4;
bool bVar5;
plVar1 = param_2 + 7;
*(int *)plVar1 = (int)*plVar1 + -1;
if ((int)*plVar1 != 0) {
return;
}
if ((*(byte *)(param_2 + 10) & 1) == 0) {
if ((int)param_2[0xb] == 0) {
bVar5 = true;
}
else {
iVar3 = (int)param_2[0xb] + -1;
bVar5 = iVar3 == 0;
*(int *)(param_2 + 0xb) = iVar3;
}
if (((bool)(bVar5 ^ 1U | param_3 == 0)) ||
(*(ulong *)(param_1 + 0x68) <= *(ulong *)(param_1 + 0x20))) {
link_block(param_1,param_2,0,(int)(char)param_3);
}
else {
if (*(int *)((long)param_2 + 0x54) == 1) {
*(ulong *)(param_1 + 0x68) = *(ulong *)(param_1 + 0x68) - 1;
}
*(int4 *)((long)param_2 + 0x54) = 2;
plVar1 = *(long **)(param_1 + 0xb8);
if (plVar1 == (long *)0x0) {
*param_2 = (long)param_2;
*(long **)(param_1 + 0xb8) = param_2;
*(long **)(param_1 + 0xb0) = param_2;
param_2[1] = (long)param_2;
}
else {
*(long **)(*plVar1 + 8) = param_2;
*param_2 = *plVar1;
param_2[1] = (long)plVar1;
*plVar1 = (long)param_2;
*(long **)(param_1 + 0xb8) = param_2;
}
}
lVar4 = *(long *)(param_1 + 0x30);
param_2[0xc] = lVar4;
lVar4 = lVar4 + 1;
*(long *)(param_1 + 0x30) = lVar4;
lVar2 = *(long *)(param_1 + 0xb8);
if ((lVar2 != 0) && (*(ulong *)(param_1 + 0x28) < (ulong)(lVar4 - *(long *)(lVar2 + 0x60)))) {
unlink_block(param_1,lVar2);
link_block(param_1,lVar2,0,0);
if (*(int *)(lVar2 + 0x54) != 1) {
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + 1;
*(int4 *)(lVar2 + 0x54) = 1;
}
}
}
return;
}
|
|
10,827 |
cmp_prec(PycRef<ASTNode>, PycRef<ASTNode>)
|
Pyarmor-Static-Unpack-1shot/ASTree.cpp
|
static int cmp_prec(PycRef<ASTNode> parent, PycRef<ASTNode> child)
{
/* Determine whether the parent has higher precedence than therefore
child, so we don't flood the source code with extraneous parens.
Else we'd have expressions like (((a + b) + c) + d) when therefore
equivalent, a + b + c + d would suffice. */
if (parent.type() == ASTNode::NODE_UNARY && parent.cast<ASTUnary>()->op() == ASTUnary::UN_NOT)
return 1; // Always parenthesize not(x)
if (child.type() == ASTNode::NODE_BINARY) {
PycRef<ASTBinary> binChild = child.cast<ASTBinary>();
if (parent.type() == ASTNode::NODE_BINARY) {
PycRef<ASTBinary> binParent = parent.cast<ASTBinary>();
if (binParent->right() == child) {
if (binParent->op() == ASTBinary::BIN_SUBTRACT &&
binChild->op() == ASTBinary::BIN_ADD)
return 1;
else if (binParent->op() == ASTBinary::BIN_DIVIDE &&
binChild->op() == ASTBinary::BIN_MULTIPLY)
return 1;
}
return binChild->op() - binParent->op();
}
else if (parent.type() == ASTNode::NODE_COMPARE)
return (binChild->op() == ASTBinary::BIN_LOG_AND ||
binChild->op() == ASTBinary::BIN_LOG_OR) ? 1 : -1;
else if (parent.type() == ASTNode::NODE_UNARY)
return (binChild->op() == ASTBinary::BIN_POWER) ? -1 : 1;
} else if (child.type() == ASTNode::NODE_UNARY) {
PycRef<ASTUnary> unChild = child.cast<ASTUnary>();
if (parent.type() == ASTNode::NODE_BINARY) {
PycRef<ASTBinary> binParent = parent.cast<ASTBinary>();
if (binParent->op() == ASTBinary::BIN_LOG_AND ||
binParent->op() == ASTBinary::BIN_LOG_OR)
return -1;
else if (unChild->op() == ASTUnary::UN_NOT)
return 1;
else if (binParent->op() == ASTBinary::BIN_POWER)
return 1;
else
return -1;
} else if (parent.type() == ASTNode::NODE_COMPARE) {
return (unChild->op() == ASTUnary::UN_NOT) ? 1 : -1;
} else if (parent.type() == ASTNode::NODE_UNARY) {
return unChild->op() - parent.cast<ASTUnary>()->op();
}
} else if (child.type() == ASTNode::NODE_COMPARE) {
PycRef<ASTCompare> cmpChild = child.cast<ASTCompare>();
if (parent.type() == ASTNode::NODE_BINARY)
return (parent.cast<ASTBinary>()->op() == ASTBinary::BIN_LOG_AND ||
parent.cast<ASTBinary>()->op() == ASTBinary::BIN_LOG_OR) ? -1 : 1;
else if (parent.type() == ASTNode::NODE_COMPARE)
return cmpChild->op() - parent.cast<ASTCompare>()->op();
else if (parent.type() == ASTNode::NODE_UNARY)
return (parent.cast<ASTUnary>()->op() == ASTUnary::UN_NOT) ? -1 : 1;
}
/* For normal nodes, don't parenthesize anything */
return -1;
}
|
O3
|
cpp
|
cmp_prec(PycRef<ASTNode>, PycRef<ASTNode>):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x282c4
cmpl $0x3, 0xc(%rax)
jne 0x282c4
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29c6e
movq (%rbx), %rdi
movl 0x14(%rdi), %r12d
decl 0x8(%rdi)
jne 0x282b5
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1, %ebx
cmpl $0x3, %r12d
je 0x285c2
movq (%r15), %rax
testq %rax, %rax
je 0x285bd
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x283fa
cmpl $0x5, %eax
je 0x28365
cmpl $0x4, %eax
jne 0x285bd
leaq -0x28(%rbp), %rdi
movq %r15, %rsi
callq 0x29c04
movq (%r14), %rax
testq %rax, %rax
je 0x28473
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x2852f
cmpl $0x5, %eax
je 0x28503
cmpl $0x4, %eax
jne 0x28473
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x29c04
movq -0x30(%rbp), %rdi
movq 0x20(%rdi), %rbx
testq %rbx, %rbx
je 0x28559
movq (%r15), %r14
cmpl $0x0, 0x8(%rbx)
jne 0x28357
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq -0x30(%rbp), %rdi
cmpq %r14, %rbx
jne 0x2858c
jmp 0x2855f
leaq -0x28(%rbp), %rdi
movq %r15, %rsi
callq 0x29672
movq (%r14), %rax
movb $0x1, %r15b
testq %rax, %rax
je 0x2847b
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x284a4
cmpl $0x5, %eax
je 0x2847d
cmpl $0x4, %eax
jne 0x284d2
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x29c04
movq -0x30(%rbp), %rdi
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpl $0xd, 0x14(%rdi)
je 0x28497
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x29c04
movq -0x38(%rbp), %rdi
xorl %ebx, %ebx
cmpl $0xe, 0x14(%rdi)
setne %bl
decl 0x8(%rdi)
jne 0x283e1
movq (%rdi), %rax
callq *0x8(%rax)
leal -0x1(,%rbx,2), %ebx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
jne 0x28497
jmp 0x284cf
leaq -0x28(%rbp), %rdi
movq %r15, %rsi
callq 0x29c6e
movq (%r14), %rax
testq %rax, %rax
je 0x28473
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x28516
cmpl $0x5, %eax
je 0x284f4
cmpl $0x4, %eax
jne 0x28473
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x29c04
movq -0x30(%rbp), %rdi
movl 0x14(%rdi), %eax
leal -0xd(%rax), %ecx
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
jb 0x28596
movq -0x28(%rbp), %rcx
movl $0x1, %ebx
cmpl $0x3, 0x14(%rcx)
je 0x28596
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
leal -0x1(,%rcx,2), %ebx
jmp 0x28596
xorl %r14d, %r14d
jmp 0x285a4
jmp 0x284d2
movq -0x28(%rbp), %rax
movl 0x14(%rax), %ebx
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x29672
movq -0x30(%rbp), %rdi
subl 0x14(%rdi), %ebx
decl 0x8(%rdi)
jne 0x284cf
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x284cf
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x29c6e
movq -0x30(%rbp), %rdi
xorl %ebx, %ebx
cmpl $0x3, 0x14(%rdi)
setne %bl
decl 0x8(%rdi)
jne 0x284c8
movq (%rdi), %rax
callq *0x8(%rax)
leal -0x1(,%rbx,2), %ebx
xorl %r15d, %r15d
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x284e6
decl 0x8(%rdi)
jne 0x284e6
movq (%rdi), %rax
callq *0x8(%rax)
testb %r15b, %r15b
jne 0x285bd
jmp 0x285c2
movq -0x28(%rbp), %rdi
xorl %eax, %eax
cmpl $0x3, 0x14(%rdi)
sete %al
jmp 0x2853c
movq -0x28(%rbp), %rdi
movl 0x14(%rdi), %eax
cmpl $0xd, %eax
jne 0x28548
movl $0x1, %ebx
jmp 0x28543
movq -0x28(%rbp), %rax
movl 0x14(%rax), %ebx
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x29c6e
movq -0x30(%rbp), %rdi
jmp 0x28593
movq -0x28(%rbp), %rdi
xorl %eax, %eax
cmpl $0x1, 0x14(%rdi)
setne %al
leal -0x1(,%rax,2), %ebx
movb $0x1, %r14b
jmp 0x285ad
xorl %ecx, %ecx
cmpl $0xe, %eax
sete %cl
leal -0x1(,%rcx,2), %ebx
jmp 0x285a1
cmpq $0x0, (%r15)
jne 0x2858c
movl 0x14(%rdi), %eax
cmpl $0x3, %eax
je 0x2857d
cmpl $0x7, %eax
jne 0x2858c
movq -0x28(%rbp), %rax
movl $0x1, %ebx
cmpl $0x6, 0x14(%rax)
jne 0x2858c
jmp 0x28596
movq -0x28(%rbp), %rax
movl $0x1, %ebx
cmpl $0x2, 0x14(%rax)
je 0x28596
movq -0x28(%rbp), %rax
movl 0x14(%rax), %ebx
subl 0x14(%rdi), %ebx
decl 0x8(%rdi)
jne 0x285a1
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, %r14b
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x285b8
decl 0x8(%rdi)
jne 0x285b8
movq (%rdi), %rax
callq *0x8(%rax)
testb %r14b, %r14b
jne 0x285c2
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x28608
decl 0x8(%rdi)
jne 0x28608
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x28608
jmp 0x28605
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2861c
callq 0x91d5
jmp 0x2861c
jmp 0x28605
jmp 0x28605
jmp 0x28605
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2861c
decl 0x8(%rdi)
jne 0x2861c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7450
|
_ZL8cmp_prec6PycRefI7ASTNodeES1_:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r15, rsi
mov r14, rdi
mov rax, [rdi]
test rax, rax
jz short loc_282C4
cmp dword ptr [rax+0Ch], 3
jnz short loc_282C4
lea rbx, [rbp+var_28]
mov rdi, rbx
mov rsi, r14
call _ZNK6PycRefI7ASTNodeE4castI8ASTUnaryEES_IT_Ev; PycRef<ASTNode>::cast<ASTUnary>(void)
mov rdi, [rbx]
mov r12d, [rdi+14h]
dec dword ptr [rdi+8]
jnz short loc_282B5
mov rax, [rdi]
call qword ptr [rax+8]
loc_282B5:
mov ebx, 1
cmp r12d, 3
jz loc_285C2
loc_282C4:
mov rax, [r15]
test rax, rax
jz loc_285BD
mov eax, [rax+0Ch]
cmp eax, 3
jz loc_283FA
cmp eax, 5
jz loc_28365
cmp eax, 4
jnz loc_285BD
lea rdi, [rbp+var_28]
mov rsi, r15
call _ZNK6PycRefI7ASTNodeE4castI9ASTBinaryEES_IT_Ev; PycRef<ASTNode>::cast<ASTBinary>(void)
mov rax, [r14]
test rax, rax
jz loc_28473
mov eax, [rax+0Ch]
cmp eax, 3
jz loc_2852F
cmp eax, 5
jz loc_28503
cmp eax, 4
jnz loc_28473
lea rdi, [rbp+var_30]
mov rsi, r14
call _ZNK6PycRefI7ASTNodeE4castI9ASTBinaryEES_IT_Ev; PycRef<ASTNode>::cast<ASTBinary>(void)
mov rdi, [rbp+var_30]
mov rbx, [rdi+20h]
test rbx, rbx
jz loc_28559
mov r14, [r15]
cmp dword ptr [rbx+8], 0
jnz short loc_28357
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+8]
mov rdi, [rbp+var_30]
loc_28357:
cmp rbx, r14
jnz loc_2858C
jmp loc_2855F
loc_28365:
lea rdi, [rbp+var_28]
mov rsi, r15
call _ZNK6PycRefI7ASTNodeE4castI10ASTCompareEES_IT_Ev; PycRef<ASTNode>::cast<ASTCompare>(void)
mov rax, [r14]
mov r15b, 1
test rax, rax
jz loc_2847B
mov eax, [rax+0Ch]
cmp eax, 3
jz loc_284A4
cmp eax, 5
jz loc_2847D
cmp eax, 4
jnz loc_284D2
lea rdi, [rbp+var_30]
mov rsi, r14
call _ZNK6PycRefI7ASTNodeE4castI9ASTBinaryEES_IT_Ev; PycRef<ASTNode>::cast<ASTBinary>(void)
mov rdi, [rbp+var_30]
mov ebx, 0FFFFFFFFh
cmp dword ptr [rdi+14h], 0Dh
jz loc_28497
lea rdi, [rbp+var_38]
mov rsi, r14
call _ZNK6PycRefI7ASTNodeE4castI9ASTBinaryEES_IT_Ev; PycRef<ASTNode>::cast<ASTBinary>(void)
mov rdi, [rbp+var_38]
xor ebx, ebx
cmp dword ptr [rdi+14h], 0Eh
setnz bl
dec dword ptr [rdi+8]
jnz short loc_283E1
mov rax, [rdi]
call qword ptr [rax+8]
loc_283E1:
lea ebx, ds:0FFFFFFFFFFFFFFFFh[rbx*2]
mov rdi, [rbp+var_30]
test rdi, rdi
jnz loc_28497
jmp loc_284CF
loc_283FA:
lea rdi, [rbp+var_28]
mov rsi, r15
call _ZNK6PycRefI7ASTNodeE4castI8ASTUnaryEES_IT_Ev; PycRef<ASTNode>::cast<ASTUnary>(void)
mov rax, [r14]
test rax, rax
jz short loc_28473
mov eax, [rax+0Ch]
cmp eax, 3
jz loc_28516
cmp eax, 5
jz loc_284F4
cmp eax, 4
jnz short loc_28473
lea rdi, [rbp+var_30]
mov rsi, r14
call _ZNK6PycRefI7ASTNodeE4castI9ASTBinaryEES_IT_Ev; PycRef<ASTNode>::cast<ASTBinary>(void)
mov rdi, [rbp+var_30]
mov eax, [rdi+14h]
lea ecx, [rax-0Dh]
mov ebx, 0FFFFFFFFh
cmp ecx, 2
jb loc_28596
mov rcx, [rbp+var_28]
mov ebx, 1
cmp dword ptr [rcx+14h], 3
jz loc_28596
xor ecx, ecx
cmp eax, 1
setz cl
lea ebx, ds:0FFFFFFFFFFFFFFFFh[rcx*2]
jmp loc_28596
loc_28473:
xor r14d, r14d
jmp loc_285A4
loc_2847B:
jmp short loc_284D2
loc_2847D:
mov rax, [rbp+var_28]
mov ebx, [rax+14h]
lea rdi, [rbp+var_30]
mov rsi, r14
call _ZNK6PycRefI7ASTNodeE4castI10ASTCompareEES_IT_Ev; PycRef<ASTNode>::cast<ASTCompare>(void)
mov rdi, [rbp+var_30]
sub ebx, [rdi+14h]
loc_28497:
dec dword ptr [rdi+8]
jnz short loc_284CF
mov rax, [rdi]
call qword ptr [rax+8]
jmp short loc_284CF
loc_284A4:
lea rdi, [rbp+var_30]
mov rsi, r14
call _ZNK6PycRefI7ASTNodeE4castI8ASTUnaryEES_IT_Ev; PycRef<ASTNode>::cast<ASTUnary>(void)
mov rdi, [rbp+var_30]
xor ebx, ebx
cmp dword ptr [rdi+14h], 3
setnz bl
dec dword ptr [rdi+8]
jnz short loc_284C8
mov rax, [rdi]
call qword ptr [rax+8]
loc_284C8:
lea ebx, ds:0FFFFFFFFFFFFFFFFh[rbx*2]
loc_284CF:
xor r15d, r15d
loc_284D2:
mov rdi, [rbp+var_28]
test rdi, rdi
jz short loc_284E6
dec dword ptr [rdi+8]
jnz short loc_284E6
mov rax, [rdi]
call qword ptr [rax+8]
loc_284E6:
test r15b, r15b
jnz loc_285BD
jmp loc_285C2
loc_284F4:
mov rdi, [rbp+var_28]
xor eax, eax
cmp dword ptr [rdi+14h], 3
setz al
jmp short loc_2853C
loc_28503:
mov rdi, [rbp+var_28]
mov eax, [rdi+14h]
cmp eax, 0Dh
jnz short loc_28548
mov ebx, 1
jmp short loc_28543
loc_28516:
mov rax, [rbp+var_28]
mov ebx, [rax+14h]
lea rdi, [rbp+var_30]
mov rsi, r14
call _ZNK6PycRefI7ASTNodeE4castI8ASTUnaryEES_IT_Ev; PycRef<ASTNode>::cast<ASTUnary>(void)
mov rdi, [rbp+var_30]
jmp short loc_28593
loc_2852F:
mov rdi, [rbp+var_28]
xor eax, eax
cmp dword ptr [rdi+14h], 1
setnz al
loc_2853C:
lea ebx, ds:0FFFFFFFFFFFFFFFFh[rax*2]
loc_28543:
mov r14b, 1
jmp short loc_285AD
loc_28548:
xor ecx, ecx
cmp eax, 0Eh
setz cl
lea ebx, ds:0FFFFFFFFFFFFFFFFh[rcx*2]
jmp short loc_285A1
loc_28559:
cmp qword ptr [r15], 0
jnz short loc_2858C
loc_2855F:
mov eax, [rdi+14h]
cmp eax, 3
jz short loc_2857D
cmp eax, 7
jnz short loc_2858C
mov rax, [rbp+var_28]
mov ebx, 1
cmp dword ptr [rax+14h], 6
jnz short loc_2858C
jmp short loc_28596
loc_2857D:
mov rax, [rbp+var_28]
mov ebx, 1
cmp dword ptr [rax+14h], 2
jz short loc_28596
loc_2858C:
mov rax, [rbp+var_28]
mov ebx, [rax+14h]
loc_28593:
sub ebx, [rdi+14h]
loc_28596:
dec dword ptr [rdi+8]
jnz short loc_285A1
mov rax, [rdi]
call qword ptr [rax+8]
loc_285A1:
mov r14b, 1
loc_285A4:
mov rdi, [rbp+var_28]
test rdi, rdi
jz short loc_285B8
loc_285AD:
dec dword ptr [rdi+8]
jnz short loc_285B8
mov rax, [rdi]
call qword ptr [rax+8]
loc_285B8:
test r14b, r14b
jnz short loc_285C2
loc_285BD:
mov ebx, 0FFFFFFFFh
loc_285C2:
mov eax, ebx
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rbp+var_30]
test rdi, rdi
jz short loc_28608
dec dword ptr [rdi+8]
jnz short loc_28608
mov rax, [rdi]
call qword ptr [rax+8]
jmp short loc_28608
jmp short loc_28605
mov rbx, rax
mov rdi, [rbp+var_28]
test rdi, rdi
jz short loc_2861C
call _ZL8cmp_prec6PycRefI7ASTNodeES1__cold_1; cmp_prec(PycRef<ASTNode>,PycRef<ASTNode>) [clone]
jmp short loc_2861C
jmp short loc_28605
jmp short loc_28605
jmp short $+2
loc_28605:
mov rbx, rax
loc_28608:
mov rdi, [rbp+var_28]
test rdi, rdi
jz short loc_2861C
dec dword ptr [rdi+8]
jnz short loc_2861C
mov rax, [rdi]
call qword ptr [rax+8]
loc_2861C:
mov rdi, rbx
call __Unwind_Resume
|
long long cmp_prec(long long a1, long long a2)
{
unsigned int v2; // ebx
long long v4; // rdi
int v5; // r12d
bool v6; // zf
int v7; // eax
int v8; // eax
_DWORD *v9; // rdi
_DWORD *v10; // rbx
_DWORD *v11; // r14
char v12; // r15
int v13; // eax
_DWORD *v14; // rdi
long long v15; // rdi
BOOL v16; // ebx
int v17; // eax
int v18; // eax
char v19; // r14
int v20; // ebx
long long v21; // rdi
BOOL v22; // ebx
long long v23; // rdi
_DWORD *v24; // rdi
BOOL v25; // eax
int v26; // eax
int v27; // ebx
int v28; // eax
long long v30; // [rsp+8h] [rbp-38h] BYREF
long long v31; // [rsp+10h] [rbp-30h] BYREF
_QWORD v32[5]; // [rsp+18h] [rbp-28h] BYREF
if ( *(_QWORD *)a1 && *(_DWORD *)(*(_QWORD *)a1 + 12LL) == 3 )
{
PycRef<ASTNode>::cast<ASTUnary>(v32, a1);
v4 = v32[0];
v5 = *(_DWORD *)(v32[0] + 20LL);
v6 = (*(_DWORD *)(v32[0] + 8LL))-- == 1;
if ( v6 )
(*(void ( **)(long long))(*(_QWORD *)v4 + 8LL))(v4);
v2 = 1;
if ( v5 == 3 )
return v2;
}
if ( !*(_QWORD *)a2 )
return (unsigned int)-1;
v7 = *(_DWORD *)(*(_QWORD *)a2 + 12LL);
if ( v7 == 3 )
{
PycRef<ASTNode>::cast<ASTUnary>(v32, a2);
if ( !*(_QWORD *)a1 )
goto LABEL_35;
v17 = *(_DWORD *)(*(_QWORD *)a1 + 12LL);
if ( v17 == 3 )
{
v27 = *(_DWORD *)(v32[0] + 20LL);
PycRef<ASTNode>::cast<ASTUnary>(&v31, a1);
v9 = (_DWORD *)v31;
LABEL_64:
v2 = v27 - v9[5];
goto LABEL_65;
}
if ( v17 != 5 )
{
if ( v17 == 4 )
{
PycRef<ASTNode>::cast<ASTBinary>(&v31, a1);
v9 = (_DWORD *)v31;
v18 = *(_DWORD *)(v31 + 20);
v2 = -1;
if ( (unsigned int)(v18 - 13) >= 2 )
{
v2 = 1;
if ( *(_DWORD *)(v32[0] + 20LL) != 3 )
v2 = 2 * (v18 == 1) - 1;
}
goto LABEL_65;
}
goto LABEL_35;
}
v24 = (_DWORD *)v32[0];
v25 = *(_DWORD *)(v32[0] + 20LL) == 3;
goto LABEL_54;
}
if ( v7 == 5 )
{
PycRef<ASTNode>::cast<ASTCompare>(v32, a2);
v12 = 1;
if ( !*(_QWORD *)a1 )
goto LABEL_44;
v13 = *(_DWORD *)(*(_QWORD *)a1 + 12LL);
switch ( v13 )
{
case 3:
PycRef<ASTNode>::cast<ASTUnary>(&v31, a1);
v21 = v31;
v22 = *(_DWORD *)(v31 + 20) != 3;
v6 = (*(_DWORD *)(v31 + 8))-- == 1;
if ( v6 )
(*(void ( **)(long long))(*(_QWORD *)v21 + 8LL))(v21);
v2 = 2 * v22 - 1;
goto LABEL_43;
case 5:
v20 = *(_DWORD *)(v32[0] + 20LL);
PycRef<ASTNode>::cast<ASTCompare>(&v31, a1);
v14 = (_DWORD *)v31;
v2 = v20 - *(_DWORD *)(v31 + 20);
break;
case 4:
PycRef<ASTNode>::cast<ASTBinary>(&v31, a1);
v14 = (_DWORD *)v31;
v2 = -1;
if ( *(_DWORD *)(v31 + 20) != 13 )
{
PycRef<ASTNode>::cast<ASTBinary>(&v30, a1);
v15 = v30;
v16 = *(_DWORD *)(v30 + 20) != 14;
v6 = (*(_DWORD *)(v30 + 8))-- == 1;
if ( v6 )
(*(void ( **)(long long))(*(_QWORD *)v15 + 8LL))(v15);
v2 = 2 * v16 - 1;
v14 = (_DWORD *)v31;
if ( !v31 )
{
LABEL_43:
v12 = 0;
goto LABEL_44;
}
}
break;
default:
LABEL_44:
v23 = v32[0];
if ( v32[0] )
{
v6 = (*(_DWORD *)(v32[0] + 8LL))-- == 1;
if ( v6 )
(*(void ( **)(long long))(*(_QWORD *)v23 + 8LL))(v23);
}
if ( v12 )
return (unsigned int)-1;
return v2;
}
v6 = v14[2]-- == 1;
if ( v6 )
(*(void ( **)(_DWORD *))(*(_QWORD *)v14 + 8LL))(v14);
goto LABEL_43;
}
if ( v7 != 4 )
return (unsigned int)-1;
PycRef<ASTNode>::cast<ASTBinary>(v32, a2);
if ( !*(_QWORD *)a1 )
goto LABEL_35;
v8 = *(_DWORD *)(*(_QWORD *)a1 + 12LL);
if ( v8 == 3 )
{
v24 = (_DWORD *)v32[0];
v25 = *(_DWORD *)(v32[0] + 20LL) != 1;
LABEL_54:
v2 = 2 * v25 - 1;
goto LABEL_55;
}
if ( v8 != 5 )
{
if ( v8 == 4 )
{
PycRef<ASTNode>::cast<ASTBinary>(&v31, a1);
v9 = (_DWORD *)v31;
v10 = *(_DWORD **)(v31 + 32);
if ( v10 )
{
v11 = *(_DWORD **)a2;
if ( !v10[2] )
{
(*(void ( **)(_QWORD))(*(_QWORD *)v10 + 8LL))(*(_QWORD *)(v31 + 32));
v9 = (_DWORD *)v31;
}
if ( v10 == v11 )
{
LABEL_58:
v28 = v9[5];
if ( v28 == 3 )
{
v2 = 1;
if ( *(_DWORD *)(v32[0] + 20LL) == 2 )
goto LABEL_65;
}
else if ( v28 == 7 )
{
v2 = 1;
if ( *(_DWORD *)(v32[0] + 20LL) == 6 )
{
LABEL_65:
v6 = v9[2]-- == 1;
if ( v6 )
(*(void ( **)(_DWORD *))(*(_QWORD *)v9 + 8LL))(v9);
goto LABEL_67;
}
}
}
}
else if ( !*(_QWORD *)a2 )
{
goto LABEL_58;
}
v27 = *(_DWORD *)(v32[0] + 20LL);
goto LABEL_64;
}
LABEL_35:
v19 = 0;
goto LABEL_68;
}
v24 = (_DWORD *)v32[0];
v26 = *(_DWORD *)(v32[0] + 20LL);
if ( v26 != 13 )
{
v2 = 2 * (v26 == 14) - 1;
LABEL_67:
v19 = 1;
LABEL_68:
v24 = (_DWORD *)v32[0];
if ( !v32[0] )
goto LABEL_71;
goto LABEL_69;
}
v2 = 1;
LABEL_55:
v19 = 1;
LABEL_69:
v6 = v24[2]-- == 1;
if ( v6 )
(*(void ( **)(_DWORD *))(*(_QWORD *)v24 + 8LL))(v24);
LABEL_71:
if ( !v19 )
return (unsigned int)-1;
return v2;
}
|
cmp_prec:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001282c4
CMP dword ptr [RAX + 0xc],0x3
JNZ 0x001282c4
LEA RBX,[RBP + -0x28]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00129c6e
MOV RDI,qword ptr [RBX]
MOV R12D,dword ptr [RDI + 0x14]
DEC dword ptr [RDI + 0x8]
JNZ 0x001282b5
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_001282b5:
MOV EBX,0x1
CMP R12D,0x3
JZ 0x001285c2
LAB_001282c4:
MOV RAX,qword ptr [R15]
TEST RAX,RAX
JZ 0x001285bd
MOV EAX,dword ptr [RAX + 0xc]
CMP EAX,0x3
JZ 0x001283fa
CMP EAX,0x5
JZ 0x00128365
CMP EAX,0x4
JNZ 0x001285bd
LEA RDI,[RBP + -0x28]
MOV RSI,R15
CALL 0x00129c04
MOV RAX,qword ptr [R14]
TEST RAX,RAX
JZ 0x00128473
MOV EAX,dword ptr [RAX + 0xc]
CMP EAX,0x3
JZ 0x0012852f
CMP EAX,0x5
JZ 0x00128503
CMP EAX,0x4
JNZ 0x00128473
LAB_00128324:
LEA RDI,[RBP + -0x30]
MOV RSI,R14
CALL 0x00129c04
LAB_00128330:
MOV RDI,qword ptr [RBP + -0x30]
MOV RBX,qword ptr [RDI + 0x20]
TEST RBX,RBX
JZ 0x00128559
MOV R14,qword ptr [R15]
CMP dword ptr [RBX + 0x8],0x0
JNZ 0x00128357
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x30]
LAB_00128357:
CMP RBX,R14
JNZ 0x0012858c
JMP 0x0012855f
LAB_00128365:
LEA RDI,[RBP + -0x28]
MOV RSI,R15
CALL 0x00129672
MOV RAX,qword ptr [R14]
MOV R15B,0x1
TEST RAX,RAX
JZ 0x0012847b
MOV EAX,dword ptr [RAX + 0xc]
CMP EAX,0x3
JZ 0x001284a4
CMP EAX,0x5
JZ 0x0012847d
CMP EAX,0x4
JNZ 0x001284d2
LAB_0012839e:
LEA RDI,[RBP + -0x30]
MOV RSI,R14
CALL 0x00129c04
MOV RDI,qword ptr [RBP + -0x30]
MOV EBX,0xffffffff
CMP dword ptr [RDI + 0x14],0xd
JZ 0x00128497
LAB_001283bd:
LEA RDI,[RBP + -0x38]
MOV RSI,R14
CALL 0x00129c04
LAB_001283c9:
MOV RDI,qword ptr [RBP + -0x38]
XOR EBX,EBX
CMP dword ptr [RDI + 0x14],0xe
SETNZ BL
DEC dword ptr [RDI + 0x8]
JNZ 0x001283e1
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_001283e1:
LEA EBX,[-0x1 + RBX*0x2]
MOV RDI,qword ptr [RBP + -0x30]
TEST RDI,RDI
JNZ 0x00128497
JMP 0x001284cf
LAB_001283fa:
LEA RDI,[RBP + -0x28]
MOV RSI,R15
CALL 0x00129c6e
MOV RAX,qword ptr [R14]
TEST RAX,RAX
JZ 0x00128473
MOV EAX,dword ptr [RAX + 0xc]
CMP EAX,0x3
JZ 0x00128516
CMP EAX,0x5
JZ 0x001284f4
CMP EAX,0x4
JNZ 0x00128473
LAB_00128428:
LEA RDI,[RBP + -0x30]
MOV RSI,R14
CALL 0x00129c04
MOV RDI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RDI + 0x14]
LEA ECX,[RAX + -0xd]
MOV EBX,0xffffffff
CMP ECX,0x2
JC 0x00128596
MOV RCX,qword ptr [RBP + -0x28]
MOV EBX,0x1
CMP dword ptr [RCX + 0x14],0x3
JZ 0x00128596
XOR ECX,ECX
CMP EAX,0x1
SETZ CL
LEA EBX,[-0x1 + RCX*0x2]
JMP 0x00128596
LAB_00128473:
XOR R14D,R14D
JMP 0x001285a4
LAB_0012847b:
JMP 0x001284d2
LAB_0012847d:
MOV RAX,qword ptr [RBP + -0x28]
MOV EBX,dword ptr [RAX + 0x14]
LAB_00128484:
LEA RDI,[RBP + -0x30]
MOV RSI,R14
CALL 0x00129672
LAB_00128490:
MOV RDI,qword ptr [RBP + -0x30]
SUB EBX,dword ptr [RDI + 0x14]
LAB_00128497:
DEC dword ptr [RDI + 0x8]
JNZ 0x001284cf
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
JMP 0x001284cf
LAB_001284a4:
LEA RDI,[RBP + -0x30]
MOV RSI,R14
CALL 0x00129c6e
LAB_001284b0:
MOV RDI,qword ptr [RBP + -0x30]
XOR EBX,EBX
CMP dword ptr [RDI + 0x14],0x3
SETNZ BL
DEC dword ptr [RDI + 0x8]
JNZ 0x001284c8
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_001284c8:
LEA EBX,[-0x1 + RBX*0x2]
LAB_001284cf:
XOR R15D,R15D
LAB_001284d2:
MOV RDI,qword ptr [RBP + -0x28]
TEST RDI,RDI
JZ 0x001284e6
DEC dword ptr [RDI + 0x8]
JNZ 0x001284e6
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_001284e6:
TEST R15B,R15B
JNZ 0x001285bd
JMP 0x001285c2
LAB_001284f4:
MOV RDI,qword ptr [RBP + -0x28]
XOR EAX,EAX
CMP dword ptr [RDI + 0x14],0x3
SETZ AL
JMP 0x0012853c
LAB_00128503:
MOV RDI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RDI + 0x14]
CMP EAX,0xd
JNZ 0x00128548
MOV EBX,0x1
JMP 0x00128543
LAB_00128516:
MOV RAX,qword ptr [RBP + -0x28]
MOV EBX,dword ptr [RAX + 0x14]
LAB_0012851d:
LEA RDI,[RBP + -0x30]
MOV RSI,R14
CALL 0x00129c6e
LAB_00128529:
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x00128593
LAB_0012852f:
MOV RDI,qword ptr [RBP + -0x28]
XOR EAX,EAX
CMP dword ptr [RDI + 0x14],0x1
SETNZ AL
LAB_0012853c:
LEA EBX,[-0x1 + RAX*0x2]
LAB_00128543:
MOV R14B,0x1
JMP 0x001285ad
LAB_00128548:
XOR ECX,ECX
CMP EAX,0xe
SETZ CL
LEA EBX,[-0x1 + RCX*0x2]
JMP 0x001285a1
LAB_00128559:
CMP qword ptr [R15],0x0
JNZ 0x0012858c
LAB_0012855f:
MOV EAX,dword ptr [RDI + 0x14]
CMP EAX,0x3
JZ 0x0012857d
CMP EAX,0x7
JNZ 0x0012858c
MOV RAX,qword ptr [RBP + -0x28]
MOV EBX,0x1
CMP dword ptr [RAX + 0x14],0x6
JNZ 0x0012858c
JMP 0x00128596
LAB_0012857d:
MOV RAX,qword ptr [RBP + -0x28]
MOV EBX,0x1
CMP dword ptr [RAX + 0x14],0x2
JZ 0x00128596
LAB_0012858c:
MOV RAX,qword ptr [RBP + -0x28]
MOV EBX,dword ptr [RAX + 0x14]
LAB_00128593:
SUB EBX,dword ptr [RDI + 0x14]
LAB_00128596:
DEC dword ptr [RDI + 0x8]
JNZ 0x001285a1
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_001285a1:
MOV R14B,0x1
LAB_001285a4:
MOV RDI,qword ptr [RBP + -0x28]
TEST RDI,RDI
JZ 0x001285b8
LAB_001285ad:
DEC dword ptr [RDI + 0x8]
JNZ 0x001285b8
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_001285b8:
TEST R14B,R14B
JNZ 0x001285c2
LAB_001285bd:
MOV EBX,0xffffffff
LAB_001285c2:
MOV EAX,EBX
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* cmp_prec(PycRef<ASTNode>, PycRef<ASTNode>) */
int cmp_prec(long *param_1,long *param_2)
{
long *plVar1;
int unaff_EBX;
int iVar2;
bool bVar3;
long *local_40;
long *local_38;
long *local_30;
if ((*param_1 != 0) && (*(int *)(*param_1 + 0xc) == 3)) {
PycRef<ASTNode>::cast<ASTUnary>();
iVar2 = *(int *)((long)local_30 + 0x14);
plVar1 = local_30 + 1;
*(int *)plVar1 = (int)*plVar1 + -1;
if ((int)*plVar1 == 0) {
(**(code **)(*local_30 + 8))();
}
unaff_EBX = 1;
if (iVar2 == 3) {
return 1;
}
}
if (*param_2 == 0) {
return -1;
}
iVar2 = *(int *)(*param_2 + 0xc);
if (iVar2 == 3) {
PycRef<ASTNode>::cast<ASTUnary>();
if (*param_1 == 0) {
LAB_00128473:
bVar3 = false;
}
else {
iVar2 = *(int *)(*param_1 + 0xc);
if (iVar2 != 3) {
if (iVar2 == 5) {
bVar3 = *(int *)((long)local_30 + 0x14) == 3;
goto LAB_0012853c;
}
if (iVar2 != 4) goto LAB_00128473;
/* try { // try from 00128428 to 00128433 has its CatchHandler @ 001285ea */
PycRef<ASTNode>::cast<ASTBinary>();
unaff_EBX = -1;
if ((1 < *(int *)((long)local_38 + 0x14) - 0xdU) &&
(unaff_EBX = 1, *(int *)((long)local_30 + 0x14) != 3)) {
unaff_EBX = (uint)(*(int *)((long)local_38 + 0x14) == 1) * 2 + -1;
}
goto LAB_00128596;
}
iVar2 = *(int *)((long)local_30 + 0x14);
/* try { // try from 0012851d to 00128528 has its CatchHandler @ 001285ff */
PycRef<ASTNode>::cast<ASTUnary>();
LAB_00128593:
unaff_EBX = iVar2 - *(int *)((long)local_38 + 0x14);
LAB_00128596:
plVar1 = local_38 + 1;
*(int *)plVar1 = (int)*plVar1 + -1;
if ((int)*plVar1 == 0) {
(**(code **)(*local_38 + 8))();
}
LAB_001285a1:
bVar3 = true;
}
if (local_30 == (long *)0x0) goto LAB_001285b8;
}
else {
if (iVar2 == 5) {
PycRef<ASTNode>::cast<ASTCompare>();
bVar3 = true;
if (*param_1 == 0) goto LAB_001284d2;
iVar2 = *(int *)(*param_1 + 0xc);
if (iVar2 == 3) {
/* try { // try from 001284a4 to 001284af has its CatchHandler @ 00128601 */
PycRef<ASTNode>::cast<ASTUnary>();
iVar2 = *(int *)((long)local_38 + 0x14);
plVar1 = local_38 + 1;
*(int *)plVar1 = (int)*plVar1 + -1;
if ((int)*plVar1 == 0) {
(**(code **)(*local_38 + 8))();
}
unaff_EBX = (uint)(iVar2 != 3) * 2 + -1;
}
else {
if (iVar2 == 5) {
iVar2 = *(int *)((long)local_30 + 0x14);
/* try { // try from 00128484 to 0012848f has its CatchHandler @ 00128603 */
PycRef<ASTNode>::cast<ASTCompare>();
unaff_EBX = iVar2 - *(int *)((long)local_38 + 0x14);
}
else {
if (iVar2 != 4) goto LAB_001284d2;
/* try { // try from 0012839e to 001283a9 has its CatchHandler @ 00128605 */
PycRef<ASTNode>::cast<ASTBinary>();
unaff_EBX = -1;
if (*(int *)((long)local_38 + 0x14) != 0xd) {
/* try { // try from 001283bd to 001283c8 has its CatchHandler @ 001285d1 */
PycRef<ASTNode>::cast<ASTBinary>();
iVar2 = *(int *)((long)local_40 + 0x14);
plVar1 = local_40 + 1;
*(int *)plVar1 = (int)*plVar1 + -1;
if ((int)*plVar1 == 0) {
(**(code **)(*local_40 + 8))();
}
unaff_EBX = (uint)(iVar2 != 0xe) * 2 + -1;
if (local_38 == (long *)0x0) goto LAB_001284cf;
}
}
plVar1 = local_38 + 1;
*(int *)plVar1 = (int)*plVar1 + -1;
if ((int)*plVar1 == 0) {
(**(code **)(*local_38 + 8))();
}
}
LAB_001284cf:
bVar3 = false;
LAB_001284d2:
if (local_30 != (long *)0x0) {
plVar1 = local_30 + 1;
*(int *)plVar1 = (int)*plVar1 + -1;
if ((int)*plVar1 == 0) {
(**(code **)(*local_30 + 8))();
}
}
if (bVar3) {
return -1;
}
return unaff_EBX;
}
if (iVar2 != 4) {
return -1;
}
PycRef<ASTNode>::cast<ASTBinary>();
if (*param_1 == 0) goto LAB_00128473;
iVar2 = *(int *)(*param_1 + 0xc);
if (iVar2 != 3) {
if (iVar2 != 5) {
if (iVar2 != 4) goto LAB_00128473;
/* try { // try from 00128324 to 0012832f has its CatchHandler @ 001285ec */
PycRef<ASTNode>::cast<ASTBinary>();
plVar1 = (long *)local_38[4];
if (plVar1 == (long *)0x0) {
if (*param_2 == 0) goto LAB_0012855f;
LAB_0012858c:
iVar2 = *(int *)((long)local_30 + 0x14);
goto LAB_00128593;
}
param_2 = (long *)*param_2;
if ((int)plVar1[1] == 0) {
(**(code **)(*plVar1 + 8))(plVar1);
}
if (plVar1 != param_2) goto LAB_0012858c;
LAB_0012855f:
if (*(int *)((long)local_38 + 0x14) == 3) {
unaff_EBX = 1;
if (*(int *)((long)local_30 + 0x14) != 2) goto LAB_0012858c;
}
else if ((*(int *)((long)local_38 + 0x14) != 7) ||
(unaff_EBX = 1, *(int *)((long)local_30 + 0x14) != 6)) goto LAB_0012858c;
goto LAB_00128596;
}
if (*(int *)((long)local_30 + 0x14) == 0xd) {
unaff_EBX = 1;
goto LAB_00128543;
}
unaff_EBX = (uint)(*(int *)((long)local_30 + 0x14) == 0xe) * 2 + -1;
goto LAB_001285a1;
}
bVar3 = *(int *)((long)local_30 + 0x14) != 1;
LAB_0012853c:
unaff_EBX = (uint)bVar3 * 2 + -1;
LAB_00128543:
bVar3 = true;
}
plVar1 = local_30 + 1;
*(int *)plVar1 = (int)*plVar1 + -1;
if ((int)*plVar1 == 0) {
(**(code **)(*local_30 + 8))();
}
LAB_001285b8:
if (!bVar3) {
return -1;
}
return unaff_EBX;
}
|
|
10,828 |
LefDefParser::lefwLayerEnclosureWidth(char const*, double, double, double, double)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwLayerEnclosureWidth(const char *location,
double overhang1,
double overhang2,
double width, // optional
double cutWithin)
{ // optional
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYER_START &&
lefwState != LEFW_LAYER)
return LEFW_BAD_ORDER;
if (!lefwIsCut)
return LEFW_BAD_DATA; // only cut calls this func
if (lefwIsMaxviastack)
return LEFW_BAD_ORDER; // Layer after maximum stacked-via
if (lefwWriteEncrypt) {
encPrint(lefwFile, (char*) " ENCLOSURE ");
if (location && (*location != 0)) {
if (strcmp(location, "ABOVE") && strcmp(location, "BELOW")) {
encPrint(lefwFile, (char*)
"ENCLOSURE in Layer(Cut) can only be ABOVE, BELOW.\n");
return LEFW_BAD_DATA;
}
encPrint(lefwFile, (char*) "%s ", location);
}
encPrint(lefwFile, (char*) "%.11g %.11g ", overhang1, overhang2);
if (width) {
encPrint(lefwFile, (char*) "WIDTH %.11g ", width);
if (cutWithin)
encPrint(lefwFile, (char*) "EXCEPTEXTRACUT %.11g ", cutWithin);
}
encPrint(lefwFile, (char*) ";\n");
} else {
fprintf(lefwFile, " ENCLOSURE ");
if (location && (*location != 0)) {
if (strcmp(location, "ABOVE") && strcmp(location, "BELOW")) {
fprintf(lefwFile,
"ENCLOSURE in Layer(Cut) can only be ABOVE, BELOW.\n");
return LEFW_BAD_DATA;
}
fprintf(lefwFile, "%s ", location);
}
fprintf(lefwFile, "%.11g %.11g ", overhang1, overhang2);
if (width) {
fprintf(lefwFile, "WIDTH %.11g ", width);
if (cutWithin)
fprintf(lefwFile, "EXCEPTEXTRACUT %.11g ", cutWithin);
}
fprintf(lefwFile, ";\n");
}
lefwLines++;
lefwState = LEFW_LAYER;
return LEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::lefwLayerEnclosureWidth(char const*, double, double, double, double):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
leaq 0x24568(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0xe8ab
movl $0x1, 0x34(%rsp)
jmp 0xebb4
leaq 0x2479e(%rip), %rax # 0x33050
cmpl $0x6, (%rax)
je 0xe8d0
leaq 0x24792(%rip), %rax # 0x33050
cmpl $0x1c, (%rax)
je 0xe8d0
movl $0x2, 0x34(%rsp)
jmp 0xebb4
leaq 0x247ad(%rip), %rax # 0x33084
cmpl $0x0, (%rax)
jne 0xe8e9
movl $0x3, 0x34(%rsp)
jmp 0xebb4
leaq 0x247c4(%rip), %rax # 0x330b4
cmpl $0x0, (%rax)
je 0xe902
movl $0x2, 0x34(%rsp)
jmp 0xebb4
cmpl $0x0, 0x247e3(%rip) # 0x330ec
je 0xea4f
leaq 0x244ea(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x1b8ee(%rip), %rsi # 0x2a20e
movb $0x0, %al
callq 0x289b0
cmpq $0x0, 0x28(%rsp)
je 0xe9aa
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xe9aa
movq 0x28(%rsp), %rdi
leaq 0x1affa(%rip), %rsi # 0x29942
callq 0x10f0
cmpl $0x0, %eax
je 0xe98d
movq 0x28(%rsp), %rdi
leaq 0x1afda(%rip), %rsi # 0x29938
callq 0x10f0
cmpl $0x0, %eax
je 0xe98d
leaq 0x24491(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x1b8d3(%rip), %rsi # 0x2a24c
movb $0x0, %al
callq 0x289b0
movl $0x3, 0x34(%rsp)
jmp 0xebb4
leaq 0x2446c(%rip), %rax # 0x32e00
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x1bacc(%rip), %rsi # 0x2a46f
movb $0x0, %al
callq 0x289b0
leaq 0x2444f(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
leaq 0x1d250(%rip), %rsi # 0x2bc17
movb $0x2, %al
callq 0x289b0
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe9e1
jp 0xe9e1
jmp 0xea32
leaq 0x24418(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x10(%rsp), %xmm0
leaq 0x1ba36(%rip), %rsi # 0x2a42e
movb $0x1, %al
callq 0x289b0
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xea12
jp 0xea12
jmp 0xea30
leaq 0x243e7(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x1b7f3(%rip), %rsi # 0x2a21c
movb $0x1, %al
callq 0x289b0
jmp 0xea32
leaq 0x243c7(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x1b511(%rip), %rsi # 0x29f54
movb $0x0, %al
callq 0x289b0
jmp 0xeb8a
leaq 0x243aa(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x1b7ae(%rip), %rsi # 0x2a20e
movb $0x0, %al
callq 0x1100
cmpq $0x0, 0x28(%rsp)
je 0xeaea
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xeaea
movq 0x28(%rsp), %rdi
leaq 0x1aeba(%rip), %rsi # 0x29942
callq 0x10f0
cmpl $0x0, %eax
je 0xeacd
movq 0x28(%rsp), %rdi
leaq 0x1ae9a(%rip), %rsi # 0x29938
callq 0x10f0
cmpl $0x0, %eax
je 0xeacd
leaq 0x24351(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x1b793(%rip), %rsi # 0x2a24c
movb $0x0, %al
callq 0x1100
movl $0x3, 0x34(%rsp)
jmp 0xebb4
leaq 0x2432c(%rip), %rax # 0x32e00
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x1b98c(%rip), %rsi # 0x2a46f
movb $0x0, %al
callq 0x1100
leaq 0x2430f(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
leaq 0x1d110(%rip), %rsi # 0x2bc17
movb $0x2, %al
callq 0x1100
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xeb21
jp 0xeb21
jmp 0xeb72
leaq 0x242d8(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x10(%rsp), %xmm0
leaq 0x1b8f6(%rip), %rsi # 0x2a42e
movb $0x1, %al
callq 0x1100
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xeb52
jp 0xeb52
jmp 0xeb70
leaq 0x242a7(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x1b6b3(%rip), %rsi # 0x2a21c
movb $0x1, %al
callq 0x1100
jmp 0xeb72
leaq 0x24287(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x1b3d1(%rip), %rsi # 0x29f54
movb $0x0, %al
callq 0x1100
leaq 0x244bb(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x244af(%rip), %rax # 0x3304c
movl %ecx, (%rax)
leaq 0x244aa(%rip), %rax # 0x33050
movl $0x1c, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
|
_ZN12LefDefParser23lefwLayerEnclosureWidthEPKcdddd:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
movsd [rsp+38h+var_18], xmm0
movsd [rsp+38h+var_20], xmm1
movsd [rsp+38h+var_28], xmm2
movsd [rsp+38h+var_30], xmm3
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_E8AB
mov [rsp+38h+var_4], 1
jmp loc_EBB4
loc_E8AB:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 6
jz short loc_E8D0
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 1Ch
jz short loc_E8D0
mov [rsp+38h+var_4], 2
jmp loc_EBB4
loc_E8D0:
lea rax, _ZN12LefDefParser9lefwIsCutE; LefDefParser::lefwIsCut
cmp dword ptr [rax], 0
jnz short loc_E8E9
mov [rsp+38h+var_4], 3
jmp loc_EBB4
loc_E8E9:
lea rax, _ZN12LefDefParser17lefwIsMaxviastackE; LefDefParser::lefwIsMaxviastack
cmp dword ptr [rax], 0
jz short loc_E902
mov [rsp+38h+var_4], 2
jmp loc_EBB4
loc_E902:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz loc_EA4F
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aEnclosure; " ENCLOSURE "
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
cmp [rsp+38h+var_10], 0
jz short loc_E9AA
mov rax, [rsp+38h+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_E9AA
mov rdi, [rsp+38h+var_10]
lea rsi, aFromabove+4; "ABOVE"
call _strcmp
cmp eax, 0
jz short loc_E98D
mov rdi, [rsp+38h+var_10]
lea rsi, aFrombelow+4; "BELOW"
call _strcmp
cmp eax, 0
jz short loc_E98D
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aPreferenclosur_0+6; "ENCLOSURE in Layer(Cut) can only be ABO"...
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
mov [rsp+38h+var_4], 3
jmp loc_EBB4
loc_E98D:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+38h+var_10]
lea rsi, aS+6; "%s "
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
loc_E9AA:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+38h+var_18]
movsd xmm1, [rsp+38h+var_20]
lea rsi, a11g11g+0Bh; "%.11g %.11g "
mov al, 2
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
movsd xmm0, [rsp+38h+var_28]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_E9E1
jp short loc_E9E1
jmp short loc_EA32
loc_E9E1:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+38h+var_28]
lea rsi, aMinimumcut11gW+14h; "WIDTH %.11g "
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
movsd xmm0, [rsp+38h+var_30]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_EA12
jp short loc_EA12
jmp short loc_EA30
loc_EA12:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+38h+var_30]
lea rsi, aExceptextracut; "EXCEPTEXTRACUT %.11g "
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
loc_EA30:
jmp short $+2
loc_EA32:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aDividercharS+11h; ";\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp loc_EB8A
loc_EA4F:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aEnclosure; " ENCLOSURE "
mov al, 0
call _fprintf
cmp [rsp+38h+var_10], 0
jz short loc_EAEA
mov rax, [rsp+38h+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_EAEA
mov rdi, [rsp+38h+var_10]
lea rsi, aFromabove+4; "ABOVE"
call _strcmp
cmp eax, 0
jz short loc_EACD
mov rdi, [rsp+38h+var_10]
lea rsi, aFrombelow+4; "BELOW"
call _strcmp
cmp eax, 0
jz short loc_EACD
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aPreferenclosur_0+6; "ENCLOSURE in Layer(Cut) can only be ABO"...
mov al, 0
call _fprintf
mov [rsp+38h+var_4], 3
jmp loc_EBB4
loc_EACD:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+38h+var_10]
lea rsi, aS+6; "%s "
mov al, 0
call _fprintf
loc_EAEA:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+38h+var_18]
movsd xmm1, [rsp+38h+var_20]
lea rsi, a11g11g+0Bh; "%.11g %.11g "
mov al, 2
call _fprintf
movsd xmm0, [rsp+38h+var_28]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_EB21
jp short loc_EB21
jmp short loc_EB72
loc_EB21:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+38h+var_28]
lea rsi, aMinimumcut11gW+14h; "WIDTH %.11g "
mov al, 1
call _fprintf
movsd xmm0, [rsp+38h+var_30]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_EB52
jp short loc_EB52
jmp short loc_EB70
loc_EB52:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+38h+var_30]
lea rsi, aExceptextracut; "EXCEPTEXTRACUT %.11g "
mov al, 1
call _fprintf
loc_EB70:
jmp short $+2
loc_EB72:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aDividercharS+11h; ";\n"
mov al, 0
call _fprintf
loc_EB8A:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 1Ch
mov [rsp+38h+var_4], 0
loc_EBB4:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
|
long long LefDefParser::lefwLayerEnclosureWidth(
LefDefParser *this,
const char *a2,
double a3,
double a4,
double a5,
double a6,
int a7,
int a8,
int a9,
int a10)
{
int v10; // edx
int v11; // ecx
int v12; // r8d
int v13; // r9d
int v14; // ecx
int v15; // r8d
int v16; // r9d
int v17; // edx
int v18; // edx
int v19; // ecx
int v20; // r8d
int v21; // r9d
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwState == 6 || LefDefParser::lefwState == 28 )
{
if ( LefDefParser::lefwIsCut )
{
if ( !LefDefParser::lefwIsMaxviastack )
{
if ( LefDefParser::lefwWriteEncrypt )
{
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" ENCLOSURE ", a7, a8, a9, a10);
if ( this && *(_BYTE *)this )
{
if ( (unsigned int)strcmp(this, "ABOVE") && (unsigned int)strcmp(this, "BELOW") )
{
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)"ENCLOSURE in Layer(Cut) can only be ABOVE, BELOW.\n",
v17,
v14,
v15,
v16);
return 3;
}
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"%s ", (_DWORD)this, v14, v15, v16);
}
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"%.11g %.11g ", v10, v11, v12, v13);
if ( a5 != 0.0 )
{
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"WIDTH %.11g ", v18, v19, v20, v21);
if ( a6 != 0.0 )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)"EXCEPTEXTRACUT %.11g ",
v18,
v19,
v20,
v21);
}
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)";\n", v18, v19, v20, v21);
}
else
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " ENCLOSURE ");
if ( this && *(_BYTE *)this )
{
if ( (unsigned int)strcmp(this, "ABOVE") && (unsigned int)strcmp(this, "BELOW") )
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "ENCLOSURE in Layer(Cut) can only be ABOVE, BELOW.\n");
return 3;
}
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "%s ", (const char *)this);
}
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "%.11g %.11g ", a3, a4);
if ( a5 != 0.0 )
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "WIDTH %.11g ", a5);
if ( a6 != 0.0 )
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "EXCEPTEXTRACUT %.11g ", a6);
}
fprintf(*(_QWORD *)&LefDefParser::lefwFile, ";\n");
}
++LefDefParser::lefwLines;
LefDefParser::lefwState = 28;
return 0;
}
return 2;
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
lefwLayerEnclosureWidth:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOVSD qword ptr [RSP + 0x20],XMM0
MOVSD qword ptr [RSP + 0x18],XMM1
MOVSD qword ptr [RSP + 0x10],XMM2
MOVSD qword ptr [RSP + 0x8],XMM3
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x0010e8ab
MOV dword ptr [RSP + 0x34],0x1
JMP 0x0010ebb4
LAB_0010e8ab:
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x6
JZ 0x0010e8d0
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x1c
JZ 0x0010e8d0
MOV dword ptr [RSP + 0x34],0x2
JMP 0x0010ebb4
LAB_0010e8d0:
LEA RAX,[0x133084]
CMP dword ptr [RAX],0x0
JNZ 0x0010e8e9
MOV dword ptr [RSP + 0x34],0x3
JMP 0x0010ebb4
LAB_0010e8e9:
LEA RAX,[0x1330b4]
CMP dword ptr [RAX],0x0
JZ 0x0010e902
MOV dword ptr [RSP + 0x34],0x2
JMP 0x0010ebb4
LAB_0010e902:
CMP dword ptr [0x001330ec],0x0
JZ 0x0010ea4f
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12a20e]
MOV AL,0x0
CALL 0x001289b0
CMP qword ptr [RSP + 0x28],0x0
JZ 0x0010e9aa
MOV RAX,qword ptr [RSP + 0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0010e9aa
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x129942]
CALL 0x001010f0
CMP EAX,0x0
JZ 0x0010e98d
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x129938]
CALL 0x001010f0
CMP EAX,0x0
JZ 0x0010e98d
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12a24c]
MOV AL,0x0
CALL 0x001289b0
MOV dword ptr [RSP + 0x34],0x3
JMP 0x0010ebb4
LAB_0010e98d:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x28]
LEA RSI,[0x12a46f]
MOV AL,0x0
CALL 0x001289b0
LAB_0010e9aa:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x20]
MOVSD XMM1,qword ptr [RSP + 0x18]
LEA RSI,[0x12bc17]
MOV AL,0x2
CALL 0x001289b0
MOVSD XMM0,qword ptr [RSP + 0x10]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x0010e9e1
JP 0x0010e9e1
JMP 0x0010ea32
LAB_0010e9e1:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x10]
LEA RSI,[0x12a42e]
MOV AL,0x1
CALL 0x001289b0
MOVSD XMM0,qword ptr [RSP + 0x8]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x0010ea12
JP 0x0010ea12
JMP 0x0010ea30
LAB_0010ea12:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12a21c]
MOV AL,0x1
CALL 0x001289b0
LAB_0010ea30:
JMP 0x0010ea32
LAB_0010ea32:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x129f54]
MOV AL,0x0
CALL 0x001289b0
JMP 0x0010eb8a
LAB_0010ea4f:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12a20e]
MOV AL,0x0
CALL 0x00101100
CMP qword ptr [RSP + 0x28],0x0
JZ 0x0010eaea
MOV RAX,qword ptr [RSP + 0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0010eaea
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x129942]
CALL 0x001010f0
CMP EAX,0x0
JZ 0x0010eacd
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x129938]
CALL 0x001010f0
CMP EAX,0x0
JZ 0x0010eacd
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12a24c]
MOV AL,0x0
CALL 0x00101100
MOV dword ptr [RSP + 0x34],0x3
JMP 0x0010ebb4
LAB_0010eacd:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x28]
LEA RSI,[0x12a46f]
MOV AL,0x0
CALL 0x00101100
LAB_0010eaea:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x20]
MOVSD XMM1,qword ptr [RSP + 0x18]
LEA RSI,[0x12bc17]
MOV AL,0x2
CALL 0x00101100
MOVSD XMM0,qword ptr [RSP + 0x10]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x0010eb21
JP 0x0010eb21
JMP 0x0010eb72
LAB_0010eb21:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x10]
LEA RSI,[0x12a42e]
MOV AL,0x1
CALL 0x00101100
MOVSD XMM0,qword ptr [RSP + 0x8]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x0010eb52
JP 0x0010eb52
JMP 0x0010eb70
LAB_0010eb52:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12a21c]
MOV AL,0x1
CALL 0x00101100
LAB_0010eb70:
JMP 0x0010eb72
LAB_0010eb72:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x129f54]
MOV AL,0x0
CALL 0x00101100
LAB_0010eb8a:
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x133050]
MOV dword ptr [RAX],0x1c
MOV dword ptr [RSP + 0x34],0x0
LAB_0010ebb4:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
/* LefDefParser::lefwLayerEnclosureWidth(char const*, double, double, double, double) */
int4
LefDefParser::lefwLayerEnclosureWidth
(char *param_1,double param_2,double param_3,double param_4,double param_5)
{
int iVar1;
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if ((lefwState == 6) || (lefwState == 0x1c)) {
if (lefwIsCut == 0) {
local_4 = 3;
}
else if (lefwIsMaxviastack == 0) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," ENCLOSURE ");
if ((param_1 != (char *)0x0) && (*param_1 != '\0')) {
iVar1 = strcmp(param_1,"ABOVE");
if ((iVar1 != 0) && (iVar1 = strcmp(param_1,"BELOW"), iVar1 != 0)) {
fprintf(lefwFile,"ENCLOSURE in Layer(Cut) can only be ABOVE, BELOW.\n");
return 3;
}
fprintf(lefwFile,"%s ",param_1);
}
fprintf(lefwFile,"%.11g %.11g ",param_2);
if ((param_4 != 0.0) || (NAN(param_4))) {
fprintf(lefwFile,"WIDTH %.11g ",param_4);
if ((param_5 != 0.0) || (NAN(param_5))) {
fprintf(lefwFile,"EXCEPTEXTRACUT %.11g ",param_5);
}
}
fprintf(lefwFile,";\n");
}
else {
encPrint(lefwFile," ENCLOSURE ");
if ((param_1 != (char *)0x0) && (*param_1 != '\0')) {
iVar1 = strcmp(param_1,"ABOVE");
if ((iVar1 != 0) && (iVar1 = strcmp(param_1,"BELOW"), iVar1 != 0)) {
encPrint(lefwFile,"ENCLOSURE in Layer(Cut) can only be ABOVE, BELOW.\n");
return 3;
}
encPrint(lefwFile,"%s ",param_1);
}
encPrint(lefwFile,"%.11g %.11g ",param_2);
if ((param_4 != 0.0) || (NAN(param_4))) {
encPrint(lefwFile,"WIDTH %.11g ",param_4);
if ((param_5 != 0.0) || (NAN(param_5))) {
encPrint(lefwFile,"EXCEPTEXTRACUT %.11g ",param_5);
}
}
encPrint(lefwFile,";\n");
}
lefwLines = lefwLines + 1;
lefwState = 0x1c;
local_4 = 0;
}
else {
local_4 = 2;
}
}
else {
local_4 = 2;
}
return local_4;
}
|
|
10,829 |
inline_mysql_file_fclose
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline int
inline_mysql_file_fclose(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_FILE *file, myf flags)
{
int result= 0;
if (likely(file != NULL))
{
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,
PSI_FILE_STREAM_CLOSE);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_fclose(file->m_file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
my_free(file);
return result;
}
}
#endif
result= my_fclose(file->m_file, flags);
my_free(file);
}
return result;
}
|
O0
|
c
|
inline_mysql_file_fclose:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3f9b4
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3f998
leaq 0x1aa7df(%rip), %rax # 0x1ea0d8
movq (%rax), %rax
movq 0x150(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rsi
leaq -0x80(%rbp), %rdi
movl $0x5, %edx
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3f996
leaq 0x1aa797(%rip), %rax # 0x1ea0d8
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x43d60
movl %eax, -0x2c(%rbp)
leaq 0x1aa766(%rip), %rax # 0x1ea0d8
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq *%rax
movq -0x20(%rbp), %rdi
callq 0x30e80
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f9ba
jmp 0x3f998
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x43d60
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x30e80
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
inline_mysql_file_fclose:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], 0
cmp [rbp+var_20], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_3F9B4
mov rax, [rbp+var_20]
cmp qword ptr [rax+8], 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_3F998
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+150h]
mov rcx, [rbp+var_20]
mov rsi, [rcx+8]
lea rdi, [rbp+var_80]
mov edx, 5
call rax
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_3F996
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rax, [rbp+var_20]
mov rdi, [rax]
mov rsi, [rbp+var_28]
call my_fclose
mov [rbp+var_2C], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_2C]
call rax
mov rdi, [rbp+var_20]
call my_free
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
jmp short loc_3F9BA
loc_3F996:
jmp short $+2
loc_3F998:
mov rax, [rbp+var_20]
mov rdi, [rax]
mov rsi, [rbp+var_28]
call my_fclose
mov [rbp+var_2C], eax
mov rdi, [rbp+var_20]
call my_free
loc_3F9B4:
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_3F9BA:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
|
long long inline_mysql_file_fclose(long long a1, unsigned int a2, _QWORD *a3, long long a4)
{
_BYTE v5[72]; // [rsp+0h] [rbp-80h] BYREF
long long v6; // [rsp+48h] [rbp-38h]
unsigned int v7; // [rsp+54h] [rbp-2Ch]
long long v8; // [rsp+58h] [rbp-28h]
_QWORD *v9; // [rsp+60h] [rbp-20h]
unsigned int v10; // [rsp+6Ch] [rbp-14h]
long long v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v7 = 0;
if ( !a3 )
return v7;
if ( !v9[1] || (v6 = (*((long long ( **)(_BYTE *, _QWORD, long long))PSI_server[0] + 42))(v5, v9[1], 5LL)) == 0 )
{
v7 = my_fclose(*v9, v8);
my_free((long long)v9);
return v7;
}
(*((void ( **)(long long, long long, _QWORD))PSI_server[0] + 68))(v6, v11, v10);
v7 = my_fclose(*v9, v8);
(*((void ( **)(long long, _QWORD))PSI_server[0] + 69))(v6, v7);
my_free((long long)v9);
return v7;
}
|
inline_mysql_file_fclose:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],0x0
CMP qword ptr [RBP + -0x20],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0013f9b4
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x8],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0013f998
LEA RAX,[0x2ea0d8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x150]
MOV RCX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RCX + 0x8]
LEA RDI,[RBP + -0x80]
MOV EDX,0x5
CALL RAX
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0013f996
LEA RAX,[0x2ea0d8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00143d60
MOV dword ptr [RBP + -0x2c],EAX
LEA RAX,[0x2ea0d8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x2c]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00130e80
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f9ba
LAB_0013f996:
JMP 0x0013f998
LAB_0013f998:
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00143d60
MOV dword ptr [RBP + -0x2c],EAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00130e80
LAB_0013f9b4:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_0013f9ba:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_fclose
(int8 param_1,int4 param_2,int8 *param_3,int8 param_4)
{
int1 local_88 [72];
long local_40;
int4 local_34;
int8 local_30;
int8 *local_28;
int4 local_1c;
int8 local_18;
local_34 = 0;
if (param_3 != (int8 *)0x0) {
local_30 = param_4;
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
if (param_3[1] != 0) {
local_40 = (**(code **)(PSI_server + 0x150))(local_88,param_3[1],5);
if (local_40 != 0) {
(**(code **)(PSI_server + 0x220))(local_40,local_18,local_1c);
local_34 = my_fclose(*local_28,local_30);
(**(code **)(PSI_server + 0x228))(local_40,local_34);
my_free(local_28);
return local_34;
}
local_40 = 0;
}
local_34 = my_fclose(*local_28,local_30);
my_free(local_28);
}
return local_34;
}
|
|
10,830 |
my_hash_sort_latin1_de
|
eloqsql/strings/ctype-latin1.c
|
void my_hash_sort_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end;
register ulong m1= *nr1, m2= *nr2;
/*
Remove end space. We have to do this to be able to compare
'AE' and 'Ä' as identical
*/
end= skip_trailing_space(key, len);
for (; key < end ; key++)
{
uint X= (uint) combo1map[(uint) *key];
MY_HASH_ADD(m1, m2, X);
if ((X= combo2map[*key]))
{
MY_HASH_ADD(m1, m2, X);
}
}
*nr1= m1;
*nr2= m2;
}
|
O3
|
c
|
my_hash_sort_latin1_de:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
leaq (%rsi,%rdx), %r9
cmpq $0x15, %rdx
jb 0x3c0db
movq %r9, %rdx
andq $-0x4, %rdx
cmpq %rsi, %rdx
jbe 0x3c0db
leaq 0x3(%rsi), %rax
andq $-0x4, %rax
movq %r9, %rdi
movb -0x1(%r9), %r10b
cmpq %rdx, %r9
jbe 0x3c184
leaq -0x1(%rdi), %r9
cmpb $0x20, %r10b
je 0x3c0bf
jmp 0x3c0de
movq %r9, %rdi
movq (%rcx), %r11
movq (%r8), %rax
cmpq %rsi, %rdi
jbe 0x3c171
leaq -0x1(%rdi), %rdx
cmpb $0x20, -0x1(%rdi)
movq %rdx, %rdi
je 0x3c0e4
incq %rdx
leaq 0x16bb0c(%rip), %r9 # 0x1a7c10
leaq 0x16bc05(%rip), %r10 # 0x1a7d10
movq %r11, %rdi
movzbl (%rsi), %r14d
movzbl (%r14,%r9), %ebx
movl %r11d, %r15d
andl $0x3f, %r15d
addq %rax, %r15
imulq %rbx, %r15
shlq $0x8, %rdi
addq %r15, %rdi
xorq %r11, %rdi
leaq 0x3(%rax), %rbx
movzbl (%r14,%r10), %r11d
testq %r11, %r11
je 0x3c161
movl %edi, %r14d
andl $0x3f, %r14d
addq %rbx, %r14
imulq %r11, %r14
movq %rdi, %r11
shlq $0x8, %r11
addq %r14, %r11
xorq %r11, %rdi
addq $0x6, %rax
movq %rax, %rbx
jmp 0x3c164
movq %rbx, %rax
incq %rsi
movq %rdi, %r11
cmpq %rdx, %rsi
jb 0x3c10e
jmp 0x3c177
movq %r11, %rdi
movq %rax, %rbx
movq %rdi, (%rcx)
movq %rbx, (%r8)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x20, %r10b
setne %r9b
cmpq %rdx, %rax
setae %dl
orb %r9b, %dl
jne 0x3c0de
movq %rdi, %rdx
movq %rdx, %rdi
cmpq %rax, %rdx
jbe 0x3c0de
leaq -0x4(%rdi), %rdx
cmpl $0x20202020, -0x4(%rdi) # imm = 0x20202020
je 0x3c19e
jmp 0x3c0de
|
my_hash_sort_latin1_de:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
lea r9, [rsi+rdx]
cmp rdx, 15h
jb short loc_3C0DB
mov rdx, r9
and rdx, 0FFFFFFFFFFFFFFFCh
cmp rdx, rsi
jbe short loc_3C0DB
lea rax, [rsi+3]
and rax, 0FFFFFFFFFFFFFFFCh
loc_3C0BF:
mov rdi, r9
mov r10b, [r9-1]
cmp r9, rdx
jbe loc_3C184
lea r9, [rdi-1]
cmp r10b, 20h ; ' '
jz short loc_3C0BF
jmp short loc_3C0DE
loc_3C0DB:
mov rdi, r9
loc_3C0DE:
mov r11, [rcx]
mov rax, [r8]
loc_3C0E4:
cmp rdi, rsi
jbe loc_3C171
lea rdx, [rdi-1]
cmp byte ptr [rdi-1], 20h ; ' '
mov rdi, rdx
jz short loc_3C0E4
inc rdx
lea r9, combo1map
lea r10, combo2map
mov rdi, r11
loc_3C10E:
movzx r14d, byte ptr [rsi]
movzx ebx, byte ptr [r14+r9]
mov r15d, r11d
and r15d, 3Fh
add r15, rax
imul r15, rbx
shl rdi, 8
add rdi, r15
xor rdi, r11
lea rbx, [rax+3]
movzx r11d, byte ptr [r14+r10]
test r11, r11
jz short loc_3C161
mov r14d, edi
and r14d, 3Fh
add r14, rbx
imul r14, r11
mov r11, rdi
shl r11, 8
add r11, r14
xor rdi, r11
add rax, 6
mov rbx, rax
jmp short loc_3C164
loc_3C161:
mov rax, rbx
loc_3C164:
inc rsi
mov r11, rdi
cmp rsi, rdx
jb short loc_3C10E
jmp short loc_3C177
loc_3C171:
mov rdi, r11
mov rbx, rax
loc_3C177:
mov [rcx], rdi
mov [r8], rbx
pop rbx
pop r14
pop r15
pop rbp
retn
loc_3C184:
cmp r10b, 20h ; ' '
setnz r9b
cmp rax, rdx
setnb dl
or dl, r9b
jnz loc_3C0DE
mov rdx, rdi
loc_3C19E:
mov rdi, rdx
cmp rdx, rax
jbe loc_3C0DE
lea rdx, [rdi-4]
cmp dword ptr [rdi-4], 20202020h
jz short loc_3C19E
jmp loc_3C0DE
|
long long my_hash_sort_latin1_de(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
long long *a4,
long long *a5)
{
unsigned long long v5; // r9
unsigned long long v6; // rdx
unsigned long long v7; // rax
unsigned long long v8; // rdi
char v9; // r10
long long v10; // r11
long long result; // rax
unsigned long long v12; // rdx
unsigned long long v14; // rdx
long long v15; // rdi
long long v16; // r14
long long v17; // rbx
unsigned long long v18; // rdx
v5 = (unsigned long long)&a2[a3];
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v8 = v5;
}
else
{
v7 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v18 = v5;
do
{
v8 = v18;
if ( v18 <= v7 )
break;
v18 -= 4LL;
}
while ( *(_DWORD *)(v8 - 4) == 538976288 );
}
}
LABEL_8:
v10 = *a4;
result = *a5;
do
{
if ( v8 <= (unsigned long long)a2 )
{
v15 = *a4;
v17 = *a5;
goto LABEL_18;
}
v12 = v8 - 1;
}
while ( *(_BYTE *)--v8 == 32 );
v14 = v12 + 1;
v15 = *a4;
do
{
v16 = *a2;
v15 = v10 ^ (combo1map[v16] * (result + (v10 & 0x3F)) + (v15 << 8));
v17 = result + 3;
if ( combo2map[v16] )
{
v15 ^= combo2map[v16] * (v17 + (v15 & 0x3F)) + (v15 << 8);
result += 6LL;
v17 = result;
}
else
{
result += 3LL;
}
++a2;
v10 = v15;
}
while ( (unsigned long long)a2 < v14 );
LABEL_18:
*a4 = v15;
*a5 = v17;
return result;
}
|
my_hash_sort_latin1_de:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
LEA R9,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x0013c0db
MOV RDX,R9
AND RDX,-0x4
CMP RDX,RSI
JBE 0x0013c0db
LEA RAX,[RSI + 0x3]
AND RAX,-0x4
LAB_0013c0bf:
MOV RDI,R9
MOV R10B,byte ptr [R9 + -0x1]
CMP R9,RDX
JBE 0x0013c184
LEA R9,[RDI + -0x1]
CMP R10B,0x20
JZ 0x0013c0bf
JMP 0x0013c0de
LAB_0013c0db:
MOV RDI,R9
LAB_0013c0de:
MOV R11,qword ptr [RCX]
MOV RAX,qword ptr [R8]
LAB_0013c0e4:
CMP RDI,RSI
JBE 0x0013c171
LEA RDX,[RDI + -0x1]
CMP byte ptr [RDI + -0x1],0x20
MOV RDI,RDX
JZ 0x0013c0e4
INC RDX
LEA R9,[0x2a7c10]
LEA R10,[0x2a7d10]
MOV RDI,R11
LAB_0013c10e:
MOVZX R14D,byte ptr [RSI]
MOVZX EBX,byte ptr [R14 + R9*0x1]
MOV R15D,R11D
AND R15D,0x3f
ADD R15,RAX
IMUL R15,RBX
SHL RDI,0x8
ADD RDI,R15
XOR RDI,R11
LEA RBX,[RAX + 0x3]
MOVZX R11D,byte ptr [R14 + R10*0x1]
TEST R11,R11
JZ 0x0013c161
MOV R14D,EDI
AND R14D,0x3f
ADD R14,RBX
IMUL R14,R11
MOV R11,RDI
SHL R11,0x8
ADD R11,R14
XOR RDI,R11
ADD RAX,0x6
MOV RBX,RAX
JMP 0x0013c164
LAB_0013c161:
MOV RAX,RBX
LAB_0013c164:
INC RSI
MOV R11,RDI
CMP RSI,RDX
JC 0x0013c10e
JMP 0x0013c177
LAB_0013c171:
MOV RDI,R11
MOV RBX,RAX
LAB_0013c177:
MOV qword ptr [RCX],RDI
MOV qword ptr [R8],RBX
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0013c184:
CMP R10B,0x20
SETNZ R9B
CMP RAX,RDX
SETNC DL
OR DL,R9B
JNZ 0x0013c0de
MOV RDX,RDI
LAB_0013c19e:
MOV RDI,RDX
CMP RDX,RAX
JBE 0x0013c0de
LEA RDX,[RDI + -0x4]
CMP dword ptr [RDI + -0x4],0x20202020
JZ 0x0013c19e
JMP 0x0013c0de
|
void my_hash_sort_latin1_de
(int8 param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
long lVar3;
byte *pbVar4;
byte *pbVar5;
ulong uVar6;
pbVar5 = param_2 + param_3;
if ((0x14 < param_3) && (pbVar4 = (byte *)((ulong)pbVar5 & 0xfffffffffffffffc), param_2 < pbVar4))
{
pbVar1 = pbVar5;
do {
pbVar5 = pbVar1;
if (pbVar5 <= pbVar4) {
pbVar1 = pbVar5;
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar4 && pbVar5[-1] == 0x20)
goto LAB_0013c19e;
break;
}
pbVar1 = pbVar5 + -1;
} while (pbVar5[-1] == 0x20);
}
goto LAB_0013c0de;
while (pbVar1 = pbVar5 + -4, *(int *)(pbVar5 + -4) == 0x20202020) {
LAB_0013c19e:
pbVar5 = pbVar1;
if (pbVar5 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_0013c0de:
uVar6 = *param_4;
lVar2 = *param_5;
do {
pbVar4 = pbVar5;
lVar3 = lVar2;
if (pbVar4 <= param_2) goto LAB_0013c177;
pbVar5 = pbVar4 + -1;
} while (pbVar4[-1] == 0x20);
do {
uVar6 = uVar6 * 0x100 + ((ulong)((uint)uVar6 & 0x3f) + lVar2) * (ulong)(byte)combo1map[*param_2]
^ uVar6;
lVar3 = lVar2 + 3;
if ((ulong)(byte)combo2map[*param_2] != 0) {
uVar6 = uVar6 ^ uVar6 * 0x100 +
((ulong)((uint)uVar6 & 0x3f) + lVar3) * (ulong)(byte)combo2map[*param_2];
lVar3 = lVar2 + 6;
}
param_2 = param_2 + 1;
lVar2 = lVar3;
} while (param_2 < pbVar4);
LAB_0013c177:
*param_4 = uVar6;
*param_5 = lVar3;
return;
}
|
|
10,831 |
psi_rwlock_wrlock
|
eloqsql/mysys/my_thr_init.c
|
ATTRIBUTE_COLD
int psi_rwlock_wrlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_WRITELOCK, file, line);
int result= rw_wrlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
}
|
O3
|
c
|
psi_rwlock_wrlock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x2cad17(%rip), %r15 # 0x2ef500
movq (%r15), %rax
movq 0x90(%rdi), %rsi
leaq -0x48(%rbp), %rdi
pushq $0x1
popq %rdx
callq *0x1b0(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0x26f31
movl %eax, %r14d
testq %rbx, %rbx
je 0x24822
movq (%r15), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x1b8(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
psi_rwlock_wrlock:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r8d, edx
mov rcx, rsi
mov r14, rdi
lea r15, PSI_server
mov rax, [r15]
mov rsi, [rdi+90h]
lea rdi, [rbp+var_48]
push 1
pop rdx
call qword ptr [rax+1B0h]
mov rbx, rax
mov rdi, r14
call my_rw_wrlock
mov r14d, eax
test rbx, rbx
jz short loc_24822
mov rax, [r15]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+1B8h]
loc_24822:
mov eax, r14d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long psi_rwlock_wrlock(long long a1, long long a2, unsigned int a3)
{
long long v3; // rbx
unsigned int v4; // r14d
_BYTE v6[72]; // [rsp+8h] [rbp-48h] BYREF
v3 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[54])(
v6,
*(_QWORD *)(a1 + 144),
1LL,
a2,
a3);
v4 = my_rw_wrlock(a1);
if ( v3 )
((void ( *)(long long, _QWORD))PSI_server[55])(v3, v4);
return v4;
}
|
psi_rwlock_wrlock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R8D,EDX
MOV RCX,RSI
MOV R14,RDI
LEA R15,[0x3ef500]
MOV RAX,qword ptr [R15]
MOV RSI,qword ptr [RDI + 0x90]
LEA RDI,[RBP + -0x48]
PUSH 0x1
POP RDX
CALL qword ptr [RAX + 0x1b0]
MOV RBX,RAX
MOV RDI,R14
CALL 0x00126f31
MOV R14D,EAX
TEST RBX,RBX
JZ 0x00124822
MOV RAX,qword ptr [R15]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x1b8]
LAB_00124822:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 psi_rwlock_wrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [48];
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x90),1,param_2,param_3);
uVar1 = my_rw_wrlock(param_1);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
|
|
10,832 |
remainingElementsCount_add
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int remainingElementsCount_add(JSContext *ctx,
JSValue resolve_element_env,
int addend)
{
JSValue val;
int remainingElementsCount;
val = JS_GetPropertyUint32(ctx, resolve_element_env, 0);
if (JS_IsException(val))
return -1;
if (JS_ToInt32Free(ctx, &remainingElementsCount, val))
return -1;
remainingElementsCount += addend;
if (JS_SetPropertyUint32(ctx, resolve_element_env, 0,
js_int32(remainingElementsCount)) < 0)
return -1;
return (remainingElementsCount == 0);
}
|
O0
|
c
|
remainingElementsCount_add:
subq $0x68, %rsp
movq %rsi, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq %rdi, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
xorl %ecx, %ecx
callq 0x31460
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x959fc
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x95a8b
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq 0x2c(%rsp), %rsi
callq 0x38f90
cmpl $0x0, %eax
je 0x95a24
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x95a8b
movl 0x44(%rsp), %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movl 0x2c(%rsp), %edi
callq 0x33cc0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
xorl %ecx, %ecx
callq 0x33350
cmpl $0x0, %eax
jge 0x95a7a
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x95a8b
cmpl $0x0, 0x2c(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
|
remainingElementsCount_add:
sub rsp, 68h
mov [rsp+68h+var_18], rsi
mov [rsp+68h+var_10], rdx
mov [rsp+68h+var_20], rdi
mov [rsp+68h+var_24], ecx
mov rdi, [rsp+68h+var_20]
mov rsi, [rsp+68h+var_18]
mov rdx, [rsp+68h+var_10]
xor ecx, ecx
call JS_GetPropertyUint32
mov [rsp+68h+var_50], rax
mov [rsp+68h+var_48], rdx
mov rax, [rsp+68h+var_50]
mov [rsp+68h+var_38], rax
mov rax, [rsp+68h+var_48]
mov [rsp+68h+var_30], rax
mov rdi, [rsp+68h+var_38]
mov rsi, [rsp+68h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_959FC
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp loc_95A8B
loc_959FC:
mov rdi, [rsp+68h+var_20]
mov rdx, [rsp+68h+var_38]
mov rcx, [rsp+68h+var_30]
lea rsi, [rsp+68h+var_3C]
call JS_ToInt32Free
cmp eax, 0
jz short loc_95A24
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp short loc_95A8B
loc_95A24:
mov eax, [rsp+68h+var_24]
add eax, [rsp+68h+var_3C]
mov [rsp+68h+var_3C], eax
mov rax, [rsp+68h+var_20]
mov [rsp+68h+var_68], rax
mov edi, [rsp+68h+var_3C]
call js_int32
mov rdi, [rsp+68h+var_68]
mov [rsp+68h+var_60], rax
mov [rsp+68h+var_58], rdx
mov rsi, [rsp+68h+var_18]
mov rdx, [rsp+68h+var_10]
mov r8, [rsp+68h+var_60]
mov r9, [rsp+68h+var_58]
xor ecx, ecx
call JS_SetPropertyUint32
cmp eax, 0
jge short loc_95A7A
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp short loc_95A8B
loc_95A7A:
cmp [rsp+68h+var_3C], 0
setz al
and al, 1
movzx eax, al
mov [rsp+68h+var_4], eax
loc_95A8B:
mov eax, [rsp+68h+var_4]
add rsp, 68h
retn
|
long long remainingElementsCount_add(long long a1, long long a2, long long a3, int a4)
{
long long v4; // rdx
long long v5; // rdx
int v7; // [rsp+0h] [rbp-68h]
long long v8; // [rsp+8h] [rbp-60h]
int v9; // [rsp+2Ch] [rbp-3Ch] BYREF
long long PropertyUint32; // [rsp+30h] [rbp-38h]
long long v11; // [rsp+38h] [rbp-30h]
int v12; // [rsp+44h] [rbp-24h]
long long v13; // [rsp+48h] [rbp-20h]
long long v14; // [rsp+50h] [rbp-18h]
long long v15; // [rsp+58h] [rbp-10h]
v14 = a2;
v15 = a3;
v13 = a1;
v12 = a4;
PropertyUint32 = JS_GetPropertyUint32(a1, a2, a3, 0);
v11 = v4;
if ( JS_IsException_1(PropertyUint32, v4) )
{
return (unsigned int)-1;
}
else if ( (unsigned int)JS_ToInt32Free(v13, &v9, PropertyUint32, v11) )
{
return (unsigned int)-1;
}
else
{
v9 += v12;
v7 = v13;
v8 = js_int32(v9);
if ( (int)JS_SetPropertyUint32(v7, v14, v15, 0, v8, v5) >= 0 )
return v9 == 0;
else
return (unsigned int)-1;
}
}
|
remainingElementsCount_add:
SUB RSP,0x68
MOV qword ptr [RSP + 0x50],RSI
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x48],RDI
MOV dword ptr [RSP + 0x44],ECX
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
XOR ECX,ECX
CALL 0x00131460
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001959fc
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x00195a8b
LAB_001959fc:
MOV RDI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
LEA RSI,[RSP + 0x2c]
CALL 0x00138f90
CMP EAX,0x0
JZ 0x00195a24
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x00195a8b
LAB_00195a24:
MOV EAX,dword ptr [RSP + 0x44]
ADD EAX,dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0x2c],EAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP],RAX
MOV EDI,dword ptr [RSP + 0x2c]
CALL 0x00133cc0
MOV RDI,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV R8,qword ptr [RSP + 0x8]
MOV R9,qword ptr [RSP + 0x10]
XOR ECX,ECX
CALL 0x00133350
CMP EAX,0x0
JGE 0x00195a7a
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x00195a8b
LAB_00195a7a:
CMP dword ptr [RSP + 0x2c],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x64],EAX
LAB_00195a8b:
MOV EAX,dword ptr [RSP + 0x64]
ADD RSP,0x68
RET
|
uint remainingElementsCount_add
(int8 param_1,int8 param_2,int8 param_3,int param_4)
{
int8 uVar1;
int iVar2;
int1 auVar3 [16];
int local_3c;
int1 local_38 [16];
int local_24;
int8 local_20;
int8 local_18;
int8 local_10;
uint local_4;
local_24 = param_4;
local_20 = param_1;
local_18 = param_2;
local_10 = param_3;
local_38 = JS_GetPropertyUint32(param_1,param_2,param_3,0);
iVar2 = JS_IsException(local_38._0_8_,local_38._8_8_);
if (iVar2 == 0) {
iVar2 = JS_ToInt32Free(local_20,&local_3c,local_38._0_8_,local_38._8_8_);
uVar1 = local_20;
if (iVar2 == 0) {
local_3c = local_24 + local_3c;
auVar3 = js_int32(local_3c);
iVar2 = JS_SetPropertyUint32(uVar1,local_18,local_10,0,auVar3._0_8_,auVar3._8_8_);
if (iVar2 < 0) {
local_4 = 0xffffffff;
}
else {
local_4 = (uint)(local_3c == 0);
}
}
else {
local_4 = 0xffffffff;
}
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
|
|
10,833 |
remainingElementsCount_add
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int remainingElementsCount_add(JSContext *ctx,
JSValue resolve_element_env,
int addend)
{
JSValue val;
int remainingElementsCount;
val = JS_GetPropertyUint32(ctx, resolve_element_env, 0);
if (JS_IsException(val))
return -1;
if (JS_ToInt32Free(ctx, &remainingElementsCount, val))
return -1;
remainingElementsCount += addend;
if (JS_SetPropertyUint32(ctx, resolve_element_env, 0,
js_int32(remainingElementsCount)) < 0)
return -1;
return (remainingElementsCount == 0);
}
|
O1
|
c
|
remainingElementsCount_add:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ecx, %ecx
callq 0x241b4
movq %rdx, %rcx
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x6, %ecx
je 0x54df3
leaq 0x1c(%rsp), %rsi
movq %r12, %rdi
movq %rax, %rdx
callq 0x279c3
testl %eax, %eax
jne 0x54df3
addl 0x1c(%rsp), %ebx
movl %ebx, 0x1c(%rsp)
movq %rbx, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x4000, %r9d # imm = 0x4000
callq 0x24d59
testl %eax, %eax
js 0x54df3
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
remainingElementsCount_add:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 30h
mov ebx, ecx
mov r14, rdx
mov r15, rsi
mov r12, rdi
xor ecx, ecx
call JS_GetPropertyInt64
mov rcx, rdx
mov ebp, 0FFFFFFFFh
cmp ecx, 6
jz short loc_54DF3
lea rsi, [rsp+58h+var_3C]
mov rdi, r12
mov rdx, rax
call JS_ToInt32Free
test eax, eax
jnz short loc_54DF3
add ebx, [rsp+58h+var_3C]
mov [rsp+58h+var_3C], ebx
mov qword ptr [rsp+58h+var_38], rbx
mov qword ptr [rsp+58h+var_38+8], 0
movups xmm0, [rsp+58h+var_38]
movups [rsp+58h+var_58], xmm0
mov rdi, r12
mov rsi, r15
mov rdx, r14
xor ecx, ecx
xor r8d, r8d
mov r9d, 4000h
call JS_SetPropertyValue
test eax, eax
js short loc_54DF3
xor ebp, ebp
test ebx, ebx
setz bpl
loc_54DF3:
mov eax, ebp
add rsp, 30h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long remainingElementsCount_add(
long long a1,
unsigned long long a2,
unsigned long long a3,
int a4,
double a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
unsigned long long PropertyInt64; // rax
long long v15; // rdx
unsigned int v16; // ebp
double v17; // xmm4_8
double v18; // xmm5_8
double v19; // rbx
int v21; // [rsp+1Ch] [rbp-3Ch] BYREF
__int128 v22; // [rsp+20h] [rbp-38h]
PropertyInt64 = JS_GetPropertyInt64(a1, a2, a3, 0LL);
v16 = -1;
if ( (_DWORD)v15 != 6 && !(unsigned int)JS_ToInt32Free(a1, &v21, PropertyInt64, v15) )
{
*(_QWORD *)&v19 = (unsigned int)(v21 + a4);
v21 = LODWORD(v19);
v22 = *(unsigned long long *)&v19;
if ( (int)JS_SetPropertyValue(
a1,
a2,
a3,
0LL,
0LL,
0x4000u,
v19,
a6,
a7,
a8,
v17,
v18,
a11,
a12,
*(unsigned long long *)&v19) >= 0 )
return LODWORD(v19) == 0;
}
return v16;
}
| |||
10,834 |
remainingElementsCount_add
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int remainingElementsCount_add(JSContext *ctx,
JSValue resolve_element_env,
int addend)
{
JSValue val;
int remainingElementsCount;
val = JS_GetPropertyUint32(ctx, resolve_element_env, 0);
if (JS_IsException(val))
return -1;
if (JS_ToInt32Free(ctx, &remainingElementsCount, val))
return -1;
remainingElementsCount += addend;
if (JS_SetPropertyUint32(ctx, resolve_element_env, 0,
js_int32(remainingElementsCount)) < 0)
return -1;
return (remainingElementsCount == 0);
}
|
O2
|
c
|
remainingElementsCount_add:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ecx, %ecx
callq 0x1e178
movq %rdx, %rcx
pushq $-0x1
popq %rbp
cmpl $0x6, %ecx
je 0x48c52
leaq 0xc(%rsp), %rsi
movq %r12, %rdi
movq %rax, %rdx
callq 0x215e0
testl %eax, %eax
jne 0x48c52
addl 0xc(%rsp), %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x1ece3
testl %eax, %eax
js 0x48c52
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
remainingElementsCount_add:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebx, ecx
mov r14, rdx
mov r15, rsi
mov r12, rdi
xor ecx, ecx
call JS_GetPropertyInt64
mov rcx, rdx
push 0FFFFFFFFFFFFFFFFh
pop rbp
cmp ecx, 6
jz short loc_48C52
lea rsi, [rsp+38h+var_2C]
mov rdi, r12
mov rdx, rax
call JS_ToInt32Free
test eax, eax
jnz short loc_48C52
add ebx, [rsp+38h+var_2C]
mov rdi, r12
mov rsi, r15
mov rdx, r14
xor ecx, ecx
mov r8, rbx
xor r9d, r9d
call JS_SetPropertyUint32
test eax, eax
js short loc_48C52
xor ebp, ebp
test ebx, ebx
setz bpl
loc_48C52:
mov eax, ebp
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long remainingElementsCount_add(long long a1, long long a2, int a3, int a4)
{
unsigned long long PropertyInt64; // rax
long long v7; // rdx
unsigned int v8; // ebp
long long v9; // rbx
_DWORD v11[11]; // [rsp+Ch] [rbp-2Ch] BYREF
PropertyInt64 = JS_GetPropertyInt64(a1, a2, a3, 0LL);
v8 = -1;
if ( (_DWORD)v7 != 6 && !(unsigned int)JS_ToInt32Free(a1, v11, PropertyInt64, v7) )
{
v9 = (unsigned int)(v11[0] + a4);
if ( (int)JS_SetPropertyUint32(a1, a2, a3, 0, v9, 0LL) >= 0 )
return (_DWORD)v9 == 0;
}
return v8;
}
|
remainingElementsCount_add:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBX,ECX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
XOR ECX,ECX
CALL 0x0011e178
MOV RCX,RDX
PUSH -0x1
POP RBP
CMP ECX,0x6
JZ 0x00148c52
LEA RSI,[RSP + 0xc]
MOV RDI,R12
MOV RDX,RAX
CALL 0x001215e0
TEST EAX,EAX
JNZ 0x00148c52
ADD EBX,dword ptr [RSP + 0xc]
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
XOR ECX,ECX
MOV R8,RBX
XOR R9D,R9D
CALL 0x0011ece3
TEST EAX,EAX
JS 0x00148c52
XOR EBP,EBP
TEST EBX,EBX
SETZ BPL
LAB_00148c52:
MOV EAX,EBP
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
uint remainingElementsCount_add
(int8 param_1,int8 param_2,int8 param_3,int param_4)
{
int iVar1;
uint uVar2;
int1 auVar3 [12];
int local_2c;
auVar3 = JS_GetPropertyInt64();
uVar2 = 0xffffffff;
if (auVar3._8_4_ != 6) {
iVar1 = JS_ToInt32Free(param_1,&local_2c,auVar3._0_8_);
if (iVar1 == 0) {
iVar1 = JS_SetPropertyUint32(param_1,param_2,param_3,0,param_4 + local_2c,0);
if (-1 < iVar1) {
uVar2 = (uint)(param_4 + local_2c == 0);
}
}
}
return uVar2;
}
|
|
10,835 |
remainingElementsCount_add
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int remainingElementsCount_add(JSContext *ctx,
JSValue resolve_element_env,
int addend)
{
JSValue val;
int remainingElementsCount;
val = JS_GetPropertyUint32(ctx, resolve_element_env, 0);
if (JS_IsException(val))
return -1;
if (JS_ToInt32Free(ctx, &remainingElementsCount, val))
return -1;
remainingElementsCount += addend;
if (JS_SetPropertyUint32(ctx, resolve_element_env, 0,
js_int32(remainingElementsCount)) < 0)
return -1;
return (remainingElementsCount == 0);
}
|
O3
|
c
|
remainingElementsCount_add:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ecx, %ecx
callq 0x24808
movq %rdx, %rcx
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x6, %ecx
je 0x57d34
leaq 0xc(%rsp), %rsi
movq %r12, %rdi
movq %rax, %rdx
callq 0x28044
testl %eax, %eax
jne 0x57d34
addl 0xc(%rsp), %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
pushq $0x4000 # imm = 0x4000
pushq $0x0
callq 0x253af
addq $0x10, %rsp
testl %eax, %eax
js 0x57d34
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
remainingElementsCount_add:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebx, ecx
mov r14, rdx
mov r15, rsi
mov r12, rdi
xor ecx, ecx
call JS_GetPropertyInt64
mov rcx, rdx
mov ebp, 0FFFFFFFFh
cmp ecx, 6
jz short loc_57D34
lea rsi, [rsp+38h+var_2C]
mov rdi, r12
mov rdx, rax
call JS_ToInt32Free
test eax, eax
jnz short loc_57D34
add ebx, [rsp+38h+var_2C]
mov rdi, r12
mov rsi, r15
mov rdx, r14
xor ecx, ecx
xor r8d, r8d
mov r9, rbx
push 4000h
push 0
call JS_SetPropertyValue
add rsp, 10h
test eax, eax
js short loc_57D34
xor ebp, ebp
test ebx, ebx
setz bpl
loc_57D34:
mov eax, ebp
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long remainingElementsCount_add(
long long a1,
long long a2,
unsigned long long a3,
int a4,
double a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
unsigned long long PropertyInt64; // rax
long long v15; // rdx
unsigned int v16; // ebp
double v17; // xmm4_8
double v18; // xmm5_8
int *v19; // rbx
int v21[11]; // [rsp+Ch] [rbp-2Ch] BYREF
PropertyInt64 = JS_GetPropertyInt64(a1, a2, a3, 0LL);
v16 = -1;
if ( (_DWORD)v15 != 6 && !(unsigned int)JS_ToInt32Free(a1, v21, PropertyInt64, v15) )
{
v19 = (int *)(unsigned int)(v21[0] + a4);
if ( (int)JS_SetPropertyValue(a1, a2, a3, 0LL, 0LL, v19, a5, a6, a7, a8, v17, v18, a11, a12, 0LL, 0x4000u) >= 0 )
return (_DWORD)v19 == 0;
}
return v16;
}
|
remainingElementsCount_add:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBX,ECX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
XOR ECX,ECX
CALL 0x00124808
MOV RCX,RDX
MOV EBP,0xffffffff
CMP ECX,0x6
JZ 0x00157d34
LEA RSI,[RSP + 0xc]
MOV RDI,R12
MOV RDX,RAX
CALL 0x00128044
TEST EAX,EAX
JNZ 0x00157d34
ADD EBX,dword ptr [RSP + 0xc]
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
XOR ECX,ECX
XOR R8D,R8D
MOV R9,RBX
PUSH 0x4000
PUSH 0x0
CALL 0x001253af
ADD RSP,0x10
TEST EAX,EAX
JS 0x00157d34
XOR EBP,EBP
TEST EBX,EBX
SETZ BPL
LAB_00157d34:
MOV EAX,EBP
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
ulong remainingElementsCount_add
(int8 param_1,int8 param_2,int8 param_3,int param_4)
{
int iVar1;
ulong uVar2;
int1 auVar3 [12];
int local_2c;
auVar3 = JS_GetPropertyInt64();
uVar2 = 0xffffffff;
if (auVar3._8_4_ != 6) {
iVar1 = JS_ToInt32Free(param_1,&local_2c,auVar3._0_8_);
if (iVar1 == 0) {
iVar1 = JS_SetPropertyValue(param_1,param_2,param_3,0,0,param_4 + local_2c,0,0x4000);
if (-1 < iVar1) {
uVar2 = (ulong)(param_4 + local_2c == 0);
}
}
}
return uVar2;
}
|
|
10,836 |
func_uni_gb2312_onechar
|
eloqsql/strings/ctype-gb2312.c
|
static int func_uni_gb2312_onechar(int code){
if ((code>=0x00A4)&&(code<=0x01DC))
return(tab_uni_gb23120[code-0x00A4]);
if ((code>=0x02C7)&&(code<=0x0451))
return(tab_uni_gb23121[code-0x02C7]);
if ((code>=0x2015)&&(code<=0x2312))
return(tab_uni_gb23122[code-0x2015]);
if ((code>=0x2460)&&(code<=0x2642))
return(tab_uni_gb23123[code-0x2460]);
if ((code>=0x3000)&&(code<=0x3129))
return(tab_uni_gb23124[code-0x3000]);
if ((code>=0x3220)&&(code<=0x3229))
return(tab_uni_gb23125[code-0x3220]);
if ((code>=0x4E00)&&(code<=0x9B54))
return(tab_uni_gb23126[code-0x4E00]);
if ((code>=0x9C7C)&&(code<=0x9CE2))
return(tab_uni_gb23127[code-0x9C7C]);
if ((code>=0x9E1F)&&(code<=0x9FA0))
return(tab_uni_gb23128[code-0x9E1F]);
if ((code>=0xFF01)&&(code<=0xFFE5))
return(tab_uni_gb23129[code-0xFF01]);
return(0);
}
|
O0
|
c
|
func_uni_gb2312_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa4, -0x8(%rbp)
jl 0x3ea77
cmpl $0x1dc, -0x8(%rbp) # imm = 0x1DC
jg 0x3ea77
movl -0x8(%rbp), %eax
subl $0xa4, %eax
movslq %eax, %rcx
leaq 0xcf0b5(%rip), %rax # 0x10db20
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ec25
cmpl $0x2c7, -0x8(%rbp) # imm = 0x2C7
jl 0x3eaa7
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x3eaa7
movl -0x8(%rbp), %eax
subl $0x2c7, %eax # imm = 0x2C7
movslq %eax, %rcx
leaq 0xcf305(%rip), %rax # 0x10dda0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ec25
cmpl $0x2015, -0x8(%rbp) # imm = 0x2015
jl 0x3ead7
cmpl $0x2312, -0x8(%rbp) # imm = 0x2312
jg 0x3ead7
movl -0x8(%rbp), %eax
subl $0x2015, %eax # imm = 0x2015
movslq %eax, %rcx
leaq 0xcf5f5(%rip), %rax # 0x10e0c0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ec25
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x3eb07
cmpl $0x2642, -0x8(%rbp) # imm = 0x2642
jg 0x3eb07
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0xcfbc5(%rip), %rax # 0x10e6c0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ec25
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x3eb37
cmpl $0x3129, -0x8(%rbp) # imm = 0x3129
jg 0x3eb37
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0xcff65(%rip), %rax # 0x10ea90
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ec25
cmpl $0x3220, -0x8(%rbp) # imm = 0x3220
jl 0x3eb67
cmpl $0x3229, -0x8(%rbp) # imm = 0x3229
jg 0x3eb67
movl -0x8(%rbp), %eax
subl $0x3220, %eax # imm = 0x3220
movslq %eax, %rcx
leaq 0xd0195(%rip), %rax # 0x10ecf0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ec25
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x3eb97
cmpl $0x9b54, -0x8(%rbp) # imm = 0x9B54
jg 0x3eb97
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0xd0185(%rip), %rax # 0x10ed10
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ec25
cmpl $0x9c7c, -0x8(%rbp) # imm = 0x9C7C
jl 0x3ebc4
cmpl $0x9ce2, -0x8(%rbp) # imm = 0x9CE2
jg 0x3ebc4
movl -0x8(%rbp), %eax
subl $0x9c7c, %eax # imm = 0x9C7C
movslq %eax, %rcx
leaq 0xd9c05(%rip), %rax # 0x1187c0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ec25
cmpl $0x9e1f, -0x8(%rbp) # imm = 0x9E1F
jl 0x3ebf1
cmpl $0x9fa0, -0x8(%rbp) # imm = 0x9FA0
jg 0x3ebf1
movl -0x8(%rbp), %eax
subl $0x9e1f, %eax # imm = 0x9E1F
movslq %eax, %rcx
leaq 0xd9ca8(%rip), %rax # 0x118890
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ec25
cmpl $0xff01, -0x8(%rbp) # imm = 0xFF01
jl 0x3ec1e
cmpl $0xffe5, -0x8(%rbp) # imm = 0xFFE5
jg 0x3ec1e
movl -0x8(%rbp), %eax
subl $0xff01, %eax # imm = 0xFF01
movslq %eax, %rcx
leaq 0xd9f8b(%rip), %rax # 0x118ba0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ec25
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
func_uni_gb2312_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A4h
jl short loc_3EA77
cmp [rbp+var_8], 1DCh
jg short loc_3EA77
mov eax, [rbp+var_8]
sub eax, 0A4h
movsxd rcx, eax
lea rax, tab_uni_gb23120
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3EC25
loc_3EA77:
cmp [rbp+var_8], 2C7h
jl short loc_3EAA7
cmp [rbp+var_8], 451h
jg short loc_3EAA7
mov eax, [rbp+var_8]
sub eax, 2C7h
movsxd rcx, eax
lea rax, tab_uni_gb23121
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3EC25
loc_3EAA7:
cmp [rbp+var_8], 2015h
jl short loc_3EAD7
cmp [rbp+var_8], 2312h
jg short loc_3EAD7
mov eax, [rbp+var_8]
sub eax, 2015h
movsxd rcx, eax
lea rax, tab_uni_gb23122; "*!,!"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3EC25
loc_3EAD7:
cmp [rbp+var_8], 2460h
jl short loc_3EB07
cmp [rbp+var_8], 2642h
jg short loc_3EB07
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_gb23123; "Y\"Z\"[\"\\\"]\"^\"_\"`\"a\"b\""
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3EC25
loc_3EB07:
cmp [rbp+var_8], 3000h
jl short loc_3EB37
cmp [rbp+var_8], 3129h
jg short loc_3EB37
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_gb23124; "!!\"!#!(!"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3EC25
loc_3EB37:
cmp [rbp+var_8], 3220h
jl short loc_3EB67
cmp [rbp+var_8], 3229h
jg short loc_3EB67
mov eax, [rbp+var_8]
sub eax, 3220h
movsxd rcx, eax
lea rax, tab_uni_gb23125; "e\"f\"g\"h\"i\"j\"k\"l\"m\"n\""
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3EC25
loc_3EB67:
cmp [rbp+var_8], 4E00h
jl short loc_3EB97
cmp [rbp+var_8], 9B54h
jg short loc_3EB97
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_gb23126; ";R!6"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3EC25
loc_3EB97:
cmp [rbp+var_8], 9C7Ch
jl short loc_3EBC4
cmp [rbp+var_8], 9CE2h
jg short loc_3EBC4
mov eax, [rbp+var_8]
sub eax, 9C7Ch
movsxd rcx, eax
lea rax, tab_uni_gb23127
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_3EC25
loc_3EBC4:
cmp [rbp+var_8], 9E1Fh
jl short loc_3EBF1
cmp [rbp+var_8], 9FA0h
jg short loc_3EBF1
mov eax, [rbp+var_8]
sub eax, 9E1Fh
movsxd rcx, eax
lea rax, tab_uni_gb23128; "qD/p&<0pyC"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_3EC25
loc_3EBF1:
cmp [rbp+var_8], 0FF01h
jl short loc_3EC1E
cmp [rbp+var_8], 0FFE5h
jg short loc_3EC1E
mov eax, [rbp+var_8]
sub eax, 0FF01h
movsxd rcx, eax
lea rax, tab_uni_gb23129; "!#\"###g!%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#"...
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_3EC25
loc_3EC1E:
mov [rbp+var_4], 0
loc_3EC25:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long func_uni_gb2312_onechar(int a1)
{
if ( a1 < 164 || a1 > 476 )
{
if ( a1 < 711 || a1 > 1105 )
{
if ( a1 < 8213 || a1 > 8978 )
{
if ( a1 < 9312 || a1 > 9794 )
{
if ( a1 < 12288 || a1 > 12585 )
{
if ( a1 < 12832 || a1 > 12841 )
{
if ( a1 < 19968 || a1 > 39764 )
{
if ( a1 < 40060 || a1 > 40162 )
{
if ( a1 < 40479 || a1 > 40864 )
{
if ( a1 < 65281 || a1 > 65509 )
return 0;
else
return tab_uni_gb23129[a1 - 65281];
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23128[2 * a1 - 80958];
}
}
else
{
return tab_uni_gb23127[a1 - 40060];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23126[2 * a1 - 39936];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23125[2 * a1 - 25664];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23124[2 * a1 - 24576];
}
}
else
{
return tab_uni_gb23123[a1 - 9312];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23122[2 * a1 - 16426];
}
}
else
{
return tab_uni_gb23121[a1 - 711];
}
}
else
{
return tab_uni_gb23120[a1 - 164];
}
}
|
func_uni_gb2312_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa4
JL 0x0013ea77
CMP dword ptr [RBP + -0x8],0x1dc
JG 0x0013ea77
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa4
MOVSXD RCX,EAX
LEA RAX,[0x20db20]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013ec25
LAB_0013ea77:
CMP dword ptr [RBP + -0x8],0x2c7
JL 0x0013eaa7
CMP dword ptr [RBP + -0x8],0x451
JG 0x0013eaa7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2c7
MOVSXD RCX,EAX
LEA RAX,[0x20dda0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013ec25
LAB_0013eaa7:
CMP dword ptr [RBP + -0x8],0x2015
JL 0x0013ead7
CMP dword ptr [RBP + -0x8],0x2312
JG 0x0013ead7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2015
MOVSXD RCX,EAX
LEA RAX,[0x20e0c0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013ec25
LAB_0013ead7:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x0013eb07
CMP dword ptr [RBP + -0x8],0x2642
JG 0x0013eb07
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x20e6c0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013ec25
LAB_0013eb07:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x0013eb37
CMP dword ptr [RBP + -0x8],0x3129
JG 0x0013eb37
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x20ea90]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013ec25
LAB_0013eb37:
CMP dword ptr [RBP + -0x8],0x3220
JL 0x0013eb67
CMP dword ptr [RBP + -0x8],0x3229
JG 0x0013eb67
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3220
MOVSXD RCX,EAX
LEA RAX,[0x20ecf0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013ec25
LAB_0013eb67:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x0013eb97
CMP dword ptr [RBP + -0x8],0x9b54
JG 0x0013eb97
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x20ed10]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013ec25
LAB_0013eb97:
CMP dword ptr [RBP + -0x8],0x9c7c
JL 0x0013ebc4
CMP dword ptr [RBP + -0x8],0x9ce2
JG 0x0013ebc4
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9c7c
MOVSXD RCX,EAX
LEA RAX,[0x2187c0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013ec25
LAB_0013ebc4:
CMP dword ptr [RBP + -0x8],0x9e1f
JL 0x0013ebf1
CMP dword ptr [RBP + -0x8],0x9fa0
JG 0x0013ebf1
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9e1f
MOVSXD RCX,EAX
LEA RAX,[0x218890]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013ec25
LAB_0013ebf1:
CMP dword ptr [RBP + -0x8],0xff01
JL 0x0013ec1e
CMP dword ptr [RBP + -0x8],0xffe5
JG 0x0013ec1e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xff01
MOVSXD RCX,EAX
LEA RAX,[0x218ba0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013ec25
LAB_0013ec1e:
MOV dword ptr [RBP + -0x4],0x0
LAB_0013ec25:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_gb2312_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa4) || (0x1dc < param_1)) {
if ((param_1 < 0x2c7) || (0x451 < param_1)) {
if ((param_1 < 0x2015) || (0x2312 < param_1)) {
if ((param_1 < 0x2460) || (0x2642 < param_1)) {
if ((param_1 < 0x3000) || (0x3129 < param_1)) {
if ((param_1 < 0x3220) || (0x3229 < param_1)) {
if ((param_1 < 0x4e00) || (0x9b54 < param_1)) {
if ((param_1 < 0x9c7c) || (0x9ce2 < param_1)) {
if ((param_1 < 0x9e1f) || (0x9fa0 < param_1)) {
if ((param_1 < 0xff01) || (0xffe5 < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_gb23129 + (long)(param_1 + -0xff01) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23128 + (long)(param_1 + -0x9e1f) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23127 + (long)(param_1 + -0x9c7c) * 2);
}
}
else {
uVar1 = *(int2 *)(&tab_uni_gb23126 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23125 + (long)(param_1 + -0x3220) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23124 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23123 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23122 + (long)(param_1 + -0x2015) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23121 + (long)(param_1 + -0x2c7) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23120 + (long)(param_1 + -0xa4) * 2);
}
return uVar1;
}
|
|
10,837 |
my_mb_wc_utf8mb4_no_range
|
eloqsql/strings/ctype-utf8.c
|
static int
my_mb_wc_utf8mb4_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s)
{
uchar c;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
if (c < 0xc2)
return MY_CS_ILSEQ;
if (c < 0xe0)
{
if (!IS_CONTINUATION_BYTE(s[1]))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
if (c < 0xf0)
{
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 (!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;
}
|
O0
|
c
|
my_mb_wc_utf8mb4_no_range:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jge 0x6e2dd
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6e4d9
movzbl -0x21(%rbp), %eax
cmpl $0xc2, %eax
jge 0x6e2f4
movl $0x0, -0x4(%rbp)
jmp 0x6e4d9
movzbl -0x21(%rbp), %eax
cmpl $0xe0, %eax
jge 0x6e350
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0x6e31d
movl $0x0, -0x4(%rbp)
jmp 0x6e4d9
movzbl -0x21(%rbp), %eax
andl $0x1f, %eax
movslq %eax, %rcx
shlq $0x6, %rcx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x6e4d9
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0x6e3f2
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x6e39d
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x6e39d
movzbl -0x21(%rbp), %eax
cmpl $0xe1, %eax
jge 0x6e3a9
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0x6e3a9
movl $0x0, -0x4(%rbp)
jmp 0x6e4d9
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
shlq $0xc, %rcx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x6e4d9
movzbl -0x21(%rbp), %eax
cmpl $0xf5, %eax
jge 0x6e4d0
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x6e46b
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x6e46b
movq -0x20(%rbp), %rax
movzbl 0x3(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x6e46b
movzbl -0x21(%rbp), %eax
cmpl $0xf1, %eax
jge 0x6e451
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x90, %eax
jl 0x6e46b
movzbl -0x21(%rbp), %eax
cmpl $0xf3, %eax
jle 0x6e474
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x8f, %eax
jle 0x6e474
movl $0x0, -0x4(%rbp)
jmp 0x6e4d9
movzbl -0x21(%rbp), %eax
andl $0x7, %eax
movslq %eax, %rcx
shlq $0x12, %rcx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0xc, %rax
orq %rax, %rcx
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x20(%rbp), %rax
movzbl 0x3(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x4, -0x4(%rbp)
jmp 0x6e4d9
jmp 0x6e4d2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
|
my_mb_wc_utf8mb4_no_range:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 80h
jge short loc_6E2DD
movzx eax, [rbp+var_21]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_6E4D9
loc_6E2DD:
movzx eax, [rbp+var_21]
cmp eax, 0C2h
jge short loc_6E2F4
mov [rbp+var_4], 0
jmp loc_6E4D9
loc_6E2F4:
movzx eax, [rbp+var_21]
cmp eax, 0E0h
jge short loc_6E350
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_6E31D
mov [rbp+var_4], 0
jmp loc_6E4D9
loc_6E31D:
movzx eax, [rbp+var_21]
and eax, 1Fh
movsxd rcx, eax
shl rcx, 6
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_6E4D9
loc_6E350:
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge loc_6E3F2
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_6E39D
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_6E39D
movzx eax, [rbp+var_21]
cmp eax, 0E1h
jge short loc_6E3A9
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_6E3A9
loc_6E39D:
mov [rbp+var_4], 0
jmp loc_6E4D9
loc_6E3A9:
movzx eax, [rbp+var_21]
and eax, 0Fh
movsxd rcx, eax
shl rcx, 0Ch
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 3
jmp loc_6E4D9
loc_6E3F2:
movzx eax, [rbp+var_21]
cmp eax, 0F5h
jge loc_6E4D0
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_6E46B
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_6E46B
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+3]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_6E46B
movzx eax, [rbp+var_21]
cmp eax, 0F1h
jge short loc_6E451
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 90h
jl short loc_6E46B
loc_6E451:
movzx eax, [rbp+var_21]
cmp eax, 0F3h
jle short loc_6E474
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 8Fh
jle short loc_6E474
loc_6E46B:
mov [rbp+var_4], 0
jmp short loc_6E4D9
loc_6E474:
movzx eax, [rbp+var_21]
and eax, 7
movsxd rcx, eax
shl rcx, 12h
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 0Ch
or rcx, rax
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+3]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 4
jmp short loc_6E4D9
loc_6E4D0:
jmp short $+2
loc_6E4D2:
mov [rbp+var_4], 0
loc_6E4D9:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_mb_wc_utf8mb4_no_range(long long a1, unsigned long long *a2, unsigned __int8 *a3)
{
unsigned __int8 v4; // [rsp+1h] [rbp-21h]
v4 = *a3;
if ( *a3 >= 0x80u )
{
if ( v4 >= 0xC2u )
{
if ( v4 >= 0xE0u )
{
if ( v4 >= 0xF0u )
{
if ( v4 >= 0xF5u )
{
return 0;
}
else if ( (a3[1] ^ 0x80) < 64
&& (a3[2] ^ 0x80) < 64
&& (a3[3] ^ 0x80) < 64
&& (v4 >= 0xF1u || a3[1] >= 0x90u)
&& (v4 <= 0xF3u || a3[1] <= 0x8Fu) )
{
*a2 = a3[3] ^ 0x80u | ((long long)(a3[2] ^ 0x80u) << 6) | ((long long)(a3[1] ^ 0x80u) << 12) | ((unsigned long long)(v4 & 7) << 18);
return 4;
}
else
{
return 0;
}
}
else if ( (a3[1] ^ 0x80) < 64 && (a3[2] ^ 0x80) < 64 && (v4 >= 0xE1u || a3[1] >= 0xA0u) )
{
*a2 = a3[2] ^ 0x80u | ((long long)(a3[1] ^ 0x80u) << 6) | ((unsigned long long)(v4 & 0xF) << 12);
return 3;
}
else
{
return 0;
}
}
else if ( (a3[1] ^ 0x80) < 64 )
{
*a2 = a3[1] ^ 0x80u | ((unsigned long long)(v4 & 0x1F) << 6);
return 2;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
else
{
*a2 = v4;
return 1;
}
}
|
my_mb_wc_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
MOV RAX,qword ptr [RBP + -0x20]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0x80
JGE 0x0016e2dd
MOVZX EAX,byte ptr [RBP + -0x21]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0016e4d9
LAB_0016e2dd:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xc2
JGE 0x0016e2f4
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016e4d9
LAB_0016e2f4:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe0
JGE 0x0016e350
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x0016e31d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016e4d9
LAB_0016e31d:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x1f
MOVSXD RCX,EAX
SHL RCX,0x6
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0016e4d9
LAB_0016e350:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf0
JGE 0x0016e3f2
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0016e39d
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0016e39d
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe1
JGE 0x0016e3a9
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x0016e3a9
LAB_0016e39d:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016e4d9
LAB_0016e3a9:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0xf
MOVSXD RCX,EAX
SHL RCX,0xc
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0016e4d9
LAB_0016e3f2:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf5
JGE 0x0016e4d0
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0016e46b
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0016e46b
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x3]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0016e46b
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf1
JGE 0x0016e451
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x90
JL 0x0016e46b
LAB_0016e451:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf3
JLE 0x0016e474
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x8f
JLE 0x0016e474
LAB_0016e46b:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016e4d9
LAB_0016e474:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x7
MOVSXD RCX,EAX
SHL RCX,0x12
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0xc
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x3]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x4
JMP 0x0016e4d9
LAB_0016e4d0:
JMP 0x0016e4d2
LAB_0016e4d2:
MOV dword ptr [RBP + -0x4],0x0
LAB_0016e4d9:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_utf8mb4_no_range(int8 param_1,ulong *param_2,byte *param_3)
{
byte bVar1;
int4 local_c;
bVar1 = *param_3;
if (bVar1 < 0x80) {
*param_2 = (ulong)bVar1;
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if ((param_3[1] ^ 0x80) < 0x40) {
*param_2 = (long)(int)(bVar1 & 0x1f) << 6 | (long)(int)(param_3[1] ^ 0x80);
local_c = 2;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf0) {
if ((((param_3[1] ^ 0x80) < 0x40) && ((param_3[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_3[1])))) {
*param_2 = (long)(int)(bVar1 & 0xf) << 0xc | (long)(int)(param_3[1] ^ 0x80) << 6 |
(long)(int)(param_3[2] ^ 0x80);
local_c = 3;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf5) {
if ((((((param_3[1] ^ 0x80) < 0x40) && ((param_3[2] ^ 0x80) < 0x40)) &&
((param_3[3] ^ 0x80) < 0x40)) && ((0xf0 < bVar1 || (0x8f < param_3[1])))) &&
((bVar1 < 0xf4 || (param_3[1] < 0x90)))) {
*param_2 = (long)(int)(bVar1 & 7) << 0x12 | (long)(int)(param_3[1] ^ 0x80) << 0xc |
(long)(int)(param_3[2] ^ 0x80) << 6 | (long)(int)(param_3[3] ^ 0x80);
local_c = 4;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
10,838 |
rw_pr_rdlock
|
eloqsql/mysys/thr_rwlock.c
|
int rw_pr_rdlock(rw_pr_lock_t *rwlock)
{
pthread_mutex_lock(&rwlock->lock);
/*
The fact that we were able to acquire 'lock' mutex means
that there are no active writers and we can acquire rd-lock.
Increment active readers counter to prevent requests for
wr-lock from succeeding and unlock mutex.
*/
rwlock->active_readers++;
pthread_mutex_unlock(&rwlock->lock);
return 0;
}
|
O0
|
c
|
rw_pr_rdlock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24420
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rdi
callq 0x241f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
rw_pr_rdlock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
call _pthread_mutex_lock
mov rax, [rbp+var_8]
mov ecx, [rax+58h]
add ecx, 1
mov [rax+58h], ecx
mov rdi, [rbp+var_8]
call _pthread_mutex_unlock
xor eax, eax
add rsp, 10h
pop rbp
retn
|
long long rw_pr_rdlock(long long a1)
{
pthread_mutex_lock(a1);
++*(_DWORD *)(a1 + 88);
pthread_mutex_unlock(a1);
return 0LL;
}
|
rw_pr_rdlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00124420
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x58]
ADD ECX,0x1
MOV dword ptr [RAX + 0x58],ECX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001241f0
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 rw_pr_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
*(int *)((long)param_1 + 0x58) = *(int *)((long)param_1 + 0x58) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
|
|
10,839 |
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11])
|
monkey531[P]llama/common/json.hpp
|
size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
// Since we cannot move const Keys, re-construct them in place
for (auto next = it; ++next != this->end(); ++it)
{
it->~value_type(); // Destroy but keep allocation
new (&*it) value_type{std::move(*next)};
}
Container::pop_back();
return 1;
}
}
return 0;
}
|
O2
|
cpp
|
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x8(%r14), %r13
cmpq %r13, %rbx
je 0x7f41d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a07e
testb %al, %al
jne 0x7f3f0
addq $0x30, %rbx
jmp 0x7f3d2
movq %rbx, %r15
leaq 0x30(%r15), %r12
cmpq 0x8(%r14), %r12
je 0x7f415
movq %r15, %rdi
callq 0x43300
movq %r15, %rdi
movq %r12, %rsi
callq 0x43f64
movq %r12, %r15
jmp 0x7f3f3
movq %r14, %rdi
callq 0x7f430
xorl %eax, %eax
cmpq %r13, %rbx
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
push r15
push r14
push r13
push r12
push rbx
mov r15, rsi
mov r14, rdi
mov rbx, [rdi]
loc_7F3D2:
mov r13, [r14+8]
cmp rbx, r13
jz short loc_7F41D
mov rdi, rbx
mov rsi, r15
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_7F3F0
add rbx, 30h ; '0'
jmp short loc_7F3D2
loc_7F3F0:
mov r15, rbx
loc_7F3F3:
lea r12, [r15+30h]
cmp r12, [r14+8]
jz short loc_7F415
mov rdi, r15; void *
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
mov rdi, r15
mov rsi, r12
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2EOSG_; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pair(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>&&)
mov r15, r12
jmp short loc_7F3F3
loc_7F415:
mov rdi, r14
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE8pop_backEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::pop_back(void)
loc_7F41D:
xor eax, eax
cmp rbx, r13
setnz al
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
_BOOL8 ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_(
long long *a1,
char *a2)
{
long long i; // rbx
long long v4; // r13
char *v5; // rsi
char *j; // r15
for ( i = *a1; ; i += 48LL )
{
v4 = a1[1];
if ( i == v4 )
break;
v5 = a2;
if ( std::operator==<char>(i) )
{
for ( j = (char *)i; j + 48 != (char *)a1[1]; j += 48 )
{
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~pair(j);
v5 = j + 48;
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pair(
(long long)j,
(long long)(j + 48));
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::pop_back(
a1,
v5);
return i != v4;
}
}
return i != v4;
}
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_0017f3d2:
MOV R13,qword ptr [R14 + 0x8]
CMP RBX,R13
JZ 0x0017f41d
MOV RDI,RBX
MOV RSI,R15
CALL 0x0013a07e
TEST AL,AL
JNZ 0x0017f3f0
ADD RBX,0x30
JMP 0x0017f3d2
LAB_0017f3f0:
MOV R15,RBX
LAB_0017f3f3:
LEA R12,[R15 + 0x30]
CMP R12,qword ptr [R14 + 0x8]
JZ 0x0017f415
MOV RDI,R15
CALL 0x00143300
MOV RDI,R15
MOV RSI,R12
CALL 0x00143f64
MOV R15,R12
JMP 0x0017f3f3
LAB_0017f415:
MOV RDI,R14
CALL 0x0017f430
LAB_0017f41d:
XOR EAX,EAX
CMP RBX,R13
SETNZ AL
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
bool _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_
(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*param_1,char *param_2)
{
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*ppVar1;
string *psVar2;
bool bVar3;
string *psVar4;
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this;
for (psVar4 = *(string **)param_1; psVar2 = *(string **)(param_1 + 8), psVar4 != psVar2;
psVar4 = psVar4 + 0x30) {
bVar3 = std::operator==(psVar4,param_2);
this = (pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)psVar4;
if (bVar3) goto LAB_0017f3f3;
}
LAB_0017f41d:
return psVar4 != psVar2;
LAB_0017f3f3:
while (ppVar1 = this + 0x30,
ppVar1 != *(pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
**)(param_1 + 8)) {
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::~pair(this);
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::pair(this,ppVar1);
this = ppVar1;
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::pop_back(param_1);
goto LAB_0017f41d;
}
|
|
10,840 |
store_page_range
|
eloqsql/storage/maria/ma_blockrec.c
|
static uchar *store_page_range(MARIA_SHARE *share,
uchar *to, MARIA_BITMAP_BLOCK *block,
ulong length,
uint *tot_ranges)
{
uint data_size= FULL_PAGE_SIZE(share);
ulong pages_left= (length + data_size -1) / data_size;
uint page_count, ranges, empty_space;
uchar *to_start;
DBUG_ENTER("store_page_range");
to_start= to;
to+= SUB_RANGE_SIZE;
/* Store number of unused bytes at last page */
empty_space= (uint) (pages_left * data_size - length);
int2store(to, empty_space);
to+= BLOCK_FILLER_SIZE;
ranges= 0;
do
{
pgcache_page_no_t page;
page= block->page;
page_count= block->page_count;
block++;
if (page_count > pages_left)
page_count= pages_left;
page_store(to, page);
to+= PAGE_STORE_SIZE;
pagerange_store(to, page_count);
to+= PAGERANGE_STORE_SIZE;
ranges++;
} while ((pages_left-= page_count));
/* Store number of ranges for this block */
int2store(to_start, ranges);
(*tot_ranges)+= ranges;
DBUG_RETURN(to);
}
|
O3
|
c
|
store_page_range:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %r10
subl %esi, %edi
addl $-0xc, %edi
leaq (%rdi,%r8), %rax
decq %rax
xorl %esi, %esi
xorl %edx, %edx
divq %rdi
movl %eax, %edx
imull %edi, %edx
subl %r8d, %edx
movw %dx, 0x2(%r10)
leaq 0x4(%r10), %rdx
movq (%rcx), %rdi
movl 0x8(%rcx), %r8d
cmpq %r8, %rax
movl %eax, %r11d
cmovael %r8d, %r11d
movl %edi, (%rdx)
shrq $0x20, %rdi
movb %dil, 0x4(%rdx)
movw %r11w, 0x5(%rdx)
addq $0x7, %rdx
incl %esi
addq $0x18, %rcx
subq %r11, %rax
jne 0x3bf8d
movw %si, (%r10)
addl %esi, (%r9)
movq %rdx, %rax
popq %rbp
retq
|
store_page_range:
push rbp
mov rbp, rsp
mov r10, rdx
sub edi, esi
add edi, 0FFFFFFF4h
lea rax, [rdi+r8]
dec rax
xor esi, esi
xor edx, edx
div rdi
mov edx, eax
imul edx, edi
sub edx, r8d
mov [r10+2], dx
lea rdx, [r10+4]
loc_3BF8D:
mov rdi, [rcx]
mov r8d, [rcx+8]
cmp rax, r8
mov r11d, eax
cmovnb r11d, r8d
mov [rdx], edi
shr rdi, 20h
mov [rdx+4], dil
mov [rdx+5], r11w
add rdx, 7
inc esi
add rcx, 18h
sub rax, r11
jnz short loc_3BF8D
mov [r10], si
add [r9], esi
mov rax, rdx
pop rbp
retn
|
_WORD * store_page_range(int a1, int a2, _WORD *a3, long long *a4, long long a5, _DWORD *a6)
{
unsigned long long v7; // rdi
int v8; // esi
unsigned long long v9; // rax
_WORD *v10; // rdx
long long v11; // rdi
unsigned long long v12; // r8
long long v13; // r11
v7 = (unsigned int)(a1 - a2 - 12);
v8 = 0;
v9 = (v7 + a5 - 1) / v7;
a3[1] = v7 * v9 - a5;
v10 = a3 + 2;
do
{
v11 = *a4;
v12 = *((unsigned int *)a4 + 2);
v13 = (unsigned int)v9;
if ( v9 >= v12 )
v13 = (unsigned int)v12;
*(_DWORD *)v10 = v11;
*((_BYTE *)v10 + 4) = BYTE4(v11);
*(_WORD *)((char *)v10 + 5) = v13;
v10 = (_WORD *)((char *)v10 + 7);
++v8;
a4 += 3;
v9 -= v13;
}
while ( v9 );
*a3 = v8;
*a6 += v8;
return v10;
}
|
store_page_range:
PUSH RBP
MOV RBP,RSP
MOV R10,RDX
SUB EDI,ESI
ADD EDI,-0xc
LEA RAX,[RDI + R8*0x1]
DEC RAX
XOR ESI,ESI
XOR EDX,EDX
DIV RDI
MOV EDX,EAX
IMUL EDX,EDI
SUB EDX,R8D
MOV word ptr [R10 + 0x2],DX
LEA RDX,[R10 + 0x4]
LAB_0013bf8d:
MOV RDI,qword ptr [RCX]
MOV R8D,dword ptr [RCX + 0x8]
CMP RAX,R8
MOV R11D,EAX
CMOVNC R11D,R8D
MOV dword ptr [RDX],EDI
SHR RDI,0x20
MOV byte ptr [RDX + 0x4],DIL
MOV word ptr [RDX + 0x5],R11W
ADD RDX,0x7
INC ESI
ADD RCX,0x18
SUB RAX,R11
JNZ 0x0013bf8d
MOV word ptr [R10],SI
ADD dword ptr [R9],ESI
MOV RAX,RDX
POP RBP
RET
|
int4 *
store_page_range(int param_1,int param_2,int2 *param_3,int8 *param_4,long param_5,
int *param_6)
{
int8 uVar1;
int1 auVar2 [16];
int1 auVar3 [16];
ulong uVar4;
int4 *puVar5;
int iVar6;
uint uVar7;
ulong uVar8;
uVar7 = (param_1 - param_2) - 0xc;
uVar4 = CONCAT44(0,uVar7);
iVar6 = 0;
auVar2._8_8_ = 0;
auVar2._0_8_ = uVar4;
auVar3._8_8_ = 0;
auVar3._0_8_ = (uVar4 + param_5) - 1;
uVar4 = SUB168(auVar3 / auVar2,0);
param_3[1] = SUB162(auVar3 / auVar2,0) * (short)uVar7 - (short)param_5;
puVar5 = (int4 *)(param_3 + 2);
do {
uVar1 = *param_4;
uVar8 = uVar4 & 0xffffffff;
if (*(uint *)(param_4 + 1) <= uVar4) {
uVar8 = (ulong)*(uint *)(param_4 + 1);
}
*puVar5 = (int)uVar1;
*(char *)(puVar5 + 1) = (char)((ulong)uVar1 >> 0x20);
*(short *)((long)puVar5 + 5) = (short)uVar8;
puVar5 = (int4 *)((long)puVar5 + 7);
iVar6 = iVar6 + 1;
param_4 = param_4 + 3;
uVar4 = uVar4 - uVar8;
} while (uVar4 != 0);
*param_3 = (short)iVar6;
*param_6 = *param_6 + iVar6;
return puVar5;
}
|
|
10,841 |
my_hash_delete
|
eloqsql/mysys/hash.c
|
my_bool my_hash_delete(HASH *hash, uchar *record)
{
uint pos2,idx,empty_index;
my_hash_value_type pos_hashnr, lastpos_hashnr;
size_t blength;
HASH_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
DBUG_ENTER("my_hash_delete");
if (!hash->records)
DBUG_RETURN(1);
blength=hash->blength;
data=dynamic_element(&hash->array,0,HASH_LINK*);
/* Search after record with key */
pos= data + my_hash_mask(rec_hashnr(hash, record), blength, hash->records);
gpos = 0;
while (pos->data != record)
{
gpos=pos;
if (pos->next == NO_RECORD)
DBUG_RETURN(1); /* Key not found */
pos=data+pos->next;
}
if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
lastpos=data+hash->records;
/* Remove link to record */
empty=pos; empty_index=(uint) (empty-data);
if (gpos)
gpos->next=pos->next; /* unlink current ptr */
else if (pos->next != NO_RECORD)
{
empty=data+(empty_index=pos->next);
pos[0]= empty[0];
}
if (empty == lastpos) /* last key at wrong pos or no next link */
goto exit;
/* Move the last key (lastpos) */
lastpos_hashnr= lastpos->hash_nr;
/* pos is where lastpos should be */
pos= data + my_hash_mask(lastpos_hashnr, hash->blength, hash->records);
if (pos == empty) /* Move to empty position. */
{
empty[0]=lastpos[0];
goto exit;
}
pos_hashnr= pos->hash_nr;
/* pos3 is where the pos should be */
pos3= data + my_hash_mask(pos_hashnr, hash->blength, hash->records);
if (pos != pos3)
{ /* pos is on wrong posit */
empty[0]=pos[0]; /* Save it here */
pos[0]=lastpos[0]; /* This should be here */
movelink(data,(uint) (pos-data),(uint) (pos3-data),empty_index);
goto exit;
}
pos2= my_hash_mask(lastpos_hashnr, blength, hash->records + 1);
if (pos2 == my_hash_mask(pos_hashnr, blength, hash->records + 1))
{ /* Identical key-positions */
if (pos2 != hash->records)
{
empty[0]=lastpos[0];
movelink(data,(uint) (lastpos-data),(uint) (pos-data),empty_index);
goto exit;
}
idx= (uint) (pos-data); /* Link pos->next after lastpos */
}
else idx= NO_RECORD; /* Different positions merge */
empty[0]=lastpos[0];
movelink(data,idx,empty_index,pos->next);
pos->next=empty_index;
exit:
(void) pop_dynamic(&hash->array);
if (hash->free)
(*hash->free)((uchar*) record);
DBUG_RETURN(0);
}
|
O3
|
c
|
my_hash_delete:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movb $0x1, %r15b
cmpq $0x0, 0x18(%rdi)
je 0x4f2da
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0x28(%rdi), %r13
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x4f0db
leaq -0x58(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rsi
movq (%r12), %rdx
jmp 0x4f0e9
movq 0x8(%r14), %rdx
movq %rdx, -0x58(%rbp)
movq (%r14), %rsi
addq %rbx, %rsi
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movq 0x68(%r14), %rdi
callq *0x58(%r14)
movq 0x18(%r14), %rcx
movq -0x38(%rbp), %r9
leaq (%r9,%r12), %r10
movl %r10d, %edx
andl %eax, %edx
shrq %r9
decl %r9d
andl %r9d, %eax
cmpq %rcx, %rdx
cmovbl %edx, %eax
movq %rax, %rdx
shlq $0x4, %rdx
leaq (%rdx,%r13), %rsi
cmpq %rbx, 0x8(%r13,%rdx)
je 0x4f14b
movl (%rsi), %eax
cmpq %r12, %rax
je 0x4f2da
movq %rsi, %rdx
movq %rax, %rdi
shlq $0x4, %rdi
leaq (%rdi,%r13), %rsi
cmpq %rbx, 0x8(%r13,%rdi)
jne 0x4f129
jmp 0x4f14d
xorl %edx, %edx
decq %rcx
movq %rcx, 0x18(%r14)
movq 0x10(%r14), %rdi
shrq %rdi
cmpq %rdi, %rcx
jae 0x4f164
movq %rdi, 0x10(%r14)
movq %rcx, %r8
shlq $0x4, %r8
addq %r13, %r8
movl (%rsi), %edi
testq %rdx, %rdx
je 0x4f179
movl %edi, (%rdx)
jmp 0x4f194
cmpl $-0x1, %edi
je 0x4f194
movq %rdi, %rax
shlq $0x4, %rax
movups (%r13,%rax), %xmm0
movups %xmm0, (%rsi)
leaq (%rax,%r13), %rsi
movl %edi, %eax
leaq 0x28(%r14), %rdi
cmpq %r8, %rsi
je 0x4f2c4
movq %r10, -0x50(%rbp)
movq %r9, -0x38(%rbp)
movl 0x4(%r8), %r11d
movq 0x10(%r14), %r9
movq 0x18(%r14), %r15
addq %r9, %r12
movl %r12d, %edx
andl %r11d, %edx
shrq %r9
decl %r9d
movl %r9d, %r10d
andl %r11d, %r10d
cmpq %r15, %rdx
cmovbl %edx, %r10d
movq %r10, %rdx
shlq $0x4, %rdx
addq %r13, %rdx
cmpq %rsi, %rdx
je 0x4f26d
movq %rdi, -0x30(%rbp)
movl 0x4(%rdx), %edi
andl %edi, %r12d
andl %edi, %r9d
cmpq %r15, %r12
cmovbl %r12d, %r9d
cmpl %r9d, %r10d
jne 0x4f276
movq %r15, -0x48(%rbp)
leaq 0x1(%r15), %r9
movq %r9, -0x40(%rbp)
movq -0x50(%rbp), %r9
movl %r9d, %r12d
andl %r11d, %r12d
movq -0x38(%rbp), %r15
andl %r15d, %r11d
cmpq -0x40(%rbp), %r12
cmovbl %r12d, %r11d
andl %edi, %r9d
andl %r15d, %edi
cmpq -0x40(%rbp), %r9
cmovbl %r9d, %edi
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
cmpl %edi, %r11d
jne 0x4f247
movl %r11d, %edi
cmpq %rdi, -0x48(%rbp)
jne 0x4f2a1
movl %r10d, %r9d
movups (%r8), %xmm0
movups %xmm0, (%rsi)
movl (%rdx), %ecx
movl %eax, %edi
movl %edi, %esi
shlq $0x4, %rsi
movl (%r13,%rsi), %edi
cmpl %r9d, %edi
jne 0x4f252
addq %rsi, %r13
movl %ecx, (%r13)
movl %eax, (%rdx)
jmp 0x4f2c0
movups (%r8), %xmm0
movups %xmm0, (%rsi)
jmp 0x4f2c4
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
movups (%r8), %xmm0
movups %xmm0, (%rdx)
movq -0x30(%rbp), %rdi
movl %r9d, %ecx
shlq $0x4, %rcx
movl (%r13,%rcx), %r9d
cmpl %r10d, %r9d
jne 0x4f287
addq %rcx, %r13
movl %eax, (%r13)
jmp 0x4f2c4
movups (%r8), %xmm0
movups %xmm0, (%rsi)
movl %r10d, %edx
shlq $0x4, %rdx
movl (%r13,%rdx), %r10d
cmpl %ecx, %r10d
jne 0x4f2a8
addq %rdx, %r13
movl %eax, (%r13)
movq -0x30(%rbp), %rdi
callq 0x5101b
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x4f2d7
movq %rbx, %rdi
callq *%rax
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_hash_delete:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15b, 1
cmp qword ptr [rdi+18h], 0
jz loc_4F2DA
mov rbx, rsi
mov r14, rdi
mov rax, [rdi+10h]
mov [rbp+var_38], rax
mov r13, [rdi+28h]
mov rax, [rdi+50h]
test rax, rax
jz short loc_4F0DB
lea r12, [rbp+var_58]
mov rdi, rbx
mov rsi, r12
xor edx, edx
call rax
mov rsi, rax
mov rdx, [r12]
jmp short loc_4F0E9
loc_4F0DB:
mov rdx, [r14+8]
mov [rbp+var_58], rdx
mov rsi, [r14]
add rsi, rbx
loc_4F0E9:
mov r12d, 0FFFFFFFFh
mov rdi, [r14+68h]
call qword ptr [r14+58h]
mov rcx, [r14+18h]
mov r9, [rbp+var_38]
lea r10, [r9+r12]
mov edx, r10d
and edx, eax
shr r9, 1
dec r9d
and eax, r9d
cmp rdx, rcx
cmovb eax, edx
mov rdx, rax
shl rdx, 4
lea rsi, [rdx+r13]
cmp [r13+rdx+8], rbx
jz short loc_4F14B
loc_4F129:
mov eax, [rsi]
cmp rax, r12
jz loc_4F2DA
mov rdx, rsi
mov rdi, rax
shl rdi, 4
lea rsi, [rdi+r13]
cmp [r13+rdi+8], rbx
jnz short loc_4F129
jmp short loc_4F14D
loc_4F14B:
xor edx, edx
loc_4F14D:
dec rcx
mov [r14+18h], rcx
mov rdi, [r14+10h]
shr rdi, 1
cmp rcx, rdi
jnb short loc_4F164
mov [r14+10h], rdi
loc_4F164:
mov r8, rcx
shl r8, 4
add r8, r13
mov edi, [rsi]
test rdx, rdx
jz short loc_4F179
mov [rdx], edi
jmp short loc_4F194
loc_4F179:
cmp edi, 0FFFFFFFFh
jz short loc_4F194
mov rax, rdi
shl rax, 4
movups xmm0, xmmword ptr [r13+rax+0]
movups xmmword ptr [rsi], xmm0
lea rsi, [rax+r13]
mov eax, edi
loc_4F194:
lea rdi, [r14+28h]
cmp rsi, r8
jz loc_4F2C4
mov [rbp+var_50], r10
mov [rbp+var_38], r9
mov r11d, [r8+4]
mov r9, [r14+10h]
mov r15, [r14+18h]
add r12, r9
mov edx, r12d
and edx, r11d
shr r9, 1
dec r9d
mov r10d, r9d
and r10d, r11d
cmp rdx, r15
cmovb r10d, edx
mov rdx, r10
shl rdx, 4
add rdx, r13
cmp rdx, rsi
jz loc_4F26D
mov [rbp+var_30], rdi
mov edi, [rdx+4]
and r12d, edi
and r9d, edi
cmp r12, r15
cmovb r9d, r12d
cmp r10d, r9d
jnz short loc_4F276
mov [rbp+var_48], r15
lea r9, [r15+1]
mov [rbp+var_40], r9
mov r9, [rbp+var_50]
mov r12d, r9d
and r12d, r11d
mov r15, [rbp+var_38]
and r11d, r15d
cmp r12, [rbp+var_40]
cmovb r11d, r12d
and r9d, edi
and edi, r15d
cmp r9, [rbp+var_40]
cmovb edi, r9d
mov r9d, 0FFFFFFFFh
cmp r11d, edi
jnz short loc_4F247
mov edi, r11d
cmp [rbp+var_48], rdi
jnz short loc_4F2A1
mov r9d, r10d
loc_4F247:
movups xmm0, xmmword ptr [r8]
movups xmmword ptr [rsi], xmm0
mov ecx, [rdx]
mov edi, eax
loc_4F252:
mov esi, edi
shl rsi, 4
mov edi, [r13+rsi+0]
cmp edi, r9d
jnz short loc_4F252
add r13, rsi
mov [r13+0], ecx
mov [rdx], eax
jmp short loc_4F2C0
loc_4F26D:
movups xmm0, xmmword ptr [r8]
movups xmmword ptr [rsi], xmm0
jmp short loc_4F2C4
loc_4F276:
movups xmm0, xmmword ptr [rdx]
movups xmmword ptr [rsi], xmm0
movups xmm0, xmmword ptr [r8]
movups xmmword ptr [rdx], xmm0
mov rdi, [rbp+var_30]
loc_4F287:
mov ecx, r9d
shl rcx, 4
mov r9d, [r13+rcx+0]
cmp r9d, r10d
jnz short loc_4F287
add r13, rcx
mov [r13+0], eax
jmp short loc_4F2C4
loc_4F2A1:
movups xmm0, xmmword ptr [r8]
movups xmmword ptr [rsi], xmm0
loc_4F2A8:
mov edx, r10d
shl rdx, 4
mov r10d, [r13+rdx+0]
cmp r10d, ecx
jnz short loc_4F2A8
add r13, rdx
mov [r13+0], eax
loc_4F2C0:
mov rdi, [rbp+var_30]
loc_4F2C4:
call pop_dynamic
mov rax, [r14+60h]
test rax, rax
jz short loc_4F2D7
mov rdi, rbx
call rax
loc_4F2D7:
xor r15d, r15d
loc_4F2DA:
mov eax, r15d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_hash_delete(long long a1, long long a2)
{
unsigned int v2; // r15d
long long v5; // r13
long long ( *v6)(long long, long long *, _QWORD); // rax
long long v7; // rsi
long long v8; // rdx
int v9; // eax
unsigned long long v10; // rcx
unsigned long long v11; // r10
unsigned long long v12; // rdx
unsigned long long v13; // r9
long long v14; // rax
unsigned int *v15; // rsi
unsigned int *v16; // rdx
unsigned long long v17; // rcx
unsigned long long v18; // rdi
unsigned int *v19; // r8
long long v20; // rdi
long long v21; // rdi
unsigned int v22; // r11d
unsigned long long v23; // r9
unsigned long long v24; // r15
int v25; // r12d
unsigned long long v26; // rdx
int v27; // r9d
long long v28; // r10
unsigned int *v29; // rdx
unsigned int v30; // edi
unsigned long long v31; // r12
unsigned int v32; // r9d
unsigned long long v33; // r12
int v34; // r11d
unsigned long long v35; // r9
int v36; // edi
int v37; // r9d
unsigned int v38; // edi
long long v39; // rsi
long long v40; // rcx
long long v41; // rdx
void ( *v42)(long long); // rax
long long v44; // [rsp+8h] [rbp-58h] BYREF
unsigned long long v45; // [rsp+10h] [rbp-50h]
unsigned long long v46; // [rsp+18h] [rbp-48h]
unsigned long long v47; // [rsp+20h] [rbp-40h]
unsigned long long v48; // [rsp+28h] [rbp-38h]
long long v49; // [rsp+30h] [rbp-30h]
LOBYTE(v2) = 1;
if ( !*(_QWORD *)(a1 + 24) )
return v2;
v48 = *(_QWORD *)(a1 + 16);
v5 = *(_QWORD *)(a1 + 40);
v6 = *(long long ( **)(long long, long long *, _QWORD))(a1 + 80);
if ( v6 )
{
v7 = v6(a2, &v44, 0LL);
v8 = v44;
}
else
{
v8 = *(_QWORD *)(a1 + 8);
v44 = v8;
v7 = a2 + *(_QWORD *)a1;
}
v9 = (*(long long ( **)(_QWORD, long long, long long))(a1 + 88))(*(_QWORD *)(a1 + 104), v7, v8);
v10 = *(_QWORD *)(a1 + 24);
v11 = v48 + 0xFFFFFFFF;
v12 = v9 & (unsigned int)(v48 - 1);
v13 = (unsigned int)(v48 >> 1) - 1;
v14 = (unsigned int)v13 & v9;
if ( v12 < v10 )
v14 = (unsigned int)v12;
v15 = (unsigned int *)(16 * v14 + v5);
if ( *((_QWORD *)v15 + 1) == a2 )
{
v16 = 0LL;
LABEL_12:
v17 = v10 - 1;
*(_QWORD *)(a1 + 24) = v17;
v18 = *(_QWORD *)(a1 + 16) >> 1;
if ( v17 < v18 )
*(_QWORD *)(a1 + 16) = v18;
v19 = (unsigned int *)(v5 + 16 * v17);
v20 = *v15;
if ( v16 )
{
*v16 = v20;
}
else if ( (_DWORD)v20 != -1 )
{
*(_OWORD *)v15 = *(_OWORD *)(v5 + 16 * v20);
v15 = (unsigned int *)(16 * v20 + v5);
LODWORD(v14) = v20;
}
v21 = a1 + 40;
if ( v15 == v19 )
goto LABEL_43;
v45 = v11;
v48 = v13;
v22 = v19[1];
v23 = *(_QWORD *)(a1 + 16);
v24 = *(_QWORD *)(a1 + 24);
v25 = v23 - 1;
v26 = v22 & ((_DWORD)v23 - 1);
v27 = (v23 >> 1) - 1;
v28 = v22 & v27;
if ( v26 < v24 )
v28 = (unsigned int)v26;
v29 = (unsigned int *)(v5 + 16 * v28);
if ( v29 == v15 )
{
*(_OWORD *)v15 = *(_OWORD *)v19;
LABEL_43:
pop_dynamic(v21);
v42 = *(void ( **)(long long))(a1 + 96);
if ( v42 )
v42(a2);
return 0;
}
v49 = a1 + 40;
v30 = v29[1];
v31 = v30 & v25;
v32 = v30 & v27;
if ( v31 < v24 )
v32 = v31;
if ( (_DWORD)v28 != v32 )
{
*(_OWORD *)v15 = *(_OWORD *)v29;
*(_OWORD *)v29 = *(_OWORD *)v19;
v21 = v49;
do
{
v40 = 16LL * v32;
v32 = *(_DWORD *)(v5 + v40);
}
while ( v32 != (_DWORD)v28 );
*(_DWORD *)(v40 + v5) = v14;
goto LABEL_43;
}
v46 = v24;
v47 = v24 + 1;
v33 = v22 & (unsigned int)v45;
v34 = v48 & v22;
if ( v33 < v24 + 1 )
v34 = v33;
v35 = v30 & (unsigned int)v45;
v36 = v48 & v30;
if ( v35 < v47 )
v36 = v35;
v37 = -1;
if ( v34 == v36 )
{
if ( v46 != v34 )
{
*(_OWORD *)v15 = *(_OWORD *)v19;
do
{
v41 = 16LL * (unsigned int)v28;
LODWORD(v28) = *(_DWORD *)(v5 + v41);
}
while ( (_DWORD)v28 != (_DWORD)v17 );
*(_DWORD *)(v41 + v5) = v14;
goto LABEL_42;
}
v37 = v28;
}
*(_OWORD *)v15 = *(_OWORD *)v19;
v38 = v14;
do
{
v39 = 16LL * v38;
v38 = *(_DWORD *)(v5 + v39);
}
while ( v38 != v37 );
*(_DWORD *)(v39 + v5) = *v29;
*v29 = v14;
LABEL_42:
v21 = v49;
goto LABEL_43;
}
while ( 1 )
{
v14 = *v15;
if ( v14 == 0xFFFFFFFFLL )
return v2;
v16 = v15;
v15 = (unsigned int *)(16 * v14 + v5);
if ( *((_QWORD *)v15 + 1) == a2 )
goto LABEL_12;
}
}
|
my_hash_delete:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15B,0x1
CMP qword ptr [RDI + 0x18],0x0
JZ 0x0014f2da
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV R13,qword ptr [RDI + 0x28]
MOV RAX,qword ptr [RDI + 0x50]
TEST RAX,RAX
JZ 0x0014f0db
LEA R12,[RBP + -0x58]
MOV RDI,RBX
MOV RSI,R12
XOR EDX,EDX
CALL RAX
MOV RSI,RAX
MOV RDX,qword ptr [R12]
JMP 0x0014f0e9
LAB_0014f0db:
MOV RDX,qword ptr [R14 + 0x8]
MOV qword ptr [RBP + -0x58],RDX
MOV RSI,qword ptr [R14]
ADD RSI,RBX
LAB_0014f0e9:
MOV R12D,0xffffffff
MOV RDI,qword ptr [R14 + 0x68]
CALL qword ptr [R14 + 0x58]
MOV RCX,qword ptr [R14 + 0x18]
MOV R9,qword ptr [RBP + -0x38]
LEA R10,[R9 + R12*0x1]
MOV EDX,R10D
AND EDX,EAX
SHR R9,0x1
DEC R9D
AND EAX,R9D
CMP RDX,RCX
CMOVC EAX,EDX
MOV RDX,RAX
SHL RDX,0x4
LEA RSI,[RDX + R13*0x1]
CMP qword ptr [R13 + RDX*0x1 + 0x8],RBX
JZ 0x0014f14b
LAB_0014f129:
MOV EAX,dword ptr [RSI]
CMP RAX,R12
JZ 0x0014f2da
MOV RDX,RSI
MOV RDI,RAX
SHL RDI,0x4
LEA RSI,[RDI + R13*0x1]
CMP qword ptr [R13 + RDI*0x1 + 0x8],RBX
JNZ 0x0014f129
JMP 0x0014f14d
LAB_0014f14b:
XOR EDX,EDX
LAB_0014f14d:
DEC RCX
MOV qword ptr [R14 + 0x18],RCX
MOV RDI,qword ptr [R14 + 0x10]
SHR RDI,0x1
CMP RCX,RDI
JNC 0x0014f164
MOV qword ptr [R14 + 0x10],RDI
LAB_0014f164:
MOV R8,RCX
SHL R8,0x4
ADD R8,R13
MOV EDI,dword ptr [RSI]
TEST RDX,RDX
JZ 0x0014f179
MOV dword ptr [RDX],EDI
JMP 0x0014f194
LAB_0014f179:
CMP EDI,-0x1
JZ 0x0014f194
MOV RAX,RDI
SHL RAX,0x4
MOVUPS XMM0,xmmword ptr [R13 + RAX*0x1]
MOVUPS xmmword ptr [RSI],XMM0
LEA RSI,[RAX + R13*0x1]
MOV EAX,EDI
LAB_0014f194:
LEA RDI,[R14 + 0x28]
CMP RSI,R8
JZ 0x0014f2c4
MOV qword ptr [RBP + -0x50],R10
MOV qword ptr [RBP + -0x38],R9
MOV R11D,dword ptr [R8 + 0x4]
MOV R9,qword ptr [R14 + 0x10]
MOV R15,qword ptr [R14 + 0x18]
ADD R12,R9
MOV EDX,R12D
AND EDX,R11D
SHR R9,0x1
DEC R9D
MOV R10D,R9D
AND R10D,R11D
CMP RDX,R15
CMOVC R10D,EDX
MOV RDX,R10
SHL RDX,0x4
ADD RDX,R13
CMP RDX,RSI
JZ 0x0014f26d
MOV qword ptr [RBP + -0x30],RDI
MOV EDI,dword ptr [RDX + 0x4]
AND R12D,EDI
AND R9D,EDI
CMP R12,R15
CMOVC R9D,R12D
CMP R10D,R9D
JNZ 0x0014f276
MOV qword ptr [RBP + -0x48],R15
LEA R9,[R15 + 0x1]
MOV qword ptr [RBP + -0x40],R9
MOV R9,qword ptr [RBP + -0x50]
MOV R12D,R9D
AND R12D,R11D
MOV R15,qword ptr [RBP + -0x38]
AND R11D,R15D
CMP R12,qword ptr [RBP + -0x40]
CMOVC R11D,R12D
AND R9D,EDI
AND EDI,R15D
CMP R9,qword ptr [RBP + -0x40]
CMOVC EDI,R9D
MOV R9D,0xffffffff
CMP R11D,EDI
JNZ 0x0014f247
MOV EDI,R11D
CMP qword ptr [RBP + -0x48],RDI
JNZ 0x0014f2a1
MOV R9D,R10D
LAB_0014f247:
MOVUPS XMM0,xmmword ptr [R8]
MOVUPS xmmword ptr [RSI],XMM0
MOV ECX,dword ptr [RDX]
MOV EDI,EAX
LAB_0014f252:
MOV ESI,EDI
SHL RSI,0x4
MOV EDI,dword ptr [R13 + RSI*0x1]
CMP EDI,R9D
JNZ 0x0014f252
ADD R13,RSI
MOV dword ptr [R13],ECX
MOV dword ptr [RDX],EAX
JMP 0x0014f2c0
LAB_0014f26d:
MOVUPS XMM0,xmmword ptr [R8]
MOVUPS xmmword ptr [RSI],XMM0
JMP 0x0014f2c4
LAB_0014f276:
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS xmmword ptr [RSI],XMM0
MOVUPS XMM0,xmmword ptr [R8]
MOVUPS xmmword ptr [RDX],XMM0
MOV RDI,qword ptr [RBP + -0x30]
LAB_0014f287:
MOV ECX,R9D
SHL RCX,0x4
MOV R9D,dword ptr [R13 + RCX*0x1]
CMP R9D,R10D
JNZ 0x0014f287
ADD R13,RCX
MOV dword ptr [R13],EAX
JMP 0x0014f2c4
LAB_0014f2a1:
MOVUPS XMM0,xmmword ptr [R8]
MOVUPS xmmword ptr [RSI],XMM0
LAB_0014f2a8:
MOV EDX,R10D
SHL RDX,0x4
MOV R10D,dword ptr [R13 + RDX*0x1]
CMP R10D,ECX
JNZ 0x0014f2a8
ADD R13,RDX
MOV dword ptr [R13],EAX
LAB_0014f2c0:
MOV RDI,qword ptr [RBP + -0x30]
LAB_0014f2c4:
CALL 0x0015101b
MOV RAX,qword ptr [R14 + 0x60]
TEST RAX,RAX
JZ 0x0014f2d7
MOV RDI,RBX
CALL RAX
LAB_0014f2d7:
XOR R15D,R15D
LAB_0014f2da:
MOV EAX,R15D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_hash_delete(long *param_1,long param_2)
{
long *plVar1;
long lVar2;
uint uVar3;
int8 uVar4;
uint uVar5;
uint uVar6;
long lVar7;
ulong uVar8;
ulong uVar9;
uint uVar10;
uint uVar11;
uint *puVar12;
uint *puVar13;
uint *puVar14;
uint uVar15;
uint uVar16;
ulong uVar18;
uint uVar19;
ulong uVar20;
int8 unaff_R15;
long local_60;
long local_58;
ulong local_50;
ulong local_48;
ulong local_40;
long *local_38;
ulong uVar17;
uVar9 = CONCAT71((int7)((ulong)unaff_R15 >> 8),1);
if (param_1[3] != 0) {
local_40 = param_1[2];
lVar2 = param_1[5];
if ((code *)param_1[10] == (code *)0x0) {
local_60 = param_1[1];
lVar7 = *param_1 + param_2;
}
else {
lVar7 = (*(code *)param_1[10])(param_2,&local_60,0);
}
uVar5 = (*(code *)param_1[0xb])(param_1[0xd],lVar7,local_60);
lVar7 = local_40 + 0xffffffff;
uVar10 = (uint)lVar7;
uVar15 = (int)(local_40 >> 1) - 1;
uVar17 = (ulong)uVar15;
uVar8 = (ulong)(uVar5 & uVar15);
if ((ulong)(uVar10 & uVar5) < (ulong)param_1[3]) {
uVar8 = (ulong)(uVar10 & uVar5);
}
puVar13 = (uint *)(uVar8 * 0x10 + lVar2);
if (*(long *)(lVar2 + 8 + uVar8 * 0x10) == param_2) {
puVar12 = (uint *)0x0;
}
else {
do {
puVar12 = puVar13;
uVar8 = (ulong)*puVar12;
if (uVar8 == 0xffffffff) goto LAB_0014f2da;
puVar13 = (uint *)(uVar8 * 0x10 + lVar2);
} while (*(long *)(lVar2 + 8 + uVar8 * 0x10) != param_2);
}
uVar9 = param_1[3] - 1;
param_1[3] = uVar9;
if (uVar9 < (ulong)param_1[2] >> 1) {
param_1[2] = (ulong)param_1[2] >> 1;
}
puVar14 = (uint *)(uVar9 * 0x10 + lVar2);
uVar5 = *puVar13;
uVar6 = (uint)uVar8;
if (puVar12 == (uint *)0x0) {
if (uVar5 != 0xffffffff) {
puVar12 = (uint *)(lVar2 + (ulong)uVar5 * 0x10);
uVar6 = puVar12[1];
uVar3 = puVar12[2];
uVar11 = puVar12[3];
*puVar13 = *puVar12;
puVar13[1] = uVar6;
puVar13[2] = uVar3;
puVar13[3] = uVar11;
puVar13 = (uint *)((ulong)uVar5 * 0x10 + lVar2);
uVar6 = uVar5;
}
}
else {
*puVar12 = uVar5;
}
plVar1 = param_1 + 5;
if (puVar13 != puVar14) {
uVar5 = puVar14[1];
uVar8 = param_1[3];
uVar19 = (int)param_1[2] - 1;
uVar11 = uVar19 & uVar5;
uVar16 = (int)((ulong)param_1[2] >> 1) - 1;
uVar3 = uVar16 & uVar5;
if (uVar11 < uVar8) {
uVar3 = uVar11;
}
uVar18 = (ulong)uVar3;
puVar12 = (uint *)(uVar18 * 0x10 + lVar2);
local_58 = lVar7;
local_40 = uVar17;
if (puVar12 == puVar13) {
uVar5 = puVar14[1];
uVar10 = puVar14[2];
uVar15 = puVar14[3];
*puVar13 = *puVar14;
puVar13[1] = uVar5;
puVar13[2] = uVar10;
puVar13[3] = uVar15;
}
else {
uVar11 = puVar12[1];
uVar20 = (ulong)(uVar19 & uVar11);
uVar17 = (ulong)(uVar16 & uVar11);
if (uVar20 < uVar8) {
uVar17 = uVar20;
}
local_38 = plVar1;
if (uVar3 == (uint)uVar17) {
local_48 = uVar8 + 1;
uVar16 = uVar5 & uVar15;
if ((uVar10 & uVar5) < local_48) {
uVar16 = uVar10 & uVar5;
}
uVar5 = uVar11 & uVar15;
if ((uVar10 & uVar11) < local_48) {
uVar5 = uVar10 & uVar11;
}
uVar10 = 0xffffffff;
local_50 = uVar8;
if ((uVar16 == uVar5) && (uVar10 = uVar3, uVar8 != uVar16)) {
uVar5 = puVar14[1];
uVar10 = puVar14[2];
uVar15 = puVar14[3];
*puVar13 = *puVar14;
puVar13[1] = uVar5;
puVar13[2] = uVar10;
puVar13[3] = uVar15;
do {
lVar7 = uVar18 * 0x10;
uVar5 = *(uint *)(lVar2 + lVar7);
uVar18 = (ulong)uVar5;
} while (uVar5 != (uint)uVar9);
*(uint *)(lVar2 + lVar7) = uVar6;
}
else {
uVar5 = puVar14[1];
uVar15 = puVar14[2];
uVar3 = puVar14[3];
*puVar13 = *puVar14;
puVar13[1] = uVar5;
puVar13[2] = uVar15;
puVar13[3] = uVar3;
uVar5 = uVar6;
do {
uVar9 = (ulong)uVar5;
uVar5 = *(uint *)(lVar2 + uVar9 * 0x10);
} while (uVar5 != uVar10);
*(uint *)(lVar2 + uVar9 * 0x10) = *puVar12;
*puVar12 = uVar6;
}
}
else {
uVar4 = *(int8 *)(puVar12 + 2);
*(int8 *)puVar13 = *(int8 *)puVar12;
*(int8 *)(puVar13 + 2) = uVar4;
uVar5 = puVar14[1];
uVar10 = puVar14[2];
uVar15 = puVar14[3];
*puVar12 = *puVar14;
puVar12[1] = uVar5;
puVar12[2] = uVar10;
puVar12[3] = uVar15;
do {
lVar7 = uVar17 * 0x10;
uVar5 = *(uint *)(lVar2 + lVar7);
uVar17 = (ulong)uVar5;
} while (uVar5 != uVar3);
*(uint *)(lVar2 + lVar7) = uVar6;
}
}
}
pop_dynamic(plVar1);
if ((code *)param_1[0xc] != (code *)0x0) {
(*(code *)param_1[0xc])(param_2);
}
uVar9 = 0;
}
LAB_0014f2da:
return uVar9 & 0xffffffff;
}
|
|
10,842 |
my_numcells_eucjpms
|
eloqsql/strings/ctype-eucjpms.c
|
static
size_t my_numcells_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *str_end)
{
size_t clen;
const uchar *b= (const uchar *) str;
const uchar *e= (const uchar *) str_end;
for (clen= 0; b < e; )
{
if (*b == 0x8E)
{
clen++;
b+= 2;
}
else if (*b == 0x8F)
{
clen+= 2;
b+= 3;
}
else if (*b & 0x80)
{
clen+= 2;
b+= 2;
}
else
{
clen++;
b++;
}
}
return clen;
}
|
O0
|
c
|
my_numcells_eucjpms:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x99222
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x8e, %eax
jne 0x991ae
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x9921d
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x8f, %eax
jne 0x991d6
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
jmp 0x9921b
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x99201
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x99219
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9921b
jmp 0x9921d
jmp 0x99178
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
|
my_numcells_eucjpms:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov [rbp+var_20], 0
loc_99178:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb loc_99222
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
cmp eax, 8Eh
jnz short loc_991AE
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
jmp short loc_9921D
loc_991AE:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
cmp eax, 8Fh
jnz short loc_991D6
mov rax, [rbp+var_20]
add rax, 2
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 3
mov [rbp+var_28], rax
jmp short loc_9921B
loc_991D6:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_99201
mov rax, [rbp+var_20]
add rax, 2
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
jmp short loc_99219
loc_99201:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_99219:
jmp short $+2
loc_9921B:
jmp short $+2
loc_9921D:
jmp loc_99178
loc_99222:
mov rax, [rbp+var_20]
pop rbp
retn
|
long long my_numcells_eucjpms(long long a1, _BYTE *a2, unsigned long long a3)
{
long long v5; // [rsp+10h] [rbp-20h]
v5 = 0LL;
while ( (unsigned long long)a2 < a3 )
{
if ( (unsigned __int8)*a2 == 142 )
{
++v5;
a2 += 2;
}
else if ( (unsigned __int8)*a2 == 143 )
{
v5 += 2LL;
a2 += 3;
}
else if ( (*a2 & 0x80) != 0 )
{
v5 += 2LL;
a2 += 2;
}
else
{
++v5;
++a2;
}
}
return v5;
}
|
my_numcells_eucjpms:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x20],0x0
LAB_00199178:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00199222
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x8e
JNZ 0x001991ae
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0019921d
LAB_001991ae:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x8f
JNZ 0x001991d6
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x3
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0019921b
LAB_001991d6:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x00199201
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00199219
LAB_00199201:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_00199219:
JMP 0x0019921b
LAB_0019921b:
JMP 0x0019921d
LAB_0019921d:
JMP 0x00199178
LAB_00199222:
MOV RAX,qword ptr [RBP + -0x20]
POP RBP
RET
|
long my_numcells_eucjpms(int8 param_1,byte *param_2,byte *param_3)
{
byte *local_30;
long local_28;
local_28 = 0;
local_30 = param_2;
while (local_30 < param_3) {
if (*local_30 == 0x8e) {
local_28 = local_28 + 1;
local_30 = local_30 + 2;
}
else if (*local_30 == 0x8f) {
local_28 = local_28 + 2;
local_30 = local_30 + 3;
}
else if ((*local_30 & 0x80) == 0) {
local_28 = local_28 + 1;
local_30 = local_30 + 1;
}
else {
local_28 = local_28 + 2;
local_30 = local_30 + 2;
}
}
return local_28;
}
|
|
10,843 |
allocate_head
|
eloqsql/storage/maria/ma_bitmap.c
|
static my_bool allocate_head(MARIA_FILE_BITMAP *bitmap, uint size,
MARIA_BITMAP_BLOCK *block)
{
uint min_bits= size_to_head_pattern(bitmap, size);
uchar *data, *end;
uchar *best_data= 0;
uint best_bits= (uint) -1, UNINIT_VAR(best_pos);
my_bool first_pattern= 0; /* if doing insert_order */
my_bool first_found= 1;
MARIA_SHARE *share= bitmap->share;
my_bool insert_order=
MY_TEST(share->base.extra_options & MA_EXTRA_OPTIONS_INSERT_ORDER);
DBUG_ENTER("allocate_head");
DBUG_ASSERT(size <= FULL_PAGE_SIZE(share));
end= bitmap->map + bitmap->used_size;
if (insert_order && bitmap->page == share->last_insert_bitmap)
{
uint last_insert_page= share->last_insert_page;
uint byte= 6 * (last_insert_page / 16);
first_pattern= last_insert_page % 16;
data= bitmap->map+byte;
first_found= 0; /* Don't update full_head_size */
DBUG_ASSERT(data <= end);
}
else
data= bitmap->map + (bitmap->full_head_size/6)*6;
for (; data < end; data+= 6, first_pattern= 0)
{
ulonglong bits= uint6korr(data); /* 6 bytes = 6*8/3= 16 patterns */
uint i;
/*
Skip common patterns
We can skip empty pages (if we already found a match) or
anything matching the following pattern as this will be either
a full page or a tail page
*/
if ((!bits && best_data) ||
((bits & 04444444444444444LL) == 04444444444444444LL))
continue;
for (i= first_pattern, bits >>= (3 * first_pattern); i < 16 ;
i++, bits >>= 3)
{
uint pattern= (uint) (bits & 7);
if (pattern <= 3) /* Room for more data */
{
if (first_found)
{
first_found= 0;
bitmap->full_head_size= (uint)(data - bitmap->map);
}
}
if (pattern <= min_bits)
{
/* There is enough space here, check if we have found better */
if ((int) pattern > (int) best_bits)
{
/*
There is more than enough space here and it's better than what
we have found so far. Remember it, as we will choose it if we
don't find anything in this bitmap page.
*/
best_bits= pattern;
best_data= data;
best_pos= i;
if (pattern == min_bits || bitmap->return_first_match)
goto found; /* Best possible match */
}
}
}
}
if (!best_data) /* Found no place */
{
if (data >= bitmap->map + bitmap->total_size)
DBUG_RETURN(1); /* No space in bitmap */
DBUG_ASSERT(uint6korr(data) == 0);
/* Allocate data at end of bitmap */
bitmap->used_size= (uint) (data - bitmap->map) + 6;
best_data= data;
best_pos= best_bits= 0;
}
else
{
/*
This is not stricly needed as used_size should be alligned on 6,
but for easier debugging lets try to keep it more accurate
*/
uint position= (uint) (best_data - bitmap->map) + 6;
set_if_bigger(bitmap->used_size, position);
}
DBUG_ASSERT(bitmap->used_size <= bitmap->total_size);
found:
if (insert_order)
{
share->last_insert_page=
((uint) (best_data - bitmap->map)) / 6 * 16 + best_pos;
share->last_insert_bitmap= bitmap->page;
}
fill_block(bitmap, block, best_data, best_pos, best_bits, FULL_HEAD_PAGE);
DBUG_RETURN(0);
}
|
O0
|
c
|
allocate_head:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x44aa0
movl %eax, -0x24(%rbp)
movq $0x0, -0x40(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movb $0x0, -0x49(%rbp)
movb $0x1, -0x4a(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movl 0x428(%rax), %edx
andl $0x2, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0x59(%rbp)
jmp 0x4472c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x24(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movsbl -0x59(%rbp), %eax
cmpl $0x0, %eax
je 0x4479c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x58(%rbp), %rcx
cmpq 0xc30(%rcx), %rax
jne 0x4479c
movq -0x58(%rbp), %rax
movl 0xc28(%rax), %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
shrl $0x4, %eax
imull $0x6, %eax, %eax
movl %eax, -0x64(%rbp)
movl -0x60(%rbp), %eax
andl $0xf, %eax
movb %al, -0x49(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x64(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x4a(%rbp)
jmp 0x4479a
jmp 0x447d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl $0x6, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x88(%rbp), %rax
imull $0x6, %ecx, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x447d2
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x448ec
movq -0x30(%rbp), %rdi
callq 0x42870
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
jne 0x447fb
cmpq $0x0, -0x40(%rbp)
jne 0x44818
movabsq $0x924924924924, %rax # imm = 0x924924924924
andq -0x70(%rbp), %rax
movabsq $0x924924924924, %rcx # imm = 0x924924924924
cmpq %rcx, %rax
jne 0x4481d
jmp 0x448d7
movsbl -0x49(%rbp), %eax
movl %eax, -0x74(%rbp)
movsbl -0x49(%rbp), %eax
imull $0x3, %eax, %ecx
movq -0x70(%rbp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x70(%rbp)
cmpl $0x10, -0x74(%rbp)
jae 0x448d5
movq -0x70(%rbp), %rax
andq $0x7, %rax
movl %eax, -0x78(%rbp)
cmpl $0x3, -0x78(%rbp)
ja 0x44877
cmpb $0x0, -0x4a(%rbp)
je 0x44875
movb $0x0, -0x4a(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
jmp 0x44877
movl -0x78(%rbp), %eax
cmpl -0x24(%rbp), %eax
ja 0x448b9
movl -0x78(%rbp), %eax
cmpl -0x44(%rbp), %eax
jle 0x448b7
movl -0x78(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x74(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x78(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x448b0
movq -0x10(%rbp), %rax
movsbl 0x22(%rax), %eax
cmpl $0x0, %eax
je 0x448b5
jmp 0x44988
jmp 0x448b7
jmp 0x448b9
jmp 0x448bb
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
movq -0x70(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x70(%rbp)
jmp 0x44838
jmp 0x448d7
movq -0x30(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x49(%rbp)
jmp 0x447d2
cmpq $0x0, -0x40(%rbp)
jne 0x44953
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movl 0x128(%rdx), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x4491c
jmp 0x44913
movb $0x1, -0x1(%rbp)
jmp 0x449ed
jmp 0x4491e
jmp 0x44920
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
addl $0x6, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
jmp 0x44982
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
addl $0x6, %eax
movl %eax, -0x7c(%rbp)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
cmpl -0x7c(%rbp), %eax
jae 0x4497e
movl -0x7c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x44980
jmp 0x44982
jmp 0x44984
jmp 0x44986
jmp 0x44988
cmpb $0x0, -0x59(%rbp)
je 0x449cb
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl $0x6, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
shll $0x4, %ecx
addl -0x48(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0xc28(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0xc30(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl -0x48(%rbp), %ecx
movl -0x44(%rbp), %r8d
movl $0x4, %r9d
callq 0x44b10
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
|
allocate_head:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
call size_to_head_pattern
mov [rbp+var_24], eax
mov [rbp+var_40], 0
mov [rbp+var_44], 0FFFFFFFFh
mov eax, [rbp+var_48]
mov [rbp+var_48], eax
mov [rbp+var_49], 0
mov [rbp+var_4A], 1
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
mov edx, [rax+428h]
and edx, 2
xor eax, eax
mov ecx, 1
cmp edx, 0
cmovnz eax, ecx
mov [rbp+var_59], al
jmp short $+2
loc_4472C:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov ecx, [rcx+24h]
add rax, rcx
mov [rbp+var_38], rax
movsx eax, [rbp+var_59]
cmp eax, 0
jz short loc_4479C
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rcx, [rbp+var_58]
cmp rax, [rcx+0C30h]
jnz short loc_4479C
mov rax, [rbp+var_58]
mov eax, [rax+0C28h]
mov [rbp+var_60], eax
mov eax, [rbp+var_60]
shr eax, 4
imul eax, 6
mov [rbp+var_64], eax
mov eax, [rbp+var_60]
and eax, 0Fh
mov [rbp+var_49], al
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov ecx, [rbp+var_64]
add rax, rcx
mov [rbp+var_30], rax
mov [rbp+var_4A], 0
jmp short $+2
loc_4479A:
jmp short loc_447D0
loc_4479C:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_88], rax
mov rax, [rbp+var_10]
mov eax, [rax+28h]
mov ecx, 6
xor edx, edx
div ecx
mov ecx, eax
mov rax, [rbp+var_88]
imul ecx, 6
mov ecx, ecx
add rax, rcx
mov [rbp+var_30], rax
loc_447D0:
jmp short $+2
loc_447D2:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jnb loc_448EC
mov rdi, [rbp+var_30]
call uint6korr
mov [rbp+var_70], rax
cmp [rbp+var_70], 0
jnz short loc_447FB
cmp [rbp+var_40], 0
jnz short loc_44818
loc_447FB:
mov rax, 924924924924h
and rax, [rbp+var_70]
mov rcx, 924924924924h
cmp rax, rcx
jnz short loc_4481D
loc_44818:
jmp loc_448D7
loc_4481D:
movsx eax, [rbp+var_49]
mov [rbp+var_74], eax
movsx eax, [rbp+var_49]
imul ecx, eax, 3
mov rax, [rbp+var_70]
mov ecx, ecx
shr rax, cl
mov [rbp+var_70], rax
loc_44838:
cmp [rbp+var_74], 10h
jnb loc_448D5
mov rax, [rbp+var_70]
and rax, 7
mov [rbp+var_78], eax
cmp [rbp+var_78], 3
ja short loc_44877
cmp [rbp+var_4A], 0
jz short loc_44875
mov [rbp+var_4A], 0
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+28h], ecx
loc_44875:
jmp short $+2
loc_44877:
mov eax, [rbp+var_78]
cmp eax, [rbp+var_24]
ja short loc_448B9
mov eax, [rbp+var_78]
cmp eax, [rbp+var_44]
jle short loc_448B7
mov eax, [rbp+var_78]
mov [rbp+var_44], eax
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
mov eax, [rbp+var_74]
mov [rbp+var_48], eax
mov eax, [rbp+var_78]
cmp eax, [rbp+var_24]
jz short loc_448B0
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+22h]
cmp eax, 0
jz short loc_448B5
loc_448B0:
jmp loc_44988
loc_448B5:
jmp short $+2
loc_448B7:
jmp short $+2
loc_448B9:
jmp short $+2
loc_448BB:
mov eax, [rbp+var_74]
add eax, 1
mov [rbp+var_74], eax
mov rax, [rbp+var_70]
shr rax, 3
mov [rbp+var_70], rax
jmp loc_44838
loc_448D5:
jmp short $+2
loc_448D7:
mov rax, [rbp+var_30]
add rax, 6
mov [rbp+var_30], rax
mov [rbp+var_49], 0
jmp loc_447D2
loc_448EC:
cmp [rbp+var_40], 0
jnz short loc_44953
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
mov rdx, [rbp+var_10]
mov edx, [rdx+128h]
add rcx, rdx
cmp rax, rcx
jb short loc_4491C
jmp short $+2
loc_44913:
mov [rbp+var_1], 1
jmp loc_449ED
loc_4491C:
jmp short $+2
loc_4491E:
jmp short $+2
loc_44920:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rax, rcx
mov ecx, eax
add ecx, 6
mov rax, [rbp+var_10]
mov [rax+24h], ecx
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
mov [rbp+var_44], 0
mov [rbp+var_48], 0
jmp short loc_44982
loc_44953:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rax, rcx
add eax, 6
mov [rbp+var_7C], eax
mov rax, [rbp+var_10]
mov eax, [rax+24h]
cmp eax, [rbp+var_7C]
jnb short loc_4497E
mov ecx, [rbp+var_7C]
mov rax, [rbp+var_10]
mov [rax+24h], ecx
loc_4497E:
jmp short $+2
loc_44980:
jmp short $+2
loc_44982:
jmp short $+2
loc_44984:
jmp short $+2
loc_44986:
jmp short $+2
loc_44988:
cmp [rbp+var_59], 0
jz short loc_449CB
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rax, rcx
mov ecx, 6
xor edx, edx
div ecx
mov ecx, eax
shl ecx, 4
add ecx, [rbp+var_48]
mov rax, [rbp+var_58]
mov [rax+0C28h], ecx
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_58]
mov [rax+0C30h], rcx
loc_449CB:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_40]
mov ecx, [rbp+var_48]
mov r8d, [rbp+var_44]
mov r9d, 4
call fill_block
mov [rbp+var_1], 0
loc_449ED:
mov al, [rbp+var_1]
add rsp, 90h
pop rbp
retn
|
char allocate_head(long long *a1, unsigned int a2, long long a3)
{
unsigned int v4; // [rsp+14h] [rbp-7Ch]
unsigned int v5; // [rsp+18h] [rbp-78h]
unsigned int v6; // [rsp+1Ch] [rbp-74h]
unsigned long long v7; // [rsp+20h] [rbp-70h]
unsigned long long v8; // [rsp+20h] [rbp-70h]
unsigned int v9; // [rsp+30h] [rbp-60h]
bool v10; // [rsp+37h] [rbp-59h]
long long v11; // [rsp+38h] [rbp-58h]
char v12; // [rsp+46h] [rbp-4Ah]
char v13; // [rsp+47h] [rbp-49h]
unsigned int v14; // [rsp+48h] [rbp-48h]
int v15; // [rsp+4Ch] [rbp-44h]
unsigned int *v16; // [rsp+50h] [rbp-40h]
unsigned long long v17; // [rsp+58h] [rbp-38h]
unsigned int *v18; // [rsp+60h] [rbp-30h]
unsigned int v19; // [rsp+6Ch] [rbp-24h]
v19 = size_to_head_pattern(a1, a2);
v16 = 0LL;
v15 = -1;
v13 = 0;
v12 = 1;
v11 = *a1;
v10 = (*(_DWORD *)(*a1 + 1064) & 2) != 0;
v17 = *((unsigned int *)a1 + 9) + a1[1];
if ( (*(_DWORD *)(*a1 + 1064) & 2) != 0 && a1[2] == *(_QWORD *)(v11 + 3120) )
{
v9 = *(_DWORD *)(v11 + 3112);
v13 = v9 & 0xF;
v18 = (unsigned int *)(6 * (v9 >> 4) + a1[1]);
v12 = 0;
}
else
{
v18 = (unsigned int *)(6 * (*((_DWORD *)a1 + 10) / 6u) + a1[1]);
}
while ( (unsigned long long)v18 < v17 )
{
v7 = uint6korr(v18);
if ( (v7 || !v16) && (v7 & 0x924924924924LL) != 0x924924924924LL )
{
v6 = v13;
v8 = v7 >> (3 * v13);
while ( v6 < 0x10 )
{
v5 = v8 & 7;
if ( v5 <= 3 && v12 )
{
v12 = 0;
*((_DWORD *)a1 + 10) = (_DWORD)v18 - a1[1];
}
if ( v5 <= v19 && (int)v5 > v15 )
{
v15 = v8 & 7;
v16 = v18;
v14 = v6;
if ( v5 == v19 || *((_BYTE *)a1 + 34) )
goto LABEL_28;
}
++v6;
v8 >>= 3;
}
}
v18 = (unsigned int *)((char *)v18 + 6);
v13 = 0;
}
if ( v16 )
{
v4 = (_DWORD)v16 - a1[1] + 6;
if ( *((_DWORD *)a1 + 9) < v4 )
*((_DWORD *)a1 + 9) = v4;
}
else
{
if ( (unsigned long long)v18 >= (unsigned long long)*((unsigned int *)a1 + 74) + a1[1] )
return 1;
*((_DWORD *)a1 + 9) = (_DWORD)v18 - a1[1] + 6;
v16 = v18;
v15 = 0;
v14 = 0;
}
LABEL_28:
if ( v10 )
{
*(_DWORD *)(v11 + 3112) = v14 + 16 * (((unsigned int)v16 - (unsigned int)a1[1]) / 6);
*(_QWORD *)(v11 + 3120) = a1[2];
}
fill_block(a1, a3, v16, v14, (unsigned int)v15, 4LL);
return 0;
}
|
allocate_head:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x00144aa0
MOV dword ptr [RBP + -0x24],EAX
MOV qword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x44],0xffffffff
MOV EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x48],EAX
MOV byte ptr [RBP + -0x49],0x0
MOV byte ptr [RBP + -0x4a],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV EDX,dword ptr [RAX + 0x428]
AND EDX,0x2
XOR EAX,EAX
MOV ECX,0x1
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV byte ptr [RBP + -0x59],AL
JMP 0x0014472c
LAB_0014472c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x24]
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOVSX EAX,byte ptr [RBP + -0x59]
CMP EAX,0x0
JZ 0x0014479c
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RCX + 0xc30]
JNZ 0x0014479c
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0xc28]
MOV dword ptr [RBP + -0x60],EAX
MOV EAX,dword ptr [RBP + -0x60]
SHR EAX,0x4
IMUL EAX,EAX,0x6
MOV dword ptr [RBP + -0x64],EAX
MOV EAX,dword ptr [RBP + -0x60]
AND EAX,0xf
MOV byte ptr [RBP + -0x49],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x64]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x4a],0x0
JMP 0x0014479a
LAB_0014479a:
JMP 0x001447d0
LAB_0014479c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x28]
MOV ECX,0x6
XOR EDX,EDX
DIV ECX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x88]
IMUL ECX,ECX,0x6
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LAB_001447d0:
JMP 0x001447d2
LAB_001447d2:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x001448ec
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00142870
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x70],0x0
JNZ 0x001447fb
CMP qword ptr [RBP + -0x40],0x0
JNZ 0x00144818
LAB_001447fb:
MOV RAX,0x924924924924
AND RAX,qword ptr [RBP + -0x70]
MOV RCX,0x924924924924
CMP RAX,RCX
JNZ 0x0014481d
LAB_00144818:
JMP 0x001448d7
LAB_0014481d:
MOVSX EAX,byte ptr [RBP + -0x49]
MOV dword ptr [RBP + -0x74],EAX
MOVSX EAX,byte ptr [RBP + -0x49]
IMUL ECX,EAX,0x3
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,ECX
SHR RAX,CL
MOV qword ptr [RBP + -0x70],RAX
LAB_00144838:
CMP dword ptr [RBP + -0x74],0x10
JNC 0x001448d5
MOV RAX,qword ptr [RBP + -0x70]
AND RAX,0x7
MOV dword ptr [RBP + -0x78],EAX
CMP dword ptr [RBP + -0x78],0x3
JA 0x00144877
CMP byte ptr [RBP + -0x4a],0x0
JZ 0x00144875
MOV byte ptr [RBP + -0x4a],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],ECX
LAB_00144875:
JMP 0x00144877
LAB_00144877:
MOV EAX,dword ptr [RBP + -0x78]
CMP EAX,dword ptr [RBP + -0x24]
JA 0x001448b9
MOV EAX,dword ptr [RBP + -0x78]
CMP EAX,dword ptr [RBP + -0x44]
JLE 0x001448b7
MOV EAX,dword ptr [RBP + -0x78]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV EAX,dword ptr [RBP + -0x74]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x78]
CMP EAX,dword ptr [RBP + -0x24]
JZ 0x001448b0
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x22]
CMP EAX,0x0
JZ 0x001448b5
LAB_001448b0:
JMP 0x00144988
LAB_001448b5:
JMP 0x001448b7
LAB_001448b7:
JMP 0x001448b9
LAB_001448b9:
JMP 0x001448bb
LAB_001448bb:
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOV dword ptr [RBP + -0x74],EAX
MOV RAX,qword ptr [RBP + -0x70]
SHR RAX,0x3
MOV qword ptr [RBP + -0x70],RAX
JMP 0x00144838
LAB_001448d5:
JMP 0x001448d7
LAB_001448d7:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x6
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x49],0x0
JMP 0x001447d2
LAB_001448ec:
CMP qword ptr [RBP + -0x40],0x0
JNZ 0x00144953
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RDX + 0x128]
ADD RCX,RDX
CMP RAX,RCX
JC 0x0014491c
JMP 0x00144913
LAB_00144913:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001449ed
LAB_0014491c:
JMP 0x0014491e
LAB_0014491e:
JMP 0x00144920
LAB_00144920:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RAX,RCX
MOV ECX,EAX
ADD ECX,0x6
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x24],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x44],0x0
MOV dword ptr [RBP + -0x48],0x0
JMP 0x00144982
LAB_00144953:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RAX,RCX
ADD EAX,0x6
MOV dword ptr [RBP + -0x7c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x24]
CMP EAX,dword ptr [RBP + -0x7c]
JNC 0x0014497e
MOV ECX,dword ptr [RBP + -0x7c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x24],ECX
LAB_0014497e:
JMP 0x00144980
LAB_00144980:
JMP 0x00144982
LAB_00144982:
JMP 0x00144984
LAB_00144984:
JMP 0x00144986
LAB_00144986:
JMP 0x00144988
LAB_00144988:
CMP byte ptr [RBP + -0x59],0x0
JZ 0x001449cb
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RAX,RCX
MOV ECX,0x6
XOR EDX,EDX
DIV ECX
MOV ECX,EAX
SHL ECX,0x4
ADD ECX,dword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX + 0xc28],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX + 0xc30],RCX
LAB_001449cb:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x48]
MOV R8D,dword ptr [RBP + -0x44]
MOV R9D,0x4
CALL 0x00144b10
MOV byte ptr [RBP + -0x1],0x0
LAB_001449ed:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x90
POP RBP
RET
|
int1 allocate_head(long *param_1,int4 param_2,int8 param_3)
{
long lVar1;
long lVar2;
bool bVar3;
uint uVar4;
uint uVar5;
uint uVar6;
bool bVar7;
uint local_7c;
ulong local_78;
byte local_51;
uint local_50;
uint local_4c;
ulong local_48;
ulong local_38;
uVar4 = size_to_head_pattern(param_1,param_2);
local_48 = 0;
local_4c = 0xffffffff;
local_51 = 0;
bVar3 = true;
lVar1 = *param_1;
bVar7 = (*(uint *)(lVar1 + 0x428) & 2) != 0;
lVar2 = param_1[1];
uVar6 = *(uint *)((long)param_1 + 0x24);
if ((bVar7) && (param_1[2] == *(long *)(lVar1 + 0xc30))) {
local_51 = (byte)*(uint *)(lVar1 + 0xc28) & 0xf;
local_38 = param_1[1] + (ulong)((*(uint *)(lVar1 + 0xc28) >> 4) * 6);
bVar3 = false;
}
else {
local_38 = param_1[1] + (ulong)((*(uint *)(param_1 + 5) / 6) * 6);
}
for (; local_38 < lVar2 + (ulong)uVar6; local_38 = local_38 + 6) {
local_78 = uint6korr(local_38);
if (((local_78 != 0) || (local_48 == 0)) && ((local_78 & 0x924924924924) != 0x924924924924)) {
local_78 = local_78 >> local_51 * '\x03';
for (local_7c = (uint)(char)local_51; local_7c < 0x10; local_7c = local_7c + 1) {
uVar5 = (uint)local_78 & 7;
if ((uVar5 < 4) && (bVar3)) {
bVar3 = false;
*(int *)(param_1 + 5) = (int)local_38 - (int)param_1[1];
}
if ((uVar5 <= uVar4) && ((int)local_4c < (int)uVar5)) {
local_48 = local_38;
local_50 = local_7c;
local_4c = uVar5;
if ((uVar5 == uVar4) || (*(char *)((long)param_1 + 0x22) != '\0')) goto LAB_00144988;
}
local_78 = local_78 >> 3;
}
}
local_51 = 0;
}
if (local_48 == 0) {
if (param_1[1] + (ulong)*(uint *)(param_1 + 0x25) <= local_38) {
return 1;
}
*(int *)((long)param_1 + 0x24) = ((int)local_38 - (int)param_1[1]) + 6;
local_48 = local_38;
local_4c = 0;
local_50 = 0;
}
else {
uVar6 = ((int)local_48 - (int)param_1[1]) + 6;
if (*(uint *)((long)param_1 + 0x24) < uVar6) {
*(uint *)((long)param_1 + 0x24) = uVar6;
}
}
LAB_00144988:
if (bVar7) {
*(uint *)(lVar1 + 0xc28) = (int)((local_48 - param_1[1] & 0xffffffff) / 6) * 0x10 + local_50;
*(long *)(lVar1 + 0xc30) = param_1[2];
}
fill_block(param_1,param_3,local_48,local_50,local_4c,4);
return 0;
}
|
|
10,844 |
minja::Parser::parseLogicalOr()
|
monkey531[P]llama/common/./minja.hpp
|
std::shared_ptr<Expression> parseLogicalOr() {
auto left = parseLogicalAnd();
if (!left) throw std::runtime_error("Expected left side of 'logical or' expression");
static std::regex or_tok(R"(or\b)");
auto location = get_location();
while (!consumeToken(or_tok).empty()) {
auto right = parseLogicalAnd();
if (!right) throw std::runtime_error("Expected right side of 'or' expression");
left = std::make_shared<BinaryOpExpr>(location, std::move(left), std::move(right), BinaryOpExpr::Op::Or);
}
return left;
}
|
O0
|
cpp
|
minja::Parser::parseLogicalOr():
subq $0xb8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0x9d6f0
movq 0x28(%rsp), %rdi
callq 0x77a80
testb $0x1, %al
jne 0x9d068
movl $0x10, %edi
callq 0x50540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x12f773(%rip), %rsi # 0x1cc77b
callq 0x50340
jmp 0x9d00f
movq 0x10(%rsp), %rdi
movq 0x1b6f95(%rip), %rsi # 0x253fb0
movq 0x1b6f56(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0x9d2a1
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x50c40
jmp 0x9d28a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x9d28a
cmpb $0x0, 0x1b7ed1(%rip) # 0x254f40
jne 0x9d0c2
leaq 0x1b7ec8(%rip), %rdi # 0x254f40
callq 0x504b0
cmpl $0x0, %eax
je 0x9d0c2
leaq 0x1b7e97(%rip), %rdi # 0x254f20
leaq 0x12f719(%rip), %rsi # 0x1cc7a9
movl $0x10, %edx
callq 0x76c30
jmp 0x9d09c
leaq -0x263c3(%rip), %rdi # 0x76ce0
leaq 0x1b7e76(%rip), %rsi # 0x254f20
leaq 0x1b77b7(%rip), %rdx # 0x254868
callq 0x50c20
leaq 0x1b7e83(%rip), %rdi # 0x254f40
callq 0x50820
movq 0x20(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x76db0
jmp 0x9d0d3
jmp 0x9d0d5
movq 0x20(%rsp), %rsi
leaq 0x1b7e3f(%rip), %rdx # 0x254f20
leaq 0x58(%rsp), %rdi
movl $0x1, %ecx
callq 0x778a0
jmp 0x9d0f2
leaq 0x58(%rsp), %rdi
callq 0x503b0
xorb $-0x1, %al
movb %al, 0xf(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x510c0
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x9d119
jmp 0x9d249
movq 0x20(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x9d6f0
jmp 0x9d12a
leaq 0x48(%rsp), %rdi
callq 0x77a80
testb $0x1, %al
jne 0x9d1ed
movl $0x10, %edi
callq 0x50540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x12f657(%rip), %rsi # 0x1cc7ae
callq 0x50340
jmp 0x9d15e
movq (%rsp), %rdi
movq 0x1b6e47(%rip), %rsi # 0x253fb0
movq 0x1b6e08(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0x9d2a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x1b7dab(%rip), %rdi # 0x254f40
callq 0x505d0
jmp 0x9d28a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x9d267
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x50c40
jmp 0x9d23d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x9d23d
movq 0x28(%rsp), %rdx
movl $0xf, 0x34(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x48(%rsp), %rcx
leaq 0x34(%rsp), %r8
callq 0x9da00
jmp 0x9d215
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x9daa0
leaq 0x38(%rsp), %rdi
callq 0x9dad0
leaq 0x48(%rsp), %rdi
callq 0x77890
jmp 0x9d0d5
leaq 0x48(%rsp), %rdi
callq 0x77890
jmp 0x9d267
movb $0x1, 0xa7(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x7a6d0
testb $0x1, 0xa7(%rsp)
jne 0x9d27d
jmp 0x9d273
leaq 0x78(%rsp), %rdi
callq 0x7a6d0
jmp 0x9d28a
movq 0x28(%rsp), %rdi
callq 0x77890
movq 0x18(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x77890
movq 0x98(%rsp), %rdi
callq 0x50940
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
_ZN5minja6Parser14parseLogicalOrEv:
sub rsp, 0B8h
mov [rsp+0B8h+var_90], rdi
mov rax, rdi
mov [rsp+0B8h+var_A0], rax
mov [rsp+0B8h+var_8], rdi
mov [rsp+0B8h+var_10], rsi
mov rsi, [rsp+0B8h+var_10]
mov [rsp+0B8h+var_98], rsi
mov [rsp+0B8h+var_11], 0
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
mov rdi, [rsp+0B8h+var_90]
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_9D068
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0B8h+var_A8], rax
lea rsi, aExpectedLeftSi; "Expected left side of 'logical or' expr"...
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_9D00F:
mov rdi, [rsp+0B8h+var_A8]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_9D2A1
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
call ___cxa_free_exception
jmp loc_9D28A
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp loc_9D28A
loc_9D068:
cmp cs:_ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11, 0; `guard variable for'minja::Parser::parseLogicalOr(void)::or_tok
jnz short loc_9D0C2
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_acquire
cmp eax, 0
jz short loc_9D0C2
lea rdi, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; minja::Parser::parseLogicalOr(void)::or_tok
lea rsi, aOrB; "or\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
jmp short $+2
loc_9D09C:
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_release
loc_9D0C2:
mov rsi, [rsp+0B8h+var_98]
lea rdi, [rsp+0B8h+var_40]; this
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
jmp short $+2
loc_9D0D3:
jmp short $+2
loc_9D0D5:
mov rsi, [rsp+0B8h+var_98]
lea rdx, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; minja::Parser::parseLogicalOr(void)::or_tok
lea rdi, [rsp+0B8h+var_60]
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
jmp short $+2
loc_9D0F2:
lea rdi, [rsp+0B8h+var_60]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
xor al, 0FFh
mov [rsp+0B8h+var_A9], al
lea rdi, [rsp+0B8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov al, [rsp+0B8h+var_A9]
test al, 1
jnz short loc_9D119
jmp loc_9D249
loc_9D119:
mov rsi, [rsp+0B8h+var_98]
lea rdi, [rsp+0B8h+var_70]; this
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
jmp short $+2
loc_9D12A:
lea rdi, [rsp+0B8h+var_70]
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz loc_9D1ED
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0B8h+var_B8], rax
lea rsi, aExpectedRightS; "Expected right side of 'or' expression"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_9D15E:
mov rdi, [rsp+0B8h+var_B8]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_9D2A1
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp loc_9D28A
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp loc_9D267
mov rdi, [rsp+0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
call ___cxa_free_exception
jmp short loc_9D23D
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp short loc_9D23D
loc_9D1ED:
mov rdx, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_84], 0Fh
lea rdi, [rsp+0B8h+var_80]
lea rsi, [rsp+0B8h+var_40]
lea rcx, [rsp+0B8h+var_70]
lea r8, [rsp+0B8h+var_84]
call _ZSt11make_sharedIN5minja12BinaryOpExprEJRNS0_8LocationESt10shared_ptrINS0_10ExpressionEES6_NS1_2OpEEES4_IT_EDpOT0_; std::make_shared<minja::BinaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op &&)
jmp short $+2
loc_9D215:
mov rdi, [rsp+0B8h+var_90]
lea rsi, [rsp+0B8h+var_80]
call _ZNSt10shared_ptrIN5minja10ExpressionEEaSINS0_12BinaryOpExprEEENSt9enable_ifIXsr13is_assignableIRSt12__shared_ptrIS1_LN9__gnu_cxx12_Lock_policyE2EES_IT_EEE5valueERS2_E4typeEOSC_
lea rdi, [rsp+0B8h+var_80]
call _ZNSt10shared_ptrIN5minja12BinaryOpExprEED2Ev; std::shared_ptr<minja::BinaryOpExpr>::~shared_ptr()
lea rdi, [rsp+0B8h+var_70]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
jmp loc_9D0D5
loc_9D23D:
lea rdi, [rsp+arg_40]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
jmp short loc_9D267
loc_9D249:
mov [rsp+0B8h+var_11], 1
lea rdi, [rsp+0B8h+var_40]; this
call _ZN5minja8LocationD2Ev; minja::Location::~Location()
test [rsp+0B8h+var_11], 1
jnz short loc_9D27D
jmp short loc_9D273
loc_9D267:
lea rdi, [rsp+arg_70]; this
call _ZN5minja8LocationD2Ev; minja::Location::~Location()
jmp short loc_9D28A
loc_9D273:
mov rdi, [rsp+0B8h+var_90]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
loc_9D27D:
mov rax, [rsp+0B8h+var_A0]
add rsp, 0B8h
retn
loc_9D28A:
mov rdi, [rsp+arg_20]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
mov rdi, [rsp+arg_90]
call __Unwind_Resume
loc_9D2A1:
nop word ptr [rax+rax+00000000h]
nop dword ptr [rax+rax+00h]
|
minja::Parser * minja::Parser::parseLogicalOr(minja::Parser *this, long long a2)
{
int v2; // r9d
int v4; // [rsp+0h] [rbp-B8h]
std::runtime_error *v5; // [rsp+0h] [rbp-B8h]
int v6; // [rsp+8h] [rbp-B0h]
char v7; // [rsp+Fh] [rbp-A9h]
int v8; // [rsp+10h] [rbp-A8h]
std::runtime_error *exception; // [rsp+10h] [rbp-A8h]
minja::Parser *v10; // [rsp+18h] [rbp-A0h]
long long v11; // [rsp+20h] [rbp-98h]
int v12; // [rsp+34h] [rbp-84h] BYREF
_BYTE v13[16]; // [rsp+38h] [rbp-80h] BYREF
_QWORD v14[2]; // [rsp+48h] [rbp-70h] BYREF
_BYTE v15[32]; // [rsp+58h] [rbp-60h] BYREF
_BYTE v16[47]; // [rsp+78h] [rbp-40h] BYREF
char v17; // [rsp+A7h] [rbp-11h]
long long v18; // [rsp+A8h] [rbp-10h]
minja::Parser *v19; // [rsp+B0h] [rbp-8h]
v10 = this;
v19 = this;
v18 = a2;
v11 = a2;
v17 = 0;
minja::Parser::parseLogicalAnd(this);
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(this) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'logical or' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
(long long)"or\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]);
}
minja::Parser::get_location((minja::Parser *)v16, a2);
while ( 1 )
{
minja::Parser::consumeToken((long long)v15, v11, (long long)&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11], 1u);
v7 = ~(unsigned __int8)std::string::empty(v15);
std::string::~string(v15);
if ( (v7 & 1) == 0 )
break;
minja::Parser::parseLogicalAnd((minja::Parser *)v14);
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(v14) )
{
v5 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v5, "Expected right side of 'or' expression");
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v12 = 15;
std::make_shared<minja::BinaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(
(unsigned int)v13,
(unsigned int)v16,
(_DWORD)this,
(unsigned int)v14,
(unsigned int)&v12,
v2,
v4,
v6,
v8,
(long long)v10,
v11);
std::shared_ptr<minja::Expression>::operator=<minja::BinaryOpExpr>(this, v13);
std::shared_ptr<minja::BinaryOpExpr>::~shared_ptr(v13);
std::shared_ptr<minja::Expression>::~shared_ptr((long long)v14);
}
v17 = 1;
minja::Location::~Location((minja::Location *)v16);
if ( (v17 & 1) == 0 )
std::shared_ptr<minja::Expression>::~shared_ptr((long long)this);
return v10;
}
|
parseLogicalOr:
SUB RSP,0xb8
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0xb0],RDI
MOV qword ptr [RSP + 0xa8],RSI
MOV RSI,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x20],RSI
MOV byte ptr [RSP + 0xa7],0x0
CALL 0x0019d6f0
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00177a80
TEST AL,0x1
JNZ 0x0019d068
MOV EDI,0x10
CALL 0x00150540
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
LAB_0019d001:
LEA RSI,[0x2cc77b]
CALL 0x00150340
JMP 0x0019d00f
LAB_0019d00f:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_0019d068:
CMP byte ptr [0x00354f40],0x0
JNZ 0x0019d0c2
LEA RDI,[0x354f40]
CALL 0x001504b0
CMP EAX,0x0
JZ 0x0019d0c2
LAB_0019d082:
LEA RDI,[0x354f20]
LEA RSI,[0x2cc7a9]
MOV EDX,0x10
CALL 0x00176c30
JMP 0x0019d09c
LAB_0019d09c:
LEA RDI,[0x176ce0]
LEA RSI,[0x354f20]
LEA RDX,[0x354868]
CALL 0x00150c20
LEA RDI,[0x354f40]
CALL 0x00150820
LAB_0019d0c2:
MOV RSI,qword ptr [RSP + 0x20]
LEA RDI,[RSP + 0x78]
CALL 0x00176db0
JMP 0x0019d0d3
LAB_0019d0d3:
JMP 0x0019d0d5
LAB_0019d0d5:
MOV RSI,qword ptr [RSP + 0x20]
LEA RDX,[0x354f20]
LEA RDI,[RSP + 0x58]
MOV ECX,0x1
CALL 0x001778a0
JMP 0x0019d0f2
LAB_0019d0f2:
LEA RDI,[RSP + 0x58]
CALL 0x001503b0
XOR AL,0xff
MOV byte ptr [RSP + 0xf],AL
LEA RDI,[RSP + 0x58]
CALL 0x001510c0
MOV AL,byte ptr [RSP + 0xf]
TEST AL,0x1
JNZ 0x0019d119
JMP 0x0019d249
LAB_0019d119:
MOV RSI,qword ptr [RSP + 0x20]
LEA RDI,[RSP + 0x48]
CALL 0x0019d6f0
LAB_0019d128:
JMP 0x0019d12a
LAB_0019d12a:
LEA RDI,[RSP + 0x48]
CALL 0x00177a80
TEST AL,0x1
JNZ 0x0019d1ed
MOV EDI,0x10
CALL 0x00150540
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP],RAX
LAB_0019d150:
LEA RSI,[0x2cc7ae]
CALL 0x00150340
JMP 0x0019d15e
LAB_0019d15e:
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_0019d1ed:
MOV RDX,qword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0x34],0xf
LAB_0019d1fa:
LEA RDI,[RSP + 0x38]
LEA RSI,[RSP + 0x78]
LEA RCX,[RSP + 0x48]
LEA R8,[RSP + 0x34]
CALL 0x0019da00
LAB_0019d213:
JMP 0x0019d215
LAB_0019d215:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0x38]
CALL 0x0019daa0
LEA RDI,[RSP + 0x38]
CALL 0x0019dad0
LEA RDI,[RSP + 0x48]
CALL 0x00177890
JMP 0x0019d0d5
LAB_0019d249:
MOV byte ptr [RSP + 0xa7],0x1
LEA RDI,[RSP + 0x78]
CALL 0x0017a6d0
TEST byte ptr [RSP + 0xa7],0x1
JNZ 0x0019d27d
JMP 0x0019d273
LAB_0019d273:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00177890
LAB_0019d27d:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0xb8
RET
|
/* minja::Parser::parseLogicalOr() */
__shared_ptr * minja::Parser::parseLogicalOr(void)
{
bool bVar1;
byte bVar2;
int iVar3;
runtime_error *prVar4;
int8 in_RSI;
__shared_ptr *in_RDI;
Location local_80 [16];
__shared_ptr local_70 [16];
string local_60 [32];
shared_ptr local_40 [47];
byte local_11;
local_11 = 0;
parseLogicalAnd();
bVar1 = std::__shared_ptr::operator_cast_to_bool(in_RDI);
if (!bVar1) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019d001 to 0019d00c has its CatchHandler @ 0019d02c */
std::runtime_error::runtime_error(prVar4,"Expected left side of \'logical or\' expression");
/* try { // try from 0019d00f to 0019d026 has its CatchHandler @ 0019d04f */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
if (parseLogicalOr()::or_tok_abi_cxx11_ == '\0') {
iVar3 = __cxa_guard_acquire(&parseLogicalOr()::or_tok_abi_cxx11_);
if (iVar3 != 0) {
/* try { // try from 0019d082 to 0019d099 has its CatchHandler @ 0019d17a */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
(parseLogicalOr()::or_tok_abi_cxx11_,&DAT_002cc7a9,0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseLogicalOr()::or_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseLogicalOr()::or_tok_abi_cxx11_);
}
}
/* try { // try from 0019d0c2 to 0019d0d0 has its CatchHandler @ 0019d04f */
get_location();
while( true ) {
/* try { // try from 0019d0d5 to 0019d127 has its CatchHandler @ 0019d19f */
consumeToken(local_60,in_RSI,parseLogicalOr()::or_tok_abi_cxx11_,1);
bVar2 = std::__cxx11::string::empty();
std::__cxx11::string::~string(local_60);
if (((bVar2 ^ 0xff) & 1) == 0) {
local_11 = 1;
Location::~Location((Location *)local_40);
if ((local_11 & 1) == 0) {
std::shared_ptr<minja::Expression>::~shared_ptr((shared_ptr<minja::Expression> *)in_RDI);
}
return in_RDI;
}
parseLogicalAnd();
bVar1 = std::__shared_ptr::operator_cast_to_bool(local_70);
if (!bVar1) break;
/* try { // try from 0019d1fa to 0019d212 has its CatchHandler @ 0019d1d7 */
std::
make_shared<minja::BinaryOpExpr,minja::Location&,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>
(local_80,local_40,(shared_ptr *)in_RDI,(Op *)local_70);
std::shared_ptr<minja::Expression>::operator=
((shared_ptr<minja::Expression> *)in_RDI,(shared_ptr *)local_80);
std::shared_ptr<minja::BinaryOpExpr>::~shared_ptr((shared_ptr<minja::BinaryOpExpr> *)local_80);
std::shared_ptr<minja::Expression>::~shared_ptr((shared_ptr<minja::Expression> *)local_70);
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019d150 to 0019d15b has its CatchHandler @ 0019d1b8 */
std::runtime_error::runtime_error(prVar4,"Expected right side of \'or\' expression");
/* try { // try from 0019d15e to 0019d174 has its CatchHandler @ 0019d1d7 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
|
|
10,845 |
rlBindImageTexture
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h
|
void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly)
{
#if defined(GRAPHICS_API_OPENGL_43)
unsigned int glInternalFormat = 0, glFormat = 0, glType = 0;
rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
glBindImageTexture(index, id, 0, 0, 0, readonly? GL_READ_ONLY : GL_READ_WRITE, glInternalFormat);
#else
TRACELOG(RL_LOG_WARNING, "TEXTURE: Image texture binding not enabled. Define GRAPHICS_API_OPENGL_43");
#endif
}
|
O2
|
c
|
rlBindImageTexture:
leaq 0x6fe99(%rip), %rsi # 0xc590e
pushq $0x4
popq %rdi
xorl %eax, %eax
jmp 0xa128b
|
rlBindImageTexture:
lea rsi, aTextureImageTe; "TEXTURE: Image texture binding not enab"...
push 4
pop rdi
xor eax, eax
jmp TraceLog
|
long long rlBindImageTexture(long long a1, long long a2, int a3, int a4, int a5, int a6)
{
return TraceLog(
4,
(unsigned int)"TEXTURE: Image texture binding not enabled. Define GRAPHICS_API_OPENGL_43",
a3,
a4,
a5,
a6);
}
|
rlBindImageTexture:
LEA RSI,[0x1c590e]
PUSH 0x4
POP RDI
XOR EAX,EAX
JMP 0x001a128b
|
void rlBindImageTexture(void)
{
TraceLog(4,"TEXTURE: Image texture binding not enabled. Define GRAPHICS_API_OPENGL_43");
return;
}
|
|
10,846 |
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 0x6fa80
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 0x6fa80
movq %rax, -0x28(%rbp)
jmp 0x6fa54
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_6FA54:
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 0x0016fa80
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 0x0016fa80
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0016fa54
LAB_0016fa54:
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;
}
|
|
10,847 |
sp_get_geometry_mbr
|
eloqsql/storage/myisam/sp_key.c
|
static int sp_get_geometry_mbr(uchar *(*wkb), uchar *end, uint n_dims,
double *mbr, int top)
{
int res;
uchar byte_order;
uint wkb_type;
byte_order = *(*wkb);
++(*wkb);
wkb_type = uint4korr((*wkb));
(*wkb) += 4;
switch ((enum wkbType) wkb_type)
{
case wkbPoint:
res = sp_get_point_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbLineString:
res = sp_get_linestring_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbPolygon:
res = sp_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbMultiPoint:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_point_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbMultiLineString:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_linestring_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbMultiPolygon:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbGeometryCollection:
{
uint n_items;
if (!top)
return -1;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
if (sp_get_geometry_mbr(wkb, end, n_dims, mbr, 0))
return -1;
}
res = 0;
break;
}
default:
res = -1;
}
return res;
}
|
O3
|
c
|
sp_get_geometry_mbr:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rdx
leaq 0x1(%rdx), %rax
movq %rax, (%rdi)
movl 0x1(%rdx), %eax
leaq 0x5(%rdx), %rsi
movq %rsi, (%rdi)
decl %eax
cmpl $0x6, %eax
ja 0x91b8f
movq %rdi, %r15
leaq 0x58643(%rip), %rsi # 0xea030
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
addq $-0x8, %r14
movb $0x1, %al
xorl %ecx, %ecx
xorl %r12d, %r12d
movq (%r15), %rdx
cmpq %r14, %rdx
ja 0x91b8f
movsd (%rdx), %xmm0
addq $0x8, %rdx
movq %rdx, (%r15)
movsd (%rbx,%rcx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x91a28
movsd %xmm0, (%rbx,%rcx)
ucomisd 0x8(%rbx,%rcx), %xmm0
jbe 0x91a39
orq $0x8, %rcx
movsd %xmm0, (%rbx,%rcx)
movl $0x10, %ecx
testb $0x1, %al
movl $0x0, %eax
jne 0x91a01
jmp 0x91b95
movl 0x5(%rdx), %r13d
addq $0x9, %rdx
movq %rdx, (%r15)
xorl %r12d, %r12d
testl %r13d, %r13d
je 0x91b95
addq $0x5, (%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x91ba7
testl %eax, %eax
jne 0x91b8f
decl %r13d
jne 0x91a63
jmp 0x91b95
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x91c22
movl 0x5(%rdx), %eax
addq $0x9, %rdx
movq %rdx, (%r15)
testl %eax, %eax
je 0x91b8a
addq $-0x8, %r14
xorl %r12d, %r12d
addq $0x5, (%r15)
movb $0x1, %cl
xorl %edx, %edx
movq (%r15), %rsi
cmpq %r14, %rsi
ja 0x91b8f
movsd (%rsi), %xmm0
addq $0x8, %rsi
movq %rsi, (%r15)
movsd (%rbx,%rdx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x91aeb
movsd %xmm0, (%rbx,%rdx)
ucomisd 0x8(%rbx,%rdx), %xmm0
jbe 0x91afc
orq $0x8, %rdx
movsd %xmm0, (%rbx,%rdx)
movl $0x10, %edx
testb $0x1, %cl
movl $0x0, %ecx
jne 0x91ac4
decl %eax
jne 0x91abc
jmp 0x91b95
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x91ba7
movl 0x5(%rdx), %r13d
addq $0x9, %rdx
movq %rdx, (%r15)
xorl %r12d, %r12d
testl %r13d, %r13d
je 0x91b95
addq $0x5, (%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x91c22
testl %eax, %eax
jne 0x91b8f
decl %r13d
jne 0x91b40
jmp 0x91b95
testl %ecx, %ecx
je 0x91b8f
movl 0x5(%rdx), %r12d
addq $0x9, %rdx
movq %rdx, (%r15)
testl %r12d, %r12d
je 0x91b8a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x919b0
testl %eax, %eax
jne 0x91b8f
decl %r12d
jne 0x91b71
xorl %r12d, %r12d
jmp 0x91b95
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
sp_get_geometry_mbr_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov rdx, [rdi]
lea rax, [rdx+1]
mov [rdi], rax
mov eax, [rdx+1]
lea rsi, [rdx+5]
mov [rdi], rsi
dec eax; switch 7 cases
cmp eax, 6
ja def_919F4; jumptable 00000000000919F4 default case
mov r15, rdi
lea rsi, jpt_919F4
movsxd rax, ds:(jpt_919F4 - 0EA030h)[rsi+rax*4]
add rax, rsi
jmp rax; switch jump
loc_919F6:
add r14, 0FFFFFFFFFFFFFFF8h; jumptable 00000000000919F4 case 1
mov al, 1
xor ecx, ecx
xor r12d, r12d
loc_91A01:
mov rdx, [r15]
cmp rdx, r14
ja def_919F4; jumptable 00000000000919F4 default case
movsd xmm0, qword ptr [rdx]
add rdx, 8
mov [r15], rdx
movsd xmm1, qword ptr [rbx+rcx]
ucomisd xmm1, xmm0
jbe short loc_91A28
movsd qword ptr [rbx+rcx], xmm0
loc_91A28:
ucomisd xmm0, qword ptr [rbx+rcx+8]
jbe short loc_91A39
or rcx, 8
movsd qword ptr [rbx+rcx], xmm0
loc_91A39:
mov ecx, 10h
test al, 1
mov eax, 0
jnz short loc_91A01
jmp loc_91B95
loc_91A4C:
mov r13d, [rdx+5]; jumptable 00000000000919F4 case 5
add rdx, 9
mov [r15], rdx
xor r12d, r12d
test r13d, r13d
jz loc_91B95
loc_91A63:
add qword ptr [r15], 5
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call sp_get_linestring_mbr_0
test eax, eax
jnz def_919F4; jumptable 00000000000919F4 default case
dec r13d
jnz short loc_91A63
jmp loc_91B95
loc_91A87:
mov rdi, r15; jumptable 00000000000919F4 case 3
mov rsi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp sp_get_polygon_mbr_0
loc_91AA3:
mov eax, [rdx+5]; jumptable 00000000000919F4 case 4
add rdx, 9
mov [r15], rdx
test eax, eax
jz loc_91B8A
add r14, 0FFFFFFFFFFFFFFF8h
xor r12d, r12d
loc_91ABC:
add qword ptr [r15], 5
mov cl, 1
xor edx, edx
loc_91AC4:
mov rsi, [r15]
cmp rsi, r14
ja def_919F4; jumptable 00000000000919F4 default case
movsd xmm0, qword ptr [rsi]
add rsi, 8
mov [r15], rsi
movsd xmm1, qword ptr [rbx+rdx]
ucomisd xmm1, xmm0
jbe short loc_91AEB
movsd qword ptr [rbx+rdx], xmm0
loc_91AEB:
ucomisd xmm0, qword ptr [rbx+rdx+8]
jbe short loc_91AFC
or rdx, 8
movsd qword ptr [rbx+rdx], xmm0
loc_91AFC:
mov edx, 10h
test cl, 1
mov ecx, 0
jnz short loc_91AC4
dec eax
jnz short loc_91ABC
jmp loc_91B95
loc_91B14:
mov rdi, r15; jumptable 00000000000919F4 case 2
mov rsi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp short sp_get_linestring_mbr_0
loc_91B2D:
mov r13d, [rdx+5]; jumptable 00000000000919F4 case 6
add rdx, 9
mov [r15], rdx
xor r12d, r12d
test r13d, r13d
jz short loc_91B95
loc_91B40:
add qword ptr [r15], 5
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call sp_get_polygon_mbr_0
test eax, eax
jnz short def_919F4; jumptable 00000000000919F4 default case
dec r13d
jnz short loc_91B40
jmp short loc_91B95
loc_91B5D:
test ecx, ecx; jumptable 00000000000919F4 case 7
jz short def_919F4; jumptable 00000000000919F4 default case
mov r12d, [rdx+5]
add rdx, 9
mov [r15], rdx
test r12d, r12d
jz short loc_91B8A
loc_91B71:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call sp_get_geometry_mbr_0
test eax, eax
jnz short def_919F4; jumptable 00000000000919F4 default case
dec r12d
jnz short loc_91B71
loc_91B8A:
xor r12d, r12d
jmp short loc_91B95
def_919F4:
mov r12d, 0FFFFFFFFh; jumptable 00000000000919F4 default case
loc_91B95:
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long sp_get_geometry_mbr_0(double **a1, long long a2, long long a3, int a4, long long a5, long long a6)
{
long long v6; // rax
double *v8; // rdx
int v9; // eax
char v10; // al
long long v11; // rcx
unsigned int v12; // r12d
double *v13; // rdx
double v14; // xmm0_8
bool v15; // zf
int v16; // r13d
int v18; // eax
unsigned long long v19; // r14
char v20; // cl
long long v21; // rdx
double *v22; // rsi
double v23; // xmm0_8
int v24; // r13d
int v25; // r12d
long long v26; // [rsp-8h] [rbp-30h]
long long v27; // [rsp+0h] [rbp-28h]
long long v28; // [rsp+8h] [rbp-20h]
long long v29; // [rsp+10h] [rbp-18h]
v26 = v6;
v8 = *a1;
*a1 = (double *)((char *)*a1 + 1);
v9 = *(_DWORD *)((char *)v8 + 1);
*a1 = (double *)((char *)v8 + 5);
switch ( v9 )
{
case 1:
v10 = 1;
v11 = 0LL;
v12 = 0;
do
{
v13 = *a1;
if ( (unsigned long long)*a1 > a2 - 8 )
return (unsigned int)-1;
v14 = *v13;
*a1 = v13 + 1;
if ( *(double *)(a3 + v11) > v14 )
*(double *)(a3 + v11) = v14;
if ( v14 > *(double *)(a3 + v11 + 8) )
*(double *)(a3 + (v11 | 8)) = v14;
v11 = 16LL;
v15 = (v10 & 1) == 0;
v10 = 0;
}
while ( !v15 );
return v12;
case 2:
return sp_get_linestring_mbr_0(a1, a2, a3);
case 3:
return sp_get_polygon_mbr_0(a1, a2, a3);
case 4:
v18 = *(_DWORD *)((char *)v8 + 5);
*a1 = (double *)((char *)v8 + 9);
if ( !v18 )
return 0;
v19 = a2 - 8;
v12 = 0;
LABEL_17:
*a1 = (double *)((char *)*a1 + 5);
v20 = 1;
v21 = 0LL;
while ( 1 )
{
v22 = *a1;
if ( (unsigned long long)*a1 > v19 )
return (unsigned int)-1;
v23 = *v22;
*a1 = v22 + 1;
if ( *(double *)(a3 + v21) > v23 )
*(double *)(a3 + v21) = v23;
if ( v23 > *(double *)(a3 + v21 + 8) )
*(double *)(a3 + (v21 | 8)) = v23;
v21 = 16LL;
v15 = (v20 & 1) == 0;
v20 = 0;
if ( v15 )
{
if ( --v18 )
goto LABEL_17;
return v12;
}
}
case 5:
v16 = *(_DWORD *)((char *)v8 + 5);
*a1 = (double *)((char *)v8 + 9);
v12 = 0;
if ( !v16 )
return v12;
while ( 1 )
{
*a1 = (double *)((char *)*a1 + 5);
if ( (unsigned int)sp_get_linestring_mbr_0(a1, a2, a3) )
break;
if ( !--v16 )
return v12;
}
return (unsigned int)-1;
case 6:
v24 = *(_DWORD *)((char *)v8 + 5);
*a1 = (double *)((char *)v8 + 9);
v12 = 0;
if ( !v24 )
return v12;
while ( 1 )
{
*a1 = (double *)((char *)*a1 + 5);
if ( (unsigned int)sp_get_polygon_mbr_0(a1, a2, a3) )
break;
if ( !--v24 )
return v12;
}
return (unsigned int)-1;
case 7:
if ( !a4 )
return (unsigned int)-1;
v25 = *(_DWORD *)((char *)v8 + 5);
*a1 = (double *)((char *)v8 + 9);
if ( !v25 )
return 0;
break;
default:
return (unsigned int)-1;
}
while ( !(unsigned int)sp_get_geometry_mbr_0(a1, a2, a3, 0LL, a5, a6, v26, v27, v28, v29) )
{
if ( !--v25 )
return 0;
}
return (unsigned int)-1;
}
|
sp_get_geometry_mbr:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV RDX,qword ptr [RDI]
LEA RAX,[RDX + 0x1]
MOV qword ptr [RDI],RAX
MOV EAX,dword ptr [RDX + 0x1]
LEA RSI,[RDX + 0x5]
MOV qword ptr [RDI],RSI
DEC EAX
CMP EAX,0x6
JA 0x00191b8f
MOV R15,RDI
LEA RSI,[0x1ea030]
MOVSXD RAX,dword ptr [RSI + RAX*0x4]
ADD RAX,RSI
switchD:
JMP RAX
caseD_1:
ADD R14,-0x8
MOV AL,0x1
XOR ECX,ECX
XOR R12D,R12D
LAB_00191a01:
MOV RDX,qword ptr [R15]
CMP RDX,R14
JA 0x00191b8f
MOVSD XMM0,qword ptr [RDX]
ADD RDX,0x8
MOV qword ptr [R15],RDX
MOVSD XMM1,qword ptr [RBX + RCX*0x1]
UCOMISD XMM1,XMM0
JBE 0x00191a28
MOVSD qword ptr [RBX + RCX*0x1],XMM0
LAB_00191a28:
UCOMISD XMM0,qword ptr [RBX + RCX*0x1 + 0x8]
JBE 0x00191a39
OR RCX,0x8
MOVSD qword ptr [RBX + RCX*0x1],XMM0
LAB_00191a39:
MOV ECX,0x10
TEST AL,0x1
MOV EAX,0x0
JNZ 0x00191a01
JMP 0x00191b95
caseD_5:
MOV R13D,dword ptr [RDX + 0x5]
ADD RDX,0x9
MOV qword ptr [R15],RDX
XOR R12D,R12D
TEST R13D,R13D
JZ 0x00191b95
LAB_00191a63:
ADD qword ptr [R15],0x5
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00191ba7
TEST EAX,EAX
JNZ 0x00191b8f
DEC R13D
JNZ 0x00191a63
JMP 0x00191b95
caseD_3:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00191c22
caseD_4:
MOV EAX,dword ptr [RDX + 0x5]
ADD RDX,0x9
MOV qword ptr [R15],RDX
TEST EAX,EAX
JZ 0x00191b8a
ADD R14,-0x8
XOR R12D,R12D
LAB_00191abc:
ADD qword ptr [R15],0x5
MOV CL,0x1
XOR EDX,EDX
LAB_00191ac4:
MOV RSI,qword ptr [R15]
CMP RSI,R14
JA 0x00191b8f
MOVSD XMM0,qword ptr [RSI]
ADD RSI,0x8
MOV qword ptr [R15],RSI
MOVSD XMM1,qword ptr [RBX + RDX*0x1]
UCOMISD XMM1,XMM0
JBE 0x00191aeb
MOVSD qword ptr [RBX + RDX*0x1],XMM0
LAB_00191aeb:
UCOMISD XMM0,qword ptr [RBX + RDX*0x1 + 0x8]
JBE 0x00191afc
OR RDX,0x8
MOVSD qword ptr [RBX + RDX*0x1],XMM0
LAB_00191afc:
MOV EDX,0x10
TEST CL,0x1
MOV ECX,0x0
JNZ 0x00191ac4
DEC EAX
JNZ 0x00191abc
JMP 0x00191b95
caseD_2:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00191ba7
caseD_6:
MOV R13D,dword ptr [RDX + 0x5]
ADD RDX,0x9
MOV qword ptr [R15],RDX
XOR R12D,R12D
TEST R13D,R13D
JZ 0x00191b95
LAB_00191b40:
ADD qword ptr [R15],0x5
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00191c22
TEST EAX,EAX
JNZ 0x00191b8f
DEC R13D
JNZ 0x00191b40
JMP 0x00191b95
caseD_7:
TEST ECX,ECX
JZ 0x00191b8f
MOV R12D,dword ptr [RDX + 0x5]
ADD RDX,0x9
MOV qword ptr [R15],RDX
TEST R12D,R12D
JZ 0x00191b8a
LAB_00191b71:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x001919b0
TEST EAX,EAX
JNZ 0x00191b8f
DEC R12D
JNZ 0x00191b71
LAB_00191b8a:
XOR R12D,R12D
JMP 0x00191b95
default:
MOV R12D,0xffffffff
LAB_00191b95:
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 sp_get_geometry_mbr(long *param_1,long param_2,long param_3,int param_4)
{
double dVar1;
int4 uVar2;
long lVar3;
double *pdVar4;
bool bVar5;
bool bVar6;
int iVar7;
ulong uVar8;
int iVar9;
int8 uVar10;
lVar3 = *param_1;
*param_1 = lVar3 + 1;
uVar2 = *(int4 *)(lVar3 + 1);
*param_1 = lVar3 + 5;
switch(uVar2) {
case 1:
uVar8 = 0;
uVar10 = 0;
bVar5 = true;
do {
bVar6 = bVar5;
pdVar4 = (double *)*param_1;
if ((double *)(param_2 + -8) < pdVar4) goto switchD_001919f4_default;
dVar1 = *pdVar4;
*param_1 = (long)(pdVar4 + 1);
if (dVar1 < *(double *)(param_3 + uVar8)) {
*(double *)(param_3 + uVar8) = dVar1;
}
pdVar4 = (double *)(param_3 + 8 + uVar8);
if (*pdVar4 <= dVar1 && dVar1 != *pdVar4) {
*(double *)(param_3 + (uVar8 | 8)) = dVar1;
}
uVar8 = 0x10;
bVar5 = false;
} while (bVar6);
break;
case 2:
uVar10 = sp_get_linestring_mbr(param_1,param_2,param_3);
return uVar10;
case 3:
uVar10 = sp_get_polygon_mbr(param_1,param_2,param_3);
return uVar10;
case 4:
iVar9 = *(int *)(lVar3 + 5);
*param_1 = lVar3 + 9;
if (iVar9 != 0) {
do {
*param_1 = *param_1 + 5;
uVar8 = 0;
bVar5 = true;
do {
bVar6 = bVar5;
pdVar4 = (double *)*param_1;
if ((double *)(param_2 + -8) < pdVar4) goto switchD_001919f4_default;
dVar1 = *pdVar4;
*param_1 = (long)(pdVar4 + 1);
if (dVar1 < *(double *)(param_3 + uVar8)) {
*(double *)(param_3 + uVar8) = dVar1;
}
pdVar4 = (double *)(param_3 + 8 + uVar8);
if (*pdVar4 <= dVar1 && dVar1 != *pdVar4) {
*(double *)(param_3 + (uVar8 | 8)) = dVar1;
}
uVar8 = 0x10;
bVar5 = false;
} while (bVar6);
iVar9 = iVar9 + -1;
if (iVar9 == 0) {
return 0;
}
} while( true );
}
LAB_00191b8a:
uVar10 = 0;
break;
case 5:
iVar9 = *(int *)(lVar3 + 5);
*param_1 = lVar3 + 9;
uVar10 = 0;
for (; iVar9 != 0; iVar9 = iVar9 + -1) {
*param_1 = *param_1 + 5;
iVar7 = sp_get_linestring_mbr(param_1,param_2,param_3);
if (iVar7 != 0) goto switchD_001919f4_default;
}
break;
case 6:
iVar9 = *(int *)(lVar3 + 5);
*param_1 = lVar3 + 9;
uVar10 = 0;
for (; iVar9 != 0; iVar9 = iVar9 + -1) {
*param_1 = *param_1 + 5;
iVar7 = sp_get_polygon_mbr(param_1,param_2,param_3);
if (iVar7 != 0) goto switchD_001919f4_default;
}
break;
case 7:
if (param_4 != 0) {
iVar9 = *(int *)(lVar3 + 5);
*param_1 = lVar3 + 9;
for (; iVar9 != 0; iVar9 = iVar9 + -1) {
iVar7 = sp_get_geometry_mbr(param_1,param_2,param_3,0);
if (iVar7 != 0) goto switchD_001919f4_default;
}
goto LAB_00191b8a;
}
default:
switchD_001919f4_default:
uVar10 = 0xffffffff;
}
return uVar10;
}
|
|
10,848 |
my_casedn_str_mb
|
eloqsql/strings/ctype-mb.c
|
size_t my_casedn_str_mb(CHARSET_INFO * cs, char *str)
{
register uint32 l;
register const uchar *map= cs->to_lower;
char *str_orig= str;
while (*str)
{
/* Pointing after the '\0' is safe here. */
if ((l= my_ismbchar(cs, str, str + cs->mbmaxlen)))
str+= l;
else
{
*str= (char) map[(uchar)*str];
str++;
}
}
return (size_t) (str - str_orig);
}
|
O0
|
c
|
my_casedn_str_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x116897
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %eax
addq %rax, %rdx
callq 0x1167b0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x116875
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x116895
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x116834
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
my_casedn_str_mb:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
loc_116834:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_116897
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
mov rax, [rbp+var_8]
mov eax, [rax+9Ch]
add rdx, rax
call my_ismbchar_0
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_116875
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp short loc_116895
loc_116875:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_10]
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
loc_116895:
jmp short loc_116834
loc_116897:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
sub rax, rcx
add rsp, 30h
pop rbp
retn
|
_BYTE * my_casedn_str_mb(long long a1, _BYTE *a2)
{
long long v3; // [rsp+10h] [rbp-20h]
unsigned int v4; // [rsp+1Ch] [rbp-14h]
_BYTE *v5; // [rsp+20h] [rbp-10h]
v5 = a2;
v3 = *(_QWORD *)(a1 + 72);
while ( *v5 )
{
v4 = my_ismbchar_0(a1, (long long)v5, (long long)&v5[*(unsigned int *)(a1 + 156)]);
if ( v4 )
{
v5 += v4;
}
else
{
*v5 = *(_BYTE *)(v3 + (unsigned __int8)*v5);
++v5;
}
}
return (_BYTE *)(v5 - a2);
}
| |||
10,849 |
my_casedn_str_mb
|
eloqsql/strings/ctype-mb.c
|
size_t my_casedn_str_mb(CHARSET_INFO * cs, char *str)
{
register uint32 l;
register const uchar *map= cs->to_lower;
char *str_orig= str;
while (*str)
{
/* Pointing after the '\0' is safe here. */
if ((l= my_ismbchar(cs, str, str + cs->mbmaxlen)))
str+= l;
else
{
*str= (char) map[(uchar)*str];
str++;
}
}
return (size_t) (str - str_orig);
}
|
O3
|
c
|
my_casedn_str_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpb $0x0, (%rsi)
movq %rsi, %rax
je 0xb2fe4
movq %rdi, %r14
movq 0x48(%rdi), %r12
movq %rbx, %r15
movl 0x9c(%r14), %edx
addq %r15, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xc0(%rax)
cmpl $0x2, %eax
jge 0xb2fd4
movzbl (%r15), %eax
movb (%r12,%rax), %al
movb %al, (%r15)
movl $0x1, %ecx
jmp 0xb2fd6
movl %eax, %ecx
leaq (%r15,%rcx), %rax
cmpb $0x0, (%r15,%rcx)
movq %rax, %r15
jne 0xb2fa0
subq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
my_casedn_str_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rsi
cmp byte ptr [rsi], 0
mov rax, rsi
jz short loc_B2FE4
mov r14, rdi
mov r12, [rdi+48h]
mov r15, rbx
loc_B2FA0:
mov edx, [r14+9Ch]
add rdx, r15
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, r15
call qword ptr [rax+0C0h]
cmp eax, 2
jge short loc_B2FD4
movzx eax, byte ptr [r15]
mov al, [r12+rax]
mov [r15], al
mov ecx, 1
jmp short loc_B2FD6
loc_B2FD4:
mov ecx, eax
loc_B2FD6:
lea rax, [r15+rcx]
cmp byte ptr [r15+rcx], 0
mov r15, rax
jnz short loc_B2FA0
loc_B2FE4:
sub rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long my_casedn_str_mb(long long a1, _BYTE *a2)
{
_BYTE *v2; // rax
long long v3; // r12
_BYTE *v4; // r15
int v5; // eax
long long v6; // rcx
bool v7; // zf
v2 = a2;
if ( *a2 )
{
v3 = *(_QWORD *)(a1 + 72);
v4 = a2;
do
{
v5 = (*(long long ( **)(long long, _BYTE *, _BYTE *))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v4,
&v4[*(unsigned int *)(a1 + 156)]);
if ( v5 >= 2 )
{
v6 = (unsigned int)v5;
}
else
{
*v4 = *(_BYTE *)(v3 + (unsigned __int8)*v4);
v6 = 1LL;
}
v2 = &v4[v6];
v7 = v4[v6] == 0;
v4 += v6;
}
while ( !v7 );
}
return v2 - a2;
}
|
my_casedn_str_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RSI
CMP byte ptr [RSI],0x0
MOV RAX,RSI
JZ 0x001b2fe4
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x48]
MOV R15,RBX
LAB_001b2fa0:
MOV EDX,dword ptr [R14 + 0x9c]
ADD RDX,R15
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,R15
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
JGE 0x001b2fd4
MOVZX EAX,byte ptr [R15]
MOV AL,byte ptr [R12 + RAX*0x1]
MOV byte ptr [R15],AL
MOV ECX,0x1
JMP 0x001b2fd6
LAB_001b2fd4:
MOV ECX,EAX
LAB_001b2fd6:
LEA RAX,[R15 + RCX*0x1]
CMP byte ptr [R15 + RCX*0x1],0x0
MOV R15,RAX
JNZ 0x001b2fa0
LAB_001b2fe4:
SUB RAX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long my_casedn_str_mb(long param_1,byte *param_2)
{
byte *pbVar1;
long lVar2;
uint uVar3;
byte *pbVar4;
ulong uVar5;
byte *pbVar6;
pbVar4 = param_2;
if (*param_2 != 0) {
lVar2 = *(long *)(param_1 + 0x48);
pbVar6 = param_2;
do {
uVar3 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,pbVar6,pbVar6 + *(uint *)(param_1 + 0x9c));
if ((int)uVar3 < 2) {
*pbVar6 = *(byte *)(lVar2 + (ulong)*pbVar6);
uVar5 = 1;
}
else {
uVar5 = (ulong)uVar3;
}
pbVar4 = pbVar6 + uVar5;
pbVar1 = pbVar6 + uVar5;
pbVar6 = pbVar4;
} while (*pbVar1 != 0);
}
return (long)pbVar4 - (long)param_2;
}
|
|
10,850 |
js_date_parse_isostring
|
bluesky950520[P]quickjs/quickjs.c
|
static BOOL js_date_parse_isostring(const uint8_t *sp, int fields[9], BOOL *is_local) {
int sgn, i, p = 0;
/* initialize fields to the beginning of the Epoch */
for (i = 0; i < 9; i++) {
fields[i] = (i == 2);
}
*is_local = FALSE;
/* year is either yyyy digits or [+-]yyyyyy */
sgn = sp[p];
if (sgn == '-' || sgn == '+') {
p++;
if (!string_get_digits(sp, &p, &fields[0], 6, 6))
return FALSE;
if (sgn == '-') {
if (fields[0] == 0)
return FALSE; // reject -000000
fields[0] = -fields[0];
}
} else {
if (!string_get_digits(sp, &p, &fields[0], 4, 4))
return FALSE;
}
if (string_skip_char(sp, &p, '-')) {
if (!string_get_digits(sp, &p, &fields[1], 2, 2)) /* month */
return FALSE;
if (fields[1] < 1)
return FALSE;
fields[1] -= 1;
if (string_skip_char(sp, &p, '-')) {
if (!string_get_digits(sp, &p, &fields[2], 2, 2)) /* day */
return FALSE;
if (fields[2] < 1)
return FALSE;
}
}
if (string_skip_char(sp, &p, 'T')) {
*is_local = TRUE;
if (!string_get_digits(sp, &p, &fields[3], 2, 2) /* hour */
|| !string_skip_char(sp, &p, ':')
|| !string_get_digits(sp, &p, &fields[4], 2, 2)) { /* minute */
fields[3] = 100; // reject unconditionally
return TRUE;
}
if (string_skip_char(sp, &p, ':')) {
if (!string_get_digits(sp, &p, &fields[5], 2, 2)) /* second */
return FALSE;
string_get_milliseconds(sp, &p, &fields[6]);
}
}
/* parse the time zone offset if present: [+-]HH:mm or [+-]HHmm */
if (sp[p]) {
*is_local = FALSE;
if (!string_get_tzoffset(sp, &p, &fields[8], TRUE))
return FALSE;
}
/* error if extraneous characters */
return sp[p] == '\0';
}
|
O0
|
c
|
js_date_parse_isostring:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x9, 0x10(%rsp)
jge 0x99bf1
cmpl $0x2, 0x10(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq 0x20(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x99bc3
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x14(%rsp)
cmpl $0x2d, 0x14(%rsp)
je 0x99c1c
cmpl $0x2b, 0x14(%rsp)
jne 0x99c86
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0xc(%rsp), %rsi
movl $0x6, %r8d
movl %r8d, %ecx
callq 0x9a5f0
cmpl $0x0, %eax
jne 0x99c56
movl $0x0, 0x34(%rsp)
jmp 0x99f07
cmpl $0x2d, 0x14(%rsp)
jne 0x99c84
movq 0x20(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x99c74
movl $0x0, 0x34(%rsp)
jmp 0x99f07
movq 0x20(%rsp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x99cb7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0xc(%rsp), %rsi
movl $0x4, %r8d
movl %r8d, %ecx
callq 0x9a5f0
cmpl $0x0, %eax
jne 0x99cb5
movl $0x0, 0x34(%rsp)
jmp 0x99f07
jmp 0x99cb7
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x2d, %edx
callq 0x9a6c0
cmpl $0x0, %eax
je 0x99d95
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x4, %rdx
leaq 0xc(%rsp), %rsi
movl $0x2, %r8d
movl %r8d, %ecx
callq 0x9a5f0
cmpl $0x0, %eax
jne 0x99d07
movl $0x0, 0x34(%rsp)
jmp 0x99f07
movq 0x20(%rsp), %rax
cmpl $0x1, 0x4(%rax)
jge 0x99d1f
movl $0x0, 0x34(%rsp)
jmp 0x99f07
movq 0x20(%rsp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x2d, %edx
callq 0x9a6c0
cmpl $0x0, %eax
je 0x99d93
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x8, %rdx
leaq 0xc(%rsp), %rsi
movl $0x2, %r8d
movl %r8d, %ecx
callq 0x9a5f0
cmpl $0x0, %eax
jne 0x99d79
movl $0x0, 0x34(%rsp)
jmp 0x99f07
movq 0x20(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jge 0x99d91
movl $0x0, 0x34(%rsp)
jmp 0x99f07
jmp 0x99d93
jmp 0x99d95
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x54, %edx
callq 0x9a6c0
cmpl $0x0, %eax
je 0x99ea1
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0xc, %rdx
leaq 0xc(%rsp), %rsi
movl $0x2, %r8d
movl %r8d, %ecx
callq 0x9a5f0
cmpl $0x0, %eax
je 0x99e22
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x3a, %edx
callq 0x9a6c0
cmpl $0x0, %eax
je 0x99e22
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x10, %rdx
leaq 0xc(%rsp), %rsi
movl $0x2, %r8d
movl %r8d, %ecx
callq 0x9a5f0
cmpl $0x0, %eax
jne 0x99e3b
movq 0x20(%rsp), %rax
movl $0x64, 0xc(%rax)
movl $0x1, 0x34(%rsp)
jmp 0x99f07
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x3a, %edx
callq 0x9a6c0
cmpl $0x0, %eax
je 0x99e9f
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x14, %rdx
leaq 0xc(%rsp), %rsi
movl $0x2, %r8d
movl %r8d, %ecx
callq 0x9a5f0
cmpl $0x0, %eax
jne 0x99e87
movl $0x0, 0x34(%rsp)
jmp 0x99f07
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x18, %rdx
leaq 0xc(%rsp), %rsi
callq 0x9a710
jmp 0x99ea1
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x99eea
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x20, %rdx
leaq 0xc(%rsp), %rsi
movl $0x1, %ecx
callq 0x9a810
cmpl $0x0, %eax
jne 0x99ee8
movl $0x0, 0x34(%rsp)
jmp 0x99f07
jmp 0x99eea
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
|
js_date_parse_isostring:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_20], rdx
mov [rsp+38h+var_2C], 0
mov [rsp+38h+var_28], 0
loc_99BC3:
cmp [rsp+38h+var_28], 9
jge short loc_99BF1
cmp [rsp+38h+var_28], 2
setz al
and al, 1
movzx edx, al
mov rax, [rsp+38h+var_18]
movsxd rcx, [rsp+38h+var_28]
mov [rax+rcx*4], edx
mov eax, [rsp+38h+var_28]
add eax, 1
mov [rsp+38h+var_28], eax
jmp short loc_99BC3
loc_99BF1:
mov rax, [rsp+38h+var_20]
mov dword ptr [rax], 0
mov rax, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_2C]
movzx eax, byte ptr [rax+rcx]
mov [rsp+38h+var_24], eax
cmp [rsp+38h+var_24], 2Dh ; '-'
jz short loc_99C1C
cmp [rsp+38h+var_24], 2Bh ; '+'
jnz short loc_99C86
loc_99C1C:
mov eax, [rsp+38h+var_2C]
add eax, 1
mov [rsp+38h+var_2C], eax
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
lea rsi, [rsp+38h+var_2C]
mov r8d, 6
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_99C56
mov [rsp+38h+var_4], 0
jmp loc_99F07
loc_99C56:
cmp [rsp+38h+var_24], 2Dh ; '-'
jnz short loc_99C84
mov rax, [rsp+38h+var_18]
cmp dword ptr [rax], 0
jnz short loc_99C74
mov [rsp+38h+var_4], 0
jmp loc_99F07
loc_99C74:
mov rax, [rsp+38h+var_18]
xor ecx, ecx
sub ecx, [rax]
mov rax, [rsp+38h+var_18]
mov [rax], ecx
loc_99C84:
jmp short loc_99CB7
loc_99C86:
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
lea rsi, [rsp+38h+var_2C]
mov r8d, 4
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_99CB5
mov [rsp+38h+var_4], 0
jmp loc_99F07
loc_99CB5:
jmp short $+2
loc_99CB7:
mov rdi, [rsp+38h+var_10]
lea rsi, [rsp+38h+var_2C]
mov edx, 2Dh ; '-'
call string_skip_char
cmp eax, 0
jz loc_99D95
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 4
lea rsi, [rsp+38h+var_2C]
mov r8d, 2
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_99D07
mov [rsp+38h+var_4], 0
jmp loc_99F07
loc_99D07:
mov rax, [rsp+38h+var_18]
cmp dword ptr [rax+4], 1
jge short loc_99D1F
mov [rsp+38h+var_4], 0
jmp loc_99F07
loc_99D1F:
mov rax, [rsp+38h+var_18]
mov ecx, [rax+4]
sub ecx, 1
mov [rax+4], ecx
mov rdi, [rsp+38h+var_10]
lea rsi, [rsp+38h+var_2C]
mov edx, 2Dh ; '-'
call string_skip_char
cmp eax, 0
jz short loc_99D93
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 8
lea rsi, [rsp+38h+var_2C]
mov r8d, 2
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_99D79
mov [rsp+38h+var_4], 0
jmp loc_99F07
loc_99D79:
mov rax, [rsp+38h+var_18]
cmp dword ptr [rax+8], 1
jge short loc_99D91
mov [rsp+38h+var_4], 0
jmp loc_99F07
loc_99D91:
jmp short $+2
loc_99D93:
jmp short $+2
loc_99D95:
mov rdi, [rsp+38h+var_10]
lea rsi, [rsp+38h+var_2C]
mov edx, 54h ; 'T'
call string_skip_char
cmp eax, 0
jz loc_99EA1
mov rax, [rsp+38h+var_20]
mov dword ptr [rax], 1
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 0Ch
lea rsi, [rsp+38h+var_2C]
mov r8d, 2
mov ecx, r8d
call string_get_digits
cmp eax, 0
jz short loc_99E22
mov rdi, [rsp+38h+var_10]
lea rsi, [rsp+38h+var_2C]
mov edx, 3Ah ; ':'
call string_skip_char
cmp eax, 0
jz short loc_99E22
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 10h
lea rsi, [rsp+38h+var_2C]
mov r8d, 2
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_99E3B
loc_99E22:
mov rax, [rsp+38h+var_18]
mov dword ptr [rax+0Ch], 64h ; 'd'
mov [rsp+38h+var_4], 1
jmp loc_99F07
loc_99E3B:
mov rdi, [rsp+38h+var_10]
lea rsi, [rsp+38h+var_2C]
mov edx, 3Ah ; ':'
call string_skip_char
cmp eax, 0
jz short loc_99E9F
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 14h
lea rsi, [rsp+38h+var_2C]
mov r8d, 2
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_99E87
mov [rsp+38h+var_4], 0
jmp loc_99F07
loc_99E87:
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 18h
lea rsi, [rsp+38h+var_2C]
call string_get_milliseconds
loc_99E9F:
jmp short $+2
loc_99EA1:
mov rax, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_2C]
cmp byte ptr [rax+rcx], 0
jz short loc_99EEA
mov rax, [rsp+38h+var_20]
mov dword ptr [rax], 0
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 20h ; ' '
lea rsi, [rsp+38h+var_2C]
mov ecx, 1
call string_get_tzoffset
cmp eax, 0
jnz short loc_99EE8
mov [rsp+38h+var_4], 0
jmp short loc_99F07
loc_99EE8:
jmp short $+2
loc_99EEA:
mov rax, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_2C]
movzx eax, byte ptr [rax+rcx]
cmp eax, 0
setz al
and al, 1
movzx eax, al
mov [rsp+38h+var_4], eax
loc_99F07:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
|
_BOOL8 js_date_parse_isostring(long long a1, _DWORD *a2, _DWORD *a3)
{
int v4; // [rsp+Ch] [rbp-2Ch] BYREF
int i; // [rsp+10h] [rbp-28h]
int v6; // [rsp+14h] [rbp-24h]
_DWORD *v7; // [rsp+18h] [rbp-20h]
_DWORD *v8; // [rsp+20h] [rbp-18h]
long long v9; // [rsp+28h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
v4 = 0;
for ( i = 0; i < 9; ++i )
v8[i] = i == 2;
*v7 = 0;
v6 = *(unsigned __int8 *)(v9 + v4);
if ( v6 == 45 || v6 == 43 )
{
++v4;
if ( !(unsigned int)string_get_digits(v9, &v4, v8, 6LL) )
return 0;
if ( v6 == 45 )
{
if ( !*v8 )
return 0;
*v8 = -*v8;
}
}
else if ( !(unsigned int)string_get_digits(v9, &v4, v8, 4LL) )
{
return 0;
}
if ( (unsigned int)string_skip_char(v9, &v4, 45LL) )
{
if ( !(unsigned int)string_get_digits(v9, &v4, v8 + 1, 2LL) )
return 0;
if ( (int)v8[1] < 1 )
return 0;
--v8[1];
if ( (unsigned int)string_skip_char(v9, &v4, 45LL) )
{
if ( !(unsigned int)string_get_digits(v9, &v4, v8 + 2, 2LL) )
return 0;
if ( (int)v8[2] < 1 )
return 0;
}
}
if ( (unsigned int)string_skip_char(v9, &v4, 84LL) )
{
*v7 = 1;
if ( !(unsigned int)string_get_digits(v9, &v4, v8 + 3, 2LL)
|| !(unsigned int)string_skip_char(v9, &v4, 58LL)
|| !(unsigned int)string_get_digits(v9, &v4, v8 + 4, 2LL) )
{
v8[3] = 100;
return 1;
}
if ( (unsigned int)string_skip_char(v9, &v4, 58LL) )
{
if ( !(unsigned int)string_get_digits(v9, &v4, v8 + 5, 2LL) )
return 0;
string_get_milliseconds(v9, &v4, v8 + 6);
}
}
if ( !*(_BYTE *)(v9 + v4) )
return *(unsigned __int8 *)(v9 + v4) == 0;
*v7 = 0;
return (unsigned int)string_get_tzoffset(v9, &v4, v8 + 8, 1LL) && *(unsigned __int8 *)(v9 + v4) == 0;
}
|
js_date_parse_isostring:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV dword ptr [RSP + 0xc],0x0
MOV dword ptr [RSP + 0x10],0x0
LAB_00199bc3:
CMP dword ptr [RSP + 0x10],0x9
JGE 0x00199bf1
CMP dword ptr [RSP + 0x10],0x2
SETZ AL
AND AL,0x1
MOVZX EDX,AL
MOV RAX,qword ptr [RSP + 0x20]
MOVSXD RCX,dword ptr [RSP + 0x10]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
MOV dword ptr [RSP + 0x10],EAX
JMP 0x00199bc3
LAB_00199bf1:
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RSP + 0x14],EAX
CMP dword ptr [RSP + 0x14],0x2d
JZ 0x00199c1c
CMP dword ptr [RSP + 0x14],0x2b
JNZ 0x00199c86
LAB_00199c1c:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0xc]
MOV R8D,0x6
MOV ECX,R8D
CALL 0x0019a5f0
CMP EAX,0x0
JNZ 0x00199c56
MOV dword ptr [RSP + 0x34],0x0
JMP 0x00199f07
LAB_00199c56:
CMP dword ptr [RSP + 0x14],0x2d
JNZ 0x00199c84
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX],0x0
JNZ 0x00199c74
MOV dword ptr [RSP + 0x34],0x0
JMP 0x00199f07
LAB_00199c74:
MOV RAX,qword ptr [RSP + 0x20]
XOR ECX,ECX
SUB ECX,dword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX],ECX
LAB_00199c84:
JMP 0x00199cb7
LAB_00199c86:
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0xc]
MOV R8D,0x4
MOV ECX,R8D
CALL 0x0019a5f0
CMP EAX,0x0
JNZ 0x00199cb5
MOV dword ptr [RSP + 0x34],0x0
JMP 0x00199f07
LAB_00199cb5:
JMP 0x00199cb7
LAB_00199cb7:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xc]
MOV EDX,0x2d
CALL 0x0019a6c0
CMP EAX,0x0
JZ 0x00199d95
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x4
LEA RSI,[RSP + 0xc]
MOV R8D,0x2
MOV ECX,R8D
CALL 0x0019a5f0
CMP EAX,0x0
JNZ 0x00199d07
MOV dword ptr [RSP + 0x34],0x0
JMP 0x00199f07
LAB_00199d07:
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX + 0x4],0x1
JGE 0x00199d1f
MOV dword ptr [RSP + 0x34],0x0
JMP 0x00199f07
LAB_00199d1f:
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RAX + 0x4]
SUB ECX,0x1
MOV dword ptr [RAX + 0x4],ECX
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xc]
MOV EDX,0x2d
CALL 0x0019a6c0
CMP EAX,0x0
JZ 0x00199d93
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x8
LEA RSI,[RSP + 0xc]
MOV R8D,0x2
MOV ECX,R8D
CALL 0x0019a5f0
CMP EAX,0x0
JNZ 0x00199d79
MOV dword ptr [RSP + 0x34],0x0
JMP 0x00199f07
LAB_00199d79:
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX + 0x8],0x1
JGE 0x00199d91
MOV dword ptr [RSP + 0x34],0x0
JMP 0x00199f07
LAB_00199d91:
JMP 0x00199d93
LAB_00199d93:
JMP 0x00199d95
LAB_00199d95:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xc]
MOV EDX,0x54
CALL 0x0019a6c0
CMP EAX,0x0
JZ 0x00199ea1
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],0x1
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0xc
LEA RSI,[RSP + 0xc]
MOV R8D,0x2
MOV ECX,R8D
CALL 0x0019a5f0
CMP EAX,0x0
JZ 0x00199e22
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xc]
MOV EDX,0x3a
CALL 0x0019a6c0
CMP EAX,0x0
JZ 0x00199e22
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x10
LEA RSI,[RSP + 0xc]
MOV R8D,0x2
MOV ECX,R8D
CALL 0x0019a5f0
CMP EAX,0x0
JNZ 0x00199e3b
LAB_00199e22:
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0xc],0x64
MOV dword ptr [RSP + 0x34],0x1
JMP 0x00199f07
LAB_00199e3b:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xc]
MOV EDX,0x3a
CALL 0x0019a6c0
CMP EAX,0x0
JZ 0x00199e9f
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x14
LEA RSI,[RSP + 0xc]
MOV R8D,0x2
MOV ECX,R8D
CALL 0x0019a5f0
CMP EAX,0x0
JNZ 0x00199e87
MOV dword ptr [RSP + 0x34],0x0
JMP 0x00199f07
LAB_00199e87:
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x18
LEA RSI,[RSP + 0xc]
CALL 0x0019a710
LAB_00199e9f:
JMP 0x00199ea1
LAB_00199ea1:
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0xc]
CMP byte ptr [RAX + RCX*0x1],0x0
JZ 0x00199eea
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x20
LEA RSI,[RSP + 0xc]
MOV ECX,0x1
CALL 0x0019a810
CMP EAX,0x0
JNZ 0x00199ee8
MOV dword ptr [RSP + 0x34],0x0
JMP 0x00199f07
LAB_00199ee8:
JMP 0x00199eea
LAB_00199eea:
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x34],EAX
LAB_00199f07:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
bool js_date_parse_isostring(byte *param_1,int *param_2,int4 *param_3)
{
int iVar1;
int local_2c;
int local_28;
uint local_24;
int4 *local_20;
int *local_18;
byte *local_10;
local_2c = 0;
for (local_28 = 0; local_28 < 9; local_28 = local_28 + 1) {
param_2[local_28] = (uint)(local_28 == 2);
}
*param_3 = 0;
local_24 = (uint)*param_1;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if ((local_24 == 0x2d) || (local_24 == 0x2b)) {
local_2c = 1;
iVar1 = string_get_digits(param_1,&local_2c,param_2);
if (iVar1 == 0) {
return false;
}
if (local_24 == 0x2d) {
if (*local_18 == 0) {
return false;
}
*local_18 = -*local_18;
}
}
else {
iVar1 = string_get_digits(param_1,&local_2c,param_2,4);
if (iVar1 == 0) {
return false;
}
}
iVar1 = string_skip_char(local_10,&local_2c,0x2d);
if (iVar1 != 0) {
iVar1 = string_get_digits(local_10,&local_2c,local_18 + 1,2);
if (iVar1 == 0) {
return false;
}
if (local_18[1] < 1) {
return false;
}
local_18[1] = local_18[1] + -1;
iVar1 = string_skip_char(local_10,&local_2c,0x2d);
if (iVar1 != 0) {
iVar1 = string_get_digits(local_10,&local_2c,local_18 + 2,2);
if (iVar1 == 0) {
return false;
}
if (local_18[2] < 1) {
return false;
}
}
}
iVar1 = string_skip_char(local_10,&local_2c,0x54);
if (iVar1 != 0) {
*local_20 = 1;
iVar1 = string_get_digits(local_10,&local_2c,local_18 + 3,2);
if (((iVar1 == 0) || (iVar1 = string_skip_char(local_10,&local_2c,0x3a), iVar1 == 0)) ||
(iVar1 = string_get_digits(local_10,&local_2c,local_18 + 4,2), iVar1 == 0)) {
local_18[3] = 100;
return true;
}
iVar1 = string_skip_char(local_10,&local_2c,0x3a);
if (iVar1 != 0) {
iVar1 = string_get_digits(local_10,&local_2c,local_18 + 5,2);
if (iVar1 == 0) {
return false;
}
string_get_milliseconds(local_10,&local_2c,local_18 + 6);
}
}
if (local_10[local_2c] != 0) {
*local_20 = 0;
iVar1 = string_get_tzoffset(local_10,&local_2c,local_18 + 8,1);
if (iVar1 == 0) {
return false;
}
}
return local_10[local_2c] == 0;
}
|
|
10,851 |
testing::internal::TestEventRepeater::OnTestIterationStart(testing::UnitTest const&, int)
|
giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc
|
void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
int iteration) {
if (forwarding_enabled_) {
for (size_t i = 0; i < listeners_.size(); i++) {
listeners_[i]->OnTestIterationStart(unit_test, iteration);
}
}
}
|
O1
|
cpp
|
testing::internal::TestEventRepeater::OnTestIterationStart(testing::UnitTest const&, int):
cmpb $0x1, 0x8(%rdi)
jne 0x24330
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x24325
movl %edx, %ebx
movq %rsi, %r14
xorl %r12d, %r12d
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x18(%rax)
incq %r12
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x242ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZN7testing8internal17TestEventRepeater20OnTestIterationStartERKNS_8UnitTestEi:
cmp byte ptr [rdi+8], 1
jnz short locret_24330
push r15
push r14
push r12
push rbx
push rax
mov r15, rdi
mov rax, [rdi+10h]
cmp [rdi+18h], rax
jz short loc_24325
mov ebx, edx
mov r14, rsi
xor r12d, r12d
loc_242FF:
mov rdi, [rax+r12*8]
mov rax, [rdi]
mov rsi, r14
mov edx, ebx
call qword ptr [rax+18h]
inc r12
mov rax, [r15+10h]
mov rcx, [r15+18h]
sub rcx, rax
sar rcx, 3
cmp r12, rcx
jb short loc_242FF
loc_24325:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
locret_24330:
retn
|
long long testing::internal::TestEventRepeater::OnTestIterationStart(
testing::internal::TestEventRepeater *this,
const testing::UnitTest *a2,
unsigned int a3)
{
long long result; // rax
unsigned long long v5; // r12
if ( *((_BYTE *)this + 8) == 1 )
{
result = *((_QWORD *)this + 2);
if ( *((_QWORD *)this + 3) != result )
{
v5 = 0LL;
do
{
(*(void ( **)(_QWORD, const testing::UnitTest *, _QWORD))(**(_QWORD **)(result + 8 * v5) + 24LL))(
*(_QWORD *)(result + 8 * v5),
a2,
a3);
++v5;
result = *((_QWORD *)this + 2);
}
while ( v5 < (*((_QWORD *)this + 3) - result) >> 3 );
}
}
return result;
}
|
OnTestIterationStart:
CMP byte ptr [RDI + 0x8],0x1
JNZ 0x00124330
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x18],RAX
JZ 0x00124325
MOV EBX,EDX
MOV R14,RSI
XOR R12D,R12D
LAB_001242ff:
MOV RDI,qword ptr [RAX + R12*0x8]
MOV RAX,qword ptr [RDI]
MOV RSI,R14
MOV EDX,EBX
CALL qword ptr [RAX + 0x18]
INC R12
MOV RAX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [R15 + 0x18]
SUB RCX,RAX
SAR RCX,0x3
CMP R12,RCX
JC 0x001242ff
LAB_00124325:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
LAB_00124330:
RET
|
/* testing::internal::TestEventRepeater::OnTestIterationStart(testing::UnitTest const&, int) */
void __thiscall
testing::internal::TestEventRepeater::OnTestIterationStart
(TestEventRepeater *this,UnitTest *param_1,int param_2)
{
long *plVar1;
long lVar2;
ulong uVar3;
if ((this[8] == (TestEventRepeater)0x1) &&
(lVar2 = *(long *)(this + 0x10), *(long *)(this + 0x18) != lVar2)) {
uVar3 = 0;
do {
plVar1 = *(long **)(lVar2 + uVar3 * 8);
(**(code **)(*plVar1 + 0x18))(plVar1,param_1,param_2);
uVar3 = uVar3 + 1;
lVar2 = *(long *)(this + 0x10);
} while (uVar3 < (ulong)(*(long *)(this + 0x18) - lVar2 >> 3));
}
return;
}
|
|
10,852 |
nglog::LogMessage::Flush()
|
ng-log[P]ng-log/src/logging.cc
|
void LogMessage::Flush() {
if (data_->has_been_flushed_ || data_->severity_ < FLAGS_minloglevel) {
return;
}
data_->num_chars_to_log_ = data_->stream_.pcount();
data_->num_chars_to_syslog_ =
data_->num_chars_to_log_ - data_->num_prefix_chars_;
// Do we need to add a \n to the end of this message?
bool append_newline =
(data_->message_text_[data_->num_chars_to_log_ - 1] != '\n');
char original_final_char = '\0';
// If we do need to add a \n, we'll do it by violating the memory of the
// ostrstream buffer. This is quick, and we'll make sure to undo our
// modification before anything else is done with the ostrstream. It
// would be preferable not to do things this way, but it seems to be
// the best way to deal with this.
if (append_newline) {
original_final_char = data_->message_text_[data_->num_chars_to_log_];
data_->message_text_[data_->num_chars_to_log_++] = '\n';
}
data_->message_text_[data_->num_chars_to_log_] = '\0';
// Prevent any subtle race conditions by wrapping a mutex lock around
// the actual logging action per se.
{
std::lock_guard<std::mutex> l{log_mutex};
(this->*(data_->send_method_))();
++num_messages_[static_cast<int>(data_->severity_)];
}
LogDestination::WaitForSinks(data_);
if (append_newline) {
// Fix the ostrstream back how it was before we screwed with it.
// It's 99.44% certain that we don't need to worry about doing this.
data_->message_text_[data_->num_chars_to_log_ - 1] = original_final_char;
}
// If errno was already set before we enter the logging call, we'll
// set it back to that value when we return from the logging call.
// It happens often that we log an error message after a syscall
// failure, which can potentially set the errno to some other
// values. We would like to preserve the original errno.
if (data_->preserved_errno_ != 0) {
errno = data_->preserved_errno_;
}
// Note that this message is now safely logged. If we're asked to flush
// again, as a result of destruction, say, we'll do nothing on future calls.
data_->has_been_flushed_ = true;
}
|
O2
|
cpp
|
nglog::LogMessage::Flush():
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
cmpb $0x0, 0x76e0(%rax)
jne 0xc30f
movl 0x7698(%rax), %ecx
leaq 0x258fe(%rip), %rdx # 0x31b20
cmpl (%rdx), %ecx
jl 0xc30f
movq %rdi, %rbx
movq 0x7568(%rax), %rcx
subq 0x7560(%rax), %rcx
movq %rcx, 0x76c0(%rax)
movq %rcx, %rdx
subq 0x76b8(%rax), %rdx
movq %rdx, 0x76c8(%rax)
movb 0x3(%rcx,%rax), %r14b
cmpb $0xa, %r14b
jne 0xc262
xorl %ebp, %ebp
jmp 0xc282
movb 0x4(%rax,%rcx), %bpl
leaq 0x1(%rcx), %rdx
movq %rdx, 0x76c0(%rax)
movb $0xa, 0x4(%rax,%rcx)
movq 0x8(%rbx), %rax
movq 0x76c0(%rax), %rcx
movb $0x0, 0x4(%rax,%rcx)
leaq 0x34b2a(%rip), %rdi # 0x40db8
callq 0x1cc6a
movq 0x8(%rbx), %rcx
movq 0x76a0(%rcx), %rax
movq 0x76a8(%rcx), %rdi
addq %rbx, %rdi
testb $0x1, %al
je 0xc2b4
movq (%rdi), %rcx
movq -0x1(%rcx,%rax), %rax
callq *%rax
movq 0x8(%rbx), %rax
movslq 0x7698(%rax), %rax
leaq 0x25968(%rip), %rcx # 0x31c30
incq (%rcx,%rax,8)
leaq 0x34ae5(%rip), %rdi # 0x40db8
callq 0x8450
movq 0x8(%rbx), %rdi
callq 0xffd0
cmpb $0xa, %r14b
je 0xc2f7
movq 0x8(%rbx), %rax
movq 0x76c0(%rax), %rcx
movb %bpl, 0x3(%rcx,%rax)
movq 0x8(%rbx), %rbx
movl (%rbx), %ebp
testl %ebp, %ebp
je 0xc308
callq 0x8050
movl %ebp, (%rax)
movb $0x1, 0x76e0(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x34a9a(%rip), %rdi # 0x40db8
callq 0x8450
movq %rbx, %rdi
callq 0x8a40
nop
|
_ZN5nglog10LogMessage5FlushEv:
push rbp
push r14
push rbx
mov rax, [rdi+8]
cmp byte ptr [rax+76E0h], 0
jnz loc_C30F
mov ecx, [rax+7698h]
lea rdx, _ZN3fLI17FLAGS_minloglevelE; fLI::FLAGS_minloglevel
cmp ecx, [rdx]
jl loc_C30F
mov rbx, rdi
mov rcx, [rax+7568h]
sub rcx, [rax+7560h]
mov [rax+76C0h], rcx
mov rdx, rcx
sub rdx, [rax+76B8h]
mov [rax+76C8h], rdx
mov r14b, [rcx+rax+3]
cmp r14b, 0Ah
jnz short loc_C262
xor ebp, ebp
jmp short loc_C282
loc_C262:
mov bpl, [rax+rcx+4]
lea rdx, [rcx+1]
mov [rax+76C0h], rdx
mov byte ptr [rax+rcx+4], 0Ah
mov rax, [rbx+8]
mov rcx, [rax+76C0h]
loc_C282:
mov byte ptr [rax+rcx+4], 0
lea rdi, _ZN5nglogL9log_mutexE; this
call _ZNSt5mutex4lockEv; std::mutex::lock(void)
mov rcx, [rbx+8]
mov rax, [rcx+76A0h]
mov rdi, [rcx+76A8h]
add rdi, rbx
test al, 1
jz short loc_C2B4
mov rcx, [rdi]
mov rax, [rcx+rax-1]
loc_C2B4:
call rax
mov rax, [rbx+8]
movsxd rax, dword ptr [rax+7698h]
lea rcx, _ZN5nglog10LogMessage13num_messages_E; nglog::LogMessage::num_messages_
inc qword ptr [rcx+rax*8]
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov rdi, [rbx+8]; this
call _ZN5nglog14LogDestination12WaitForSinksEPNS_8internal14LogMessageDataE; nglog::LogDestination::WaitForSinks(nglog::internal::LogMessageData *)
cmp r14b, 0Ah
jz short loc_C2F7
mov rax, [rbx+8]
mov rcx, [rax+76C0h]
mov [rcx+rax+3], bpl
loc_C2F7:
mov rbx, [rbx+8]
mov ebp, [rbx]
test ebp, ebp
jz short loc_C308
call ___errno_location
mov [rax], ebp
loc_C308:
mov byte ptr [rbx+76E0h], 1
loc_C30F:
pop rbx
pop r14
pop rbp
retn
mov rbx, rax
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov rdi, rbx
call __Unwind_Resume
|
long long nglog::LogMessage::Flush(nglog::LogMessage *this, nglog::internal::LogMessageData *a2)
{
long long result; // rax
long long v4; // rcx
char v5; // r14
char v6; // bp
long long v7; // rcx
void ( *v8)(_QWORD); // rax
_QWORD *v9; // rdi
long long v10; // rax
int *v11; // rbx
int v12; // ebp
result = *((_QWORD *)this + 1);
if ( !*(_BYTE *)(result + 30432) && *(_DWORD *)(result + 30360) >= fLI::FLAGS_minloglevel )
{
v4 = *(_QWORD *)(result + 30056) - *(_QWORD *)(result + 30048);
*(_QWORD *)(result + 30400) = v4;
*(_QWORD *)(result + 30408) = v4 - *(_QWORD *)(result + 30392);
v5 = *(_BYTE *)(v4 + result + 3);
if ( v5 == 10 )
{
v6 = 0;
}
else
{
v6 = *(_BYTE *)(result + v4 + 4);
*(_QWORD *)(result + 30400) = v4 + 1;
*(_BYTE *)(result + v4 + 4) = 10;
result = *((_QWORD *)this + 1);
v4 = *(_QWORD *)(result + 30400);
}
*(_BYTE *)(result + v4 + 4) = 0;
std::mutex::lock((std::mutex *)&nglog::log_mutex);
v7 = *((_QWORD *)this + 1);
v8 = *(void ( **)(_QWORD))(v7 + 30368);
v9 = (_QWORD *)((char *)this + *(_QWORD *)(v7 + 30376));
if ( ((unsigned __int8)v8 & 1) != 0 )
v8 = *(void ( **)(_QWORD))((char *)v8 + *v9 - 1);
v8(v9);
v10 = *(int *)(*((_QWORD *)this + 1) + 30360LL);
++nglog::LogMessage::num_messages_[v10];
pthread_mutex_unlock(&nglog::log_mutex);
result = nglog::LogDestination::WaitForSinks(*((nglog::LogDestination **)this + 1), a2);
if ( v5 != 10 )
{
result = *((_QWORD *)this + 1);
*(_BYTE *)(*(_QWORD *)(result + 30400) + result + 3) = v6;
}
v11 = (int *)*((_QWORD *)this + 1);
v12 = *v11;
if ( *v11 )
{
result = __errno_location();
*(_DWORD *)result = v12;
}
*((_BYTE *)v11 + 30432) = 1;
}
return result;
}
|
Flush:
PUSH RBP
PUSH R14
PUSH RBX
MOV RAX,qword ptr [RDI + 0x8]
CMP byte ptr [RAX + 0x76e0],0x0
JNZ 0x0010c30f
MOV ECX,dword ptr [RAX + 0x7698]
LEA RDX,[0x131b20]
CMP ECX,dword ptr [RDX]
JL 0x0010c30f
MOV RBX,RDI
MOV RCX,qword ptr [RAX + 0x7568]
SUB RCX,qword ptr [RAX + 0x7560]
MOV qword ptr [RAX + 0x76c0],RCX
MOV RDX,RCX
SUB RDX,qword ptr [RAX + 0x76b8]
MOV qword ptr [RAX + 0x76c8],RDX
MOV R14B,byte ptr [RCX + RAX*0x1 + 0x3]
CMP R14B,0xa
JNZ 0x0010c262
XOR EBP,EBP
JMP 0x0010c282
LAB_0010c262:
MOV BPL,byte ptr [RAX + RCX*0x1 + 0x4]
LEA RDX,[RCX + 0x1]
MOV qword ptr [RAX + 0x76c0],RDX
MOV byte ptr [RAX + RCX*0x1 + 0x4],0xa
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RAX + 0x76c0]
LAB_0010c282:
MOV byte ptr [RAX + RCX*0x1 + 0x4],0x0
LEA RDI,[0x140db8]
CALL 0x0011cc6a
MOV RCX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RCX + 0x76a0]
MOV RDI,qword ptr [RCX + 0x76a8]
ADD RDI,RBX
TEST AL,0x1
JZ 0x0010c2b4
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RCX + RAX*0x1 + -0x1]
LAB_0010c2b4:
CALL RAX
LAB_0010c2b6:
MOV RAX,qword ptr [RBX + 0x8]
MOVSXD RAX,dword ptr [RAX + 0x7698]
LEA RCX,[0x131c30]
INC qword ptr [RCX + RAX*0x8]
LEA RDI,[0x140db8]
CALL 0x00108450
MOV RDI,qword ptr [RBX + 0x8]
CALL 0x0010ffd0
CMP R14B,0xa
JZ 0x0010c2f7
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RAX + 0x76c0]
MOV byte ptr [RCX + RAX*0x1 + 0x3],BPL
LAB_0010c2f7:
MOV RBX,qword ptr [RBX + 0x8]
MOV EBP,dword ptr [RBX]
TEST EBP,EBP
JZ 0x0010c308
CALL 0x00108050
MOV dword ptr [RAX],EBP
LAB_0010c308:
MOV byte ptr [RBX + 0x76e0],0x1
LAB_0010c30f:
POP RBX
POP R14
POP RBP
RET
|
/* nglog::LogMessage::Flush() */
void __thiscall nglog::LogMessage::Flush(LogMessage *this)
{
char cVar1;
int iVar2;
int *piVar3;
long lVar4;
code *pcVar5;
int *piVar6;
long lVar7;
int1 uVar8;
lVar4 = *(long *)(this + 8);
if ((*(char *)(lVar4 + 0x76e0) == '\0') && (fLI::FLAGS_minloglevel <= *(int *)(lVar4 + 0x7698))) {
lVar7 = *(long *)(lVar4 + 0x7568) - *(long *)(lVar4 + 0x7560);
*(long *)(lVar4 + 0x76c0) = lVar7;
*(long *)(lVar4 + 0x76c8) = lVar7 - *(long *)(lVar4 + 0x76b8);
cVar1 = *(char *)(lVar7 + 3 + lVar4);
if (cVar1 == '\n') {
uVar8 = 0;
}
else {
uVar8 = *(int1 *)(lVar4 + 4 + lVar7);
*(long *)(lVar4 + 0x76c0) = lVar7 + 1;
*(int1 *)(lVar4 + 4 + lVar7) = 10;
lVar4 = *(long *)(this + 8);
lVar7 = *(long *)(lVar4 + 0x76c0);
}
*(int1 *)(lVar4 + 4 + lVar7) = 0;
std::mutex::lock((mutex *)log_mutex);
pcVar5 = *(code **)(*(long *)(this + 8) + 0x76a0);
if (((ulong)pcVar5 & 1) != 0) {
pcVar5 = *(code **)(pcVar5 + *(long *)(this + *(long *)(*(long *)(this + 8) + 0x76a8)) + -1);
}
/* try { // try from 0010c2b4 to 0010c2b5 has its CatchHandler @ 0010c314 */
(*pcVar5)();
*(long *)(num_messages_ + (long)*(int *)(*(long *)(this + 8) + 0x7698) * 8) =
*(long *)(num_messages_ + (long)*(int *)(*(long *)(this + 8) + 0x7698) * 8) + 1;
pthread_mutex_unlock((pthread_mutex_t *)log_mutex);
LogDestination::WaitForSinks(*(LogMessageData **)(this + 8));
if (cVar1 != '\n') {
*(int1 *)(*(long *)(*(long *)(this + 8) + 0x76c0) + 3 + *(long *)(this + 8)) = uVar8;
}
piVar3 = *(int **)(this + 8);
iVar2 = *piVar3;
if (iVar2 != 0) {
piVar6 = __errno_location();
*piVar6 = iVar2;
}
*(int1 *)(piVar3 + 0x1db8) = 1;
}
return;
}
|
|
10,853 |
set_default_charset
|
eloqsql/libmariadb/libmariadb/mariadb_charset.c
|
my_bool set_default_charset(uint cs, myf flags __attribute__((unused)))
{
MARIADB_CHARSET_INFO *new_charset;
new_charset = mysql_get_charset_by_nr(cs);
if (!new_charset)
{
return(TRUE); /* error */
}
ma_default_charset_info = new_charset;
return(FALSE);
}
|
O0
|
c
|
set_default_charset:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x6ab80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6ac47
movb $0x1, -0x1(%rbp)
jmp 0x6ac59
movq -0x18(%rbp), %rcx
leaq 0x3824b6(%rip), %rax # 0x3ed108
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
set_default_charset:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], edi
mov [rbp+var_C], esi
mov edi, [rbp+var_8]
call mysql_get_charset_by_nr
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jnz short loc_6AC47
mov [rbp+var_1], 1
jmp short loc_6AC59
loc_6AC47:
mov rcx, [rbp+var_18]
lea rax, ma_default_charset_info
mov [rax], rcx
mov [rbp+var_1], 0
loc_6AC59:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char set_default_charset(int a1)
{
char *charset_by_nr; // [rsp+8h] [rbp-18h]
charset_by_nr = mysql_get_charset_by_nr(a1);
if ( !charset_by_nr )
return 1;
ma_default_charset_info = charset_by_nr;
return 0;
}
|
set_default_charset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x8],EDI
MOV dword ptr [RBP + -0xc],ESI
MOV EDI,dword ptr [RBP + -0x8]
CALL 0x0016ab80
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0016ac47
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0016ac59
LAB_0016ac47:
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x4ed108]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x1],0x0
LAB_0016ac59:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int8 set_default_charset(int4 param_1)
{
long lVar1;
int8 *puVar2;
bool local_9;
lVar1 = mysql_get_charset_by_nr(param_1);
if (lVar1 != 0) {
puVar2 = &ma_default_charset_info;
ma_default_charset_info = lVar1;
}
else {
puVar2 = (int8 *)0x0;
}
local_9 = lVar1 == 0;
return CONCAT71((int7)((ulong)puVar2 >> 8),local_9);
}
|
|
10,854 |
my_copy_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t
my_copy_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
set_if_smaller(src_length, dst_length);
set_if_smaller(src_length, nchars);
if (src_length)
memmove(dst, src, src_length);
status->m_source_end_pos= src + src_length;
status->m_well_formed_error_pos= NULL;
return src_length;
}
|
O0
|
c
|
my_copy_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
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 -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x55776
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x55778
jmp 0x5577a
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x5578c
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5578e
cmpq $0x0, -0x28(%rbp)
je 0x557a6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x25590
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
my_copy_8bit:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_28]
cmp rax, [rbp+var_18]
jbe short loc_55776
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_55776:
jmp short $+2
loc_55778:
jmp short $+2
loc_5577A:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jbe short loc_5578C
mov rax, [rbp+var_30]
mov [rbp+var_28], rax
loc_5578C:
jmp short $+2
loc_5578E:
cmp [rbp+var_28], 0
jz short loc_557A6
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call _memmove
loc_557A6:
mov rcx, [rbp+var_20]
add rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax], rcx
mov rax, [rbp+arg_0]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
|
unsigned long long my_copy_8bit(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
unsigned long long a6,
_QWORD *a7)
{
unsigned long long v8; // [rsp+8h] [rbp-28h]
v8 = a5;
if ( a5 > a3 )
v8 = a3;
if ( v8 > a6 )
v8 = a6;
if ( v8 )
memmove(a2, a4, v8);
*a7 = v8 + a4;
a7[1] = 0LL;
return v8;
}
|
my_copy_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00155776
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
LAB_00155776:
JMP 0x00155778
LAB_00155778:
JMP 0x0015577a
LAB_0015577a:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x0015578c
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
LAB_0015578c:
JMP 0x0015578e
LAB_0015578e:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001557a6
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00125590
LAB_001557a6:
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
size_t my_copy_8bit(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
ulong param_6,long *param_7)
{
ulong local_30;
local_30 = param_5;
if (param_3 < param_5) {
local_30 = param_3;
}
if (param_6 < local_30) {
local_30 = param_6;
}
if (local_30 != 0) {
memmove(param_2,param_4,local_30);
}
*param_7 = (long)param_4 + local_30;
param_7[1] = 0;
return local_30;
}
|
|
10,855 |
PVG_FT_MulFix
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-math.c
|
PVG_FT_Long PVG_FT_MulFix(PVG_FT_Long a, PVG_FT_Long b)
{
PVG_FT_Int s = 1;
PVG_FT_Long c;
PVG_FT_MOVE_SIGN(a, s);
PVG_FT_MOVE_SIGN(b, s);
c = (PVG_FT_Long)(((PVG_FT_Int64)a * b + 0x8000L) >> 16);
return (s > 0) ? c : -c;
}
|
O1
|
c
|
PVG_FT_MulFix:
movq %rdi, %rax
sarq $0x3f, %rax
orl $0x1, %eax
movl %eax, %ecx
negl %ecx
testq %rsi, %rsi
cmovnsl %eax, %ecx
imulq %rdi, %rsi
movq %rsi, %rdx
negq %rdx
cmovsq %rsi, %rdx
addq $0x8000, %rdx # imm = 0x8000
shrq $0x10, %rdx
movq %rdx, %rax
negq %rax
testl %ecx, %ecx
cmovgq %rdx, %rax
retq
|
PVG_FT_MulFix:
mov rax, rdi
sar rax, 3Fh
or eax, 1
mov ecx, eax
neg ecx
test rsi, rsi
cmovns ecx, eax
imul rsi, rdi
mov rdx, rsi
neg rdx
cmovs rdx, rsi
add rdx, 8000h
shr rdx, 10h
mov rax, rdx
neg rax
test ecx, ecx
cmovg rax, rdx
retn
|
unsigned long long PVG_FT_MulFix(long long a1, long long a2)
{
int v2; // ecx
long long v3; // rsi
long long v4; // rdx
unsigned long long v5; // rdx
unsigned long long result; // rax
v2 = -((a1 >> 63) | 1);
if ( a2 >= 0 )
v2 = (a1 >> 63) | 1;
v3 = a1 * a2;
v4 = -v3;
if ( v3 > 0 )
v4 = v3;
v5 = (unsigned long long)(v4 + 0x8000) >> 16;
result = -(long long)v5;
if ( v2 > 0 )
return v5;
return result;
}
|
PVG_FT_MulFix:
MOV RAX,RDI
SAR RAX,0x3f
OR EAX,0x1
MOV ECX,EAX
NEG ECX
TEST RSI,RSI
CMOVNS ECX,EAX
IMUL RSI,RDI
MOV RDX,RSI
NEG RDX
CMOVS RDX,RSI
ADD RDX,0x8000
SHR RDX,0x10
MOV RAX,RDX
NEG RAX
TEST ECX,ECX
CMOVG RAX,RDX
RET
|
ulong PVG_FT_MulFix(long param_1,long param_2)
{
uint uVar1;
uint uVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
uVar2 = (uint)(param_1 >> 0x3f) | 1;
uVar1 = -uVar2;
if (-1 < param_2) {
uVar1 = uVar2;
}
param_2 = param_2 * param_1;
lVar4 = -param_2;
if (0 < param_2) {
lVar4 = param_2;
}
uVar5 = lVar4 + 0x8000U >> 0x10;
uVar3 = -uVar5;
if (0 < (int)uVar1) {
uVar3 = uVar5;
}
return uVar3;
}
|
|
10,856 |
PVG_FT_MulFix
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-math.c
|
PVG_FT_Long PVG_FT_MulFix(PVG_FT_Long a, PVG_FT_Long b)
{
PVG_FT_Int s = 1;
PVG_FT_Long c;
PVG_FT_MOVE_SIGN(a, s);
PVG_FT_MOVE_SIGN(b, s);
c = (PVG_FT_Long)(((PVG_FT_Int64)a * b + 0x8000L) >> 16);
return (s > 0) ? c : -c;
}
|
O2
|
c
|
PVG_FT_MulFix:
movq %rdi, %rax
sarq $0x3f, %rax
orl $0x1, %eax
movl %eax, %ecx
negl %ecx
testq %rsi, %rsi
cmovnsl %eax, %ecx
imulq %rdi, %rsi
movq %rsi, %rdx
negq %rdx
cmovsq %rsi, %rdx
addq $0x8000, %rdx # imm = 0x8000
shrq $0x10, %rdx
movq %rdx, %rax
negq %rax
testl %ecx, %ecx
cmovgq %rdx, %rax
retq
|
PVG_FT_MulFix:
mov rax, rdi
sar rax, 3Fh
or eax, 1
mov ecx, eax
neg ecx
test rsi, rsi
cmovns ecx, eax
imul rsi, rdi
mov rdx, rsi
neg rdx
cmovs rdx, rsi
add rdx, 8000h
shr rdx, 10h
mov rax, rdx
neg rax
test ecx, ecx
cmovg rax, rdx
retn
|
unsigned long long PVG_FT_MulFix(long long a1, long long a2)
{
int v2; // ecx
long long v3; // rsi
long long v4; // rdx
unsigned long long v5; // rdx
unsigned long long result; // rax
v2 = -((a1 >> 63) | 1);
if ( a2 >= 0 )
v2 = (a1 >> 63) | 1;
v3 = a1 * a2;
v4 = -v3;
if ( v3 > 0 )
v4 = v3;
v5 = (unsigned long long)(v4 + 0x8000) >> 16;
result = -(long long)v5;
if ( v2 > 0 )
return v5;
return result;
}
|
PVG_FT_MulFix:
MOV RAX,RDI
SAR RAX,0x3f
OR EAX,0x1
MOV ECX,EAX
NEG ECX
TEST RSI,RSI
CMOVNS ECX,EAX
IMUL RSI,RDI
MOV RDX,RSI
NEG RDX
CMOVS RDX,RSI
ADD RDX,0x8000
SHR RDX,0x10
MOV RAX,RDX
NEG RAX
TEST ECX,ECX
CMOVG RAX,RDX
RET
|
ulong PVG_FT_MulFix(long param_1,long param_2)
{
uint uVar1;
uint uVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
uVar2 = (uint)(param_1 >> 0x3f) | 1;
uVar1 = -uVar2;
if (-1 < param_2) {
uVar1 = uVar2;
}
param_2 = param_2 * param_1;
lVar4 = -param_2;
if (0 < param_2) {
lVar4 = param_2;
}
uVar5 = lVar4 + 0x8000U >> 0x10;
uVar3 = -uVar5;
if (0 < (int)uVar1) {
uVar3 = uVar5;
}
return uVar3;
}
|
|
10,857 |
google::protobuf::Descriptor::map_value() const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc
|
const FieldDescriptor* Descriptor::map_value() const {
if (!options().map_entry()) return nullptr;
GOOGLE_DCHECK_EQ(field_count(), 2);
return field(1);
}
|
O0
|
cpp
|
google::protobuf::Descriptor::map_value() const:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x748b0
movq %rax, %rdi
callq 0x74f40
testb $0x1, %al
jne 0x36802
movq $0x0, 0x70(%rsp)
jmp 0x368c2
jmp 0x36804
xorl %eax, %eax
testb $0x1, %al
jne 0x3680f
jmp 0x368ae
movq 0x10(%rsp), %rdi
callq 0x74f60
movb $0x0, 0x2f(%rsp)
cmpl $0x2, %eax
jne 0x36825
jmp 0x36873
leaq 0x1b6ca8(%rip), %rdx # 0x1ed4d4
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x3, %esi
movl $0x8f5, %ecx # imm = 0x8F5
callq 0x237e0
movq (%rsp), %rdi
movb $0x1, 0x2f(%rsp)
leaq 0x1b6fd9(%rip), %rsi # 0x1ed82d
callq 0x230a0
movq %rax, 0x8(%rsp)
jmp 0x36860
movq 0x8(%rsp), %rsi
leaq 0x1b(%rsp), %rdi
callq 0x23250
jmp 0x36871
jmp 0x36873
testb $0x1, 0x2f(%rsp)
jne 0x3687c
jmp 0x36886
leaq 0x30(%rsp), %rdi
callq 0x23820
jmp 0x36804
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x368a2
jmp 0x368ac
leaq 0x30(%rsp), %rdi
callq 0x23820
jmp 0x368cc
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x73dc0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13750
nopw %cs:(%rax,%rax)
|
_ZNK6google8protobuf10Descriptor9map_valueEv:
sub rsp, 78h
mov [rsp+78h+var_10], rdi
mov rdi, [rsp+78h+var_10]; this
mov [rsp+78h+var_68], rdi
call _ZNK6google8protobuf10Descriptor7optionsEv; google::protobuf::Descriptor::options(void)
mov rdi, rax; this
call _ZNK6google8protobuf14MessageOptions9map_entryEv; google::protobuf::MessageOptions::map_entry(void)
test al, 1
jnz short loc_36802
mov [rsp+78h+var_8], 0
jmp loc_368C2
loc_36802:
jmp short $+2
loc_36804:
xor eax, eax
test al, 1
jnz short loc_3680F
jmp loc_368AE
loc_3680F:
mov rdi, [rsp+78h+var_68]; this
call _ZNK6google8protobuf10Descriptor11field_countEv; google::protobuf::Descriptor::field_count(void)
mov [rsp+78h+var_49], 0
cmp eax, 2
jnz short loc_36825
jmp short loc_36873
loc_36825:
lea rdx, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+78h+var_48]
mov [rsp+78h+var_78], rdi
mov esi, 3
mov ecx, 8F5h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+78h+var_78]
mov [rsp+78h+var_49], 1
lea rsi, aCheckFailedFie; "CHECK failed: (field_count()) == (2): "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+78h+var_70], rax
jmp short $+2
loc_36860:
mov rsi, [rsp+78h+var_70]
lea rdi, [rsp+78h+var_5D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_36871:
jmp short $+2
loc_36873:
test [rsp+78h+var_49], 1
jnz short loc_3687C
jmp short loc_36886
loc_3687C:
lea rdi, [rsp+78h+var_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_36886:
jmp loc_36804
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
test [rsp+arg_27], 1
jnz short loc_368A2
jmp short loc_368AC
loc_368A2:
lea rdi, [rsp+arg_28]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_368AC:
jmp short loc_368CC
loc_368AE:
mov rdi, [rsp+78h+var_68]; this
mov esi, 1; int
call _ZNK6google8protobuf10Descriptor5fieldEi; google::protobuf::Descriptor::field(int)
mov [rsp+78h+var_8], rax
loc_368C2:
mov rax, [rsp+78h+var_8]
add rsp, 78h
retn
loc_368CC:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
|
long long google::protobuf::Descriptor::map_value(google::protobuf::Descriptor *this)
{
google::protobuf::MessageOptions *v1; // rax
v1 = (google::protobuf::MessageOptions *)google::protobuf::Descriptor::options(this);
if ( (google::protobuf::MessageOptions::map_entry(v1) & 1) != 0 )
return google::protobuf::Descriptor::field(this, 1);
else
return 0LL;
}
|
map_value:
SUB RSP,0x78
MOV qword ptr [RSP + 0x68],RDI
MOV RDI,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x001748b0
MOV RDI,RAX
CALL 0x00174f40
TEST AL,0x1
JNZ 0x00136802
MOV qword ptr [RSP + 0x70],0x0
JMP 0x001368c2
LAB_00136802:
JMP 0x00136804
LAB_00136804:
XOR EAX,EAX
TEST AL,0x1
JNZ 0x0013680f
JMP 0x001368ae
LAB_0013680f:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00174f60
MOV byte ptr [RSP + 0x2f],0x0
CMP EAX,0x2
JNZ 0x00136825
JMP 0x00136873
LAB_00136825:
LEA RDX,[0x2ed4d4]
LEA RDI,[RSP + 0x30]
MOV qword ptr [RSP],RDI
MOV ESI,0x3
MOV ECX,0x8f5
CALL 0x001237e0
MOV RDI,qword ptr [RSP]
MOV byte ptr [RSP + 0x2f],0x1
LAB_0013684d:
LEA RSI,[0x2ed82d]
CALL 0x001230a0
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00136860
LAB_00136860:
MOV RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x1b]
CALL 0x00123250
LAB_0013686f:
JMP 0x00136871
LAB_00136871:
JMP 0x00136873
LAB_00136873:
TEST byte ptr [RSP + 0x2f],0x1
JNZ 0x0013687c
JMP 0x00136886
LAB_0013687c:
LEA RDI,[RSP + 0x30]
CALL 0x00123820
LAB_00136886:
JMP 0x00136804
LAB_001368ae:
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,0x1
CALL 0x00173dc0
MOV qword ptr [RSP + 0x70],RAX
LAB_001368c2:
MOV RAX,qword ptr [RSP + 0x70]
ADD RSP,0x78
RET
|
/* WARNING: Removing unreachable block (ram,0x0013680f) */
/* WARNING: Removing unreachable block (ram,0x00136825) */
/* WARNING: Removing unreachable block (ram,0x00136823) */
/* WARNING: Removing unreachable block (ram,0x00136873) */
/* WARNING: Removing unreachable block (ram,0x0013687c) */
/* WARNING: Removing unreachable block (ram,0x0013687a) */
/* WARNING: Removing unreachable block (ram,0x00136886) */
/* google::protobuf::Descriptor::map_value() const */
int8 __thiscall google::protobuf::Descriptor::map_value(Descriptor *this)
{
MessageOptions *this_00;
ulong uVar1;
int8 local_8;
this_00 = (MessageOptions *)options(this);
uVar1 = MessageOptions::map_entry(this_00);
if ((uVar1 & 1) == 0) {
local_8 = 0;
}
else {
local_8 = field(this,1);
}
return local_8;
}
|
|
10,858 |
LefDefParser::defwBlockagesLayerPushdown()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp
|
int
defwBlockagesLayerPushdown()
{
defwFunc = DEFW_BLOCKAGE_LAYER; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if ((defwState != DEFW_BLOCKAGE_LAYER) && (defwState != DEFW_BLOCKAGE_RECT))
return DEFW_BAD_ORDER;
if (defwState == DEFW_BLOCKAGE_RECT)
fprintf(defwFile, " ;\n"); // end the previous rectangle
fprintf(defwFile, " + PUSHDOWN\n");
defwLines++;
defwState = DEFW_BLOCKAGE_LAYER;
return DEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::defwBlockagesLayerPushdown():
pushq %rax
leaq 0xc9d0(%rip), %rax # 0x2b168
movl $0x2c, (%rax)
leaq 0xc9b3(%rip), %rax # 0x2b158
cmpq $0x0, (%rax)
jne 0x1e7b8
movl $0x1, 0x4(%rsp)
jmp 0x1e840
leaq 0xc9a5(%rip), %rax # 0x2b164
cmpl $0x2c, (%rax)
je 0x1e7da
leaq 0xc999(%rip), %rax # 0x2b164
cmpl $0x2e, (%rax)
je 0x1e7da
movl $0x2, 0x4(%rsp)
jmp 0x1e840
leaq 0xc983(%rip), %rax # 0x2b164
cmpl $0x2e, (%rax)
jne 0x1e7fe
leaq 0xc96b(%rip), %rax # 0x2b158
movq (%rax), %rdi
leaq 0x565b(%rip), %rsi # 0x23e52
movb $0x0, %al
callq 0x10f0
leaq 0xc953(%rip), %rax # 0x2b158
movq (%rax), %rdi
leaq 0x683f(%rip), %rsi # 0x2504e
movb $0x0, %al
callq 0x10f0
leaq 0xc943(%rip), %rax # 0x2b160
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xc937(%rip), %rax # 0x2b160
movl %ecx, (%rax)
leaq 0xc932(%rip), %rax # 0x2b164
movl $0x2c, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
|
_ZN12LefDefParser26defwBlockagesLayerPushdownEv:
push rax
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 2Ch ; ','
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
cmp qword ptr [rax], 0
jnz short loc_1E7B8
mov [rsp+8+var_4], 1
jmp loc_1E840
loc_1E7B8:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 2Ch ; ','
jz short loc_1E7DA
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 2Eh ; '.'
jz short loc_1E7DA
mov [rsp+8+var_4], 2
jmp short loc_1E840
loc_1E7DA:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 2Eh ; '.'
jnz short loc_1E7FE
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
lea rsi, aDividercharS+10h; " ;\n"
mov al, 0
call _fprintf
loc_1E7FE:
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
lea rsi, aPushdown; " + PUSHDOWN\n"
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov dword ptr [rax], 2Ch ; ','
mov [rsp+8+var_4], 0
loc_1E840:
mov eax, [rsp+8+var_4]
pop rcx
retn
|
long long LefDefParser::defwBlockagesLayerPushdown(LefDefParser *this)
{
LefDefParser::defwFunc = 44;
if ( LefDefParser::defwFile )
{
if ( LefDefParser::defwState == 44 || LefDefParser::defwState == 46 )
{
if ( LefDefParser::defwState == 46 )
fprintf(LefDefParser::defwFile, " ;\n");
fprintf(LefDefParser::defwFile, " + PUSHDOWN\n");
++LefDefParser::defwLines;
LefDefParser::defwState = 44;
return 0;
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
defwBlockagesLayerPushdown:
PUSH RAX
LEA RAX,[0x12b168]
MOV dword ptr [RAX],0x2c
LEA RAX,[0x12b158]
CMP qword ptr [RAX],0x0
JNZ 0x0011e7b8
MOV dword ptr [RSP + 0x4],0x1
JMP 0x0011e840
LAB_0011e7b8:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x2c
JZ 0x0011e7da
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x2e
JZ 0x0011e7da
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0011e840
LAB_0011e7da:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x2e
JNZ 0x0011e7fe
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x123e52]
MOV AL,0x0
CALL 0x001010f0
LAB_0011e7fe:
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12504e]
MOV AL,0x0
CALL 0x001010f0
LEA RAX,[0x12b160]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x12b160]
MOV dword ptr [RAX],ECX
LEA RAX,[0x12b164]
MOV dword ptr [RAX],0x2c
MOV dword ptr [RSP + 0x4],0x0
LAB_0011e840:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::defwBlockagesLayerPushdown() */
int4 LefDefParser::defwBlockagesLayerPushdown(void)
{
int4 local_4;
defwFunc = 0x2c;
if (defwFile == (FILE *)0x0) {
local_4 = 1;
}
else if ((defwState == 0x2c) || (defwState == 0x2e)) {
if (defwState == 0x2e) {
fprintf(defwFile," ;\n");
}
fprintf(defwFile," + PUSHDOWN\n");
defwLines = defwLines + 1;
defwState = 0x2c;
local_4 = 0;
}
else {
local_4 = 2;
}
return local_4;
}
|
|
10,859 |
LefDefParser::defwBlockagesLayerPushdown()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp
|
int
defwBlockagesLayerPushdown()
{
defwFunc = DEFW_BLOCKAGE_LAYER; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if ((defwState != DEFW_BLOCKAGE_LAYER) && (defwState != DEFW_BLOCKAGE_RECT))
return DEFW_BAD_ORDER;
if (defwState == DEFW_BLOCKAGE_RECT)
fprintf(defwFile, " ;\n"); // end the previous rectangle
fprintf(defwFile, " + PUSHDOWN\n");
defwLines++;
defwState = DEFW_BLOCKAGE_LAYER;
return DEFW_OK;
}
|
O3
|
cpp
|
LefDefParser::defwBlockagesLayerPushdown():
pushq %r14
pushq %rbx
pushq %rax
leaq 0xd26b(%rip), %rax # 0x1e178
movl $0x2c, (%rax)
leaq 0xd24e(%rip), %r14 # 0x1e168
movq (%r14), %rcx
testq %rcx, %rcx
je 0x10f81
leaq 0xd24b(%rip), %rbx # 0x1e174
movl (%rbx), %edx
movl %edx, %esi
andl $-0x3, %esi
movl $0x2, %eax
cmpl $0x2c, %esi
jne 0x10f86
cmpl $0x2e, %edx
jne 0x10f58
leaq 0x404b(%rip), %rdi # 0x14f91
movl $0x3, %esi
movl $0x1, %edx
callq 0x1110
movq (%r14), %rcx
leaq 0x522e(%rip), %rdi # 0x1618d
movl $0x10, %esi
movl $0x1, %edx
callq 0x1110
leaq 0xd1fb(%rip), %rax # 0x1e170
incl (%rax)
movl $0x2c, (%rbx)
xorl %eax, %eax
jmp 0x10f86
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZN12LefDefParser26defwBlockagesLayerPushdownEv:
push r14
push rbx
push rax
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 2Ch ; ','
lea r14, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rcx, [r14]
test rcx, rcx
jz short loc_10F81
lea rbx, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov edx, [rbx]
mov esi, edx
and esi, 0FFFFFFFDh
mov eax, 2
cmp esi, 2Ch ; ','
jnz short loc_10F86
cmp edx, 2Eh ; '.'
jnz short loc_10F58
lea rdi, aDividercharS+10h; " ;\n"
mov esi, 3
mov edx, 1
call _fwrite
mov rcx, [r14]
loc_10F58:
lea rdi, aPushdown; " + PUSHDOWN\n"
mov esi, 10h
mov edx, 1
call _fwrite
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
inc dword ptr [rax]
mov dword ptr [rbx], 2Ch ; ','
xor eax, eax
jmp short loc_10F86
loc_10F81:
mov eax, 1
loc_10F86:
add rsp, 8
pop rbx
pop r14
retn
|
long long LefDefParser::defwBlockagesLayerPushdown(LefDefParser *this)
{
long long v1; // rcx
long long result; // rax
LefDefParser::defwFunc = 44;
v1 = LefDefParser::defwFile;
if ( !LefDefParser::defwFile )
return 1LL;
result = 2LL;
if ( (LefDefParser::defwState & 0xFFFFFFFD) == 0x2C )
{
if ( LefDefParser::defwState == 46 )
{
fwrite(" ;\n", 3LL, 1LL, LefDefParser::defwFile);
v1 = LefDefParser::defwFile;
}
fwrite(" + PUSHDOWN\n", 16LL, 1LL, v1);
++LefDefParser::defwLines;
LefDefParser::defwState = 44;
return 0LL;
}
return result;
}
|
defwBlockagesLayerPushdown:
PUSH R14
PUSH RBX
PUSH RAX
LEA RAX,[0x11e178]
MOV dword ptr [RAX],0x2c
LEA R14,[0x11e168]
MOV RCX,qword ptr [R14]
TEST RCX,RCX
JZ 0x00110f81
LEA RBX,[0x11e174]
MOV EDX,dword ptr [RBX]
MOV ESI,EDX
AND ESI,0xfffffffd
MOV EAX,0x2
CMP ESI,0x2c
JNZ 0x00110f86
CMP EDX,0x2e
JNZ 0x00110f58
LEA RDI,[0x114f91]
MOV ESI,0x3
MOV EDX,0x1
CALL 0x00101110
MOV RCX,qword ptr [R14]
LAB_00110f58:
LEA RDI,[0x11618d]
MOV ESI,0x10
MOV EDX,0x1
CALL 0x00101110
LEA RAX,[0x11e170]
INC dword ptr [RAX]
MOV dword ptr [RBX],0x2c
XOR EAX,EAX
JMP 0x00110f86
LAB_00110f81:
MOV EAX,0x1
LAB_00110f86:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* LefDefParser::defwBlockagesLayerPushdown() */
int8 LefDefParser::defwBlockagesLayerPushdown(void)
{
int8 uVar1;
defwFunc = 0x2c;
if (defwFile == (FILE *)0x0) {
uVar1 = 1;
}
else {
uVar1 = 2;
if ((defwState & 0xfffffffd) == 0x2c) {
if (defwState == 0x2e) {
fwrite(" ;\n",3,1,defwFile);
}
fwrite(" + PUSHDOWN\n",0x10,1,defwFile);
defwLines = defwLines + 1;
defwState = 0x2c;
uVar1 = 0;
}
}
return uVar1;
}
|
|
10,860 |
cleanup_memory_class()
|
eloqsql/storage/perfschema/pfs_instr_class.cc
|
void cleanup_memory_class(void)
{
PFS_FREE_ARRAY(& builtin_memory_memory_class,
memory_class_max, sizeof(PFS_memory_class),
memory_class_array);
memory_class_array= NULL;
memory_class_dirty_count= memory_class_allocated_count= 0;
memory_class_max= 0;
}
|
O0
|
cpp
|
cleanup_memory_class():
pushq %rbp
movq %rsp, %rbp
movq 0x3ca075(%rip), %rsi # 0x40c600
movq 0x3ca906(%rip), %rcx # 0x40ce98
leaq 0x3c7967(%rip), %rdi # 0x409f00
movl $0xc0, %edx
callq 0x29be0
movq $0x0, 0x3ca8ea(%rip) # 0x40ce98
movl $0x0, 0x3ca8d8(%rip) # 0x40ce90
movl $0x0, 0x3ca8d2(%rip) # 0x40ce94
movq $0x0, 0x3ca033(%rip) # 0x40c600
popq %rbp
retq
nop
|
_Z20cleanup_memory_classv:
push rbp
mov rbp, rsp
mov rsi, cs:memory_class_max
mov rcx, cs:_ZL18memory_class_array; memory_class_array
lea rdi, builtin_memory_memory_class
mov edx, 0C0h
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov cs:_ZL18memory_class_array, 0; memory_class_array
mov cs:_ZL28memory_class_allocated_count, 0; memory_class_allocated_count
mov cs:_ZL24memory_class_dirty_count, 0; memory_class_dirty_count
mov cs:memory_class_max, 0
pop rbp
retn
|
long long cleanup_memory_class(void)
{
long long result; // rax
result = pfs_free_array(
(PFS_builtin_memory_class *)&builtin_memory_memory_class,
memory_class_max,
192LL,
(void *)memory_class_array);
memory_class_array = 0LL;
memory_class_allocated_count = 0;
memory_class_dirty_count = 0;
memory_class_max = 0LL;
return result;
}
|
cleanup_memory_class:
PUSH RBP
MOV RBP,RSP
MOV RSI,qword ptr [0x0050c600]
MOV RCX,qword ptr [0x0050ce98]
LEA RDI,[0x509f00]
MOV EDX,0xc0
CALL 0x00129be0
MOV qword ptr [0x0050ce98],0x0
MOV dword ptr [0x0050ce90],0x0
MOV dword ptr [0x0050ce94],0x0
MOV qword ptr [0x0050c600],0x0
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cleanup_memory_class() */
void cleanup_memory_class(void)
{
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_memory_class,memory_class_max,0xc0,
memory_class_array);
memory_class_array = (void *)0x0;
memory_class_allocated_count = 0;
memory_class_dirty_count = 0;
memory_class_max = 0;
return;
}
|
|
10,861 |
reciprocal_fp2
|
corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/recip.c
|
static void reciprocal_fp2(vec384x out, const vec384x inp)
{
vec384 t0, t1;
/*
* |out| = 1/(a + b*i) = a/(a^2+b^2) - b/(a^2+b^2)*i
*/
sqr_fp(t0, inp[0]);
sqr_fp(t1, inp[1]);
add_fp(t0, t0, t1);
reciprocal_fp(t1, t0);
mul_fp(out[0], inp[0], t1);
mul_fp(out[1], inp[1], t1);
neg_fp(out[1], out[1]);
}
|
O0
|
c
|
reciprocal_fp2:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb2560
leaq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0xb2560
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xafde0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb25d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xb6080
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
leaq -0x70(%rbp), %rdx
callq 0xb6080
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rsi
addq $0x30, %rsi
movl $0x1, %edx
callq 0xafe20
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
reciprocal_fp2:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
lea rdi, [rbp+var_40]
mov rsi, [rbp+var_10]
call sqr_fp
lea rdi, [rbp+var_70]
mov rsi, [rbp+var_10]
add rsi, 30h ; '0'
call sqr_fp
lea rdi, [rbp+var_40]
lea rsi, [rbp+var_40]
lea rdx, [rbp+var_70]
call add_fp
lea rdi, [rbp+var_70]
lea rsi, [rbp+var_40]
call reciprocal_fp
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_70]
call mul_fp
mov rdi, [rbp+var_8]
add rdi, 30h ; '0'
mov rsi, [rbp+var_10]
add rsi, 30h ; '0'
lea rdx, [rbp+var_70]
call mul_fp
mov rdi, [rbp+var_8]
add rdi, 30h ; '0'
mov rsi, [rbp+var_8]
add rsi, 30h ; '0'
mov edx, 1
call cneg_fp
add rsp, 70h
pop rbp
retn
|
long long reciprocal_fp2(long long a1, long long a2)
{
_BYTE v3[48]; // [rsp+0h] [rbp-70h] BYREF
_BYTE v4[48]; // [rsp+30h] [rbp-40h] BYREF
long long v5; // [rsp+60h] [rbp-10h]
long long v6; // [rsp+68h] [rbp-8h]
v6 = a1;
v5 = a2;
sqr_fp((long long)v4, a2);
sqr_fp((long long)v3, v5 + 48);
add_fp((long long)v4, (long long)v4, (long long)v3);
reciprocal_fp((long long)v3, (long long)v4);
mul_fp(v6, v5, v3);
mul_fp(v6 + 48, v5 + 48, v3);
return cneg_fp(v6 + 48, v6 + 48, 1LL);
}
|
reciprocal_fp2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RDI,[RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001b2560
LEA RDI,[RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x30
CALL 0x001b2560
LEA RDI,[RBP + -0x40]
LEA RSI,[RBP + -0x40]
LEA RDX,[RBP + -0x70]
CALL 0x001afde0
LEA RDI,[RBP + -0x70]
LEA RSI,[RBP + -0x40]
CALL 0x001b25d0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x70]
CALL 0x001b6080
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x30
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x30
LEA RDX,[RBP + -0x70]
CALL 0x001b6080
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x30
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x30
MOV EDX,0x1
CALL 0x001afe20
ADD RSP,0x70
POP RBP
RET
|
void reciprocal_fp2(long param_1,long param_2)
{
int1 local_78 [48];
int1 local_48 [48];
long local_18;
long local_10;
local_18 = param_2;
local_10 = param_1;
sqr_fp(local_48,param_2);
sqr_fp(local_78,local_18 + 0x30);
add_fp(local_48,local_48,local_78);
reciprocal_fp(local_78,local_48);
mul_fp(local_10,local_18,local_78);
mul_fp(local_10 + 0x30,local_18 + 0x30,local_78);
cneg_fp(local_10 + 0x30,local_10 + 0x30,1);
return;
}
|
|
10,862 |
Logger::~Logger()
|
11AgReS1SoR11[P]Graph/Common/Logger/src/Logger.cpp
|
Logger::~Logger()
{
if (m_logFile.is_open())
{
m_logFile.close();
}
}
|
O3
|
cpp
|
Logger::~Logger():
pushq %rbx
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x2050
testb %al, %al
je 0x2b19
leaq 0x20(%rbx), %rdi
callq 0x2200
movq 0x24a0(%rip), %rax # 0x4fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x20(%rbx,%rcx)
leaq 0x28(%rbx), %rdi
callq 0x2180
leaq 0x118(%rbx), %rdi
callq 0x2080
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x2b61
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x21d0
popq %rbx
retq
movq %rax, %rdi
callq 0x2c58
nop
|
_ZN6LoggerD2Ev:
push rbx; Alternative name is 'Logger::~Logger()'
mov rbx, rdi
add rdi, 90h
call __ZNKSt12__basic_fileIcE7is_openEv; std::__basic_file<char>::is_open(void)
test al, al
jz short loc_2B19
lea rdi, [rbx+20h]
call __ZNSt14basic_ofstreamIcSt11char_traitsIcEE5closeEv; std::ofstream::close(void)
loc_2B19:
mov rax, cs:_ZTTSt14basic_ofstreamIcSt11char_traitsIcEE_ptr
mov rcx, [rax]
mov rax, [rax+18h]
mov [rbx+20h], rcx
mov rcx, [rcx-18h]
mov [rbx+rcx+20h], rax
lea rdi, [rbx+28h]
call __ZNSt13basic_filebufIcSt11char_traitsIcEED2Ev; std::filebuf::~filebuf()
lea rdi, [rbx+118h]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, [rbx]; void *
add rbx, 10h
cmp rdi, rbx
jz short loc_2B61
mov rsi, [rbx]
inc rsi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_2B61:
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
|
void Logger::~Logger(Logger *this)
{
long long v2; // rcx
long long v3; // rax
_QWORD *v4; // rdi
_QWORD *v5; // rbx
if ( (unsigned __int8)std::__basic_file<char>::is_open((char *)this + 144) )
std::ofstream::close((char *)this + 32);
v2 = `VTT for'std::ofstream[0];
v3 = `VTT for'std::ofstream[3];
*((_QWORD *)this + 4) = `VTT for'std::ofstream[0];
*(_QWORD *)((char *)this + *(_QWORD *)(v2 - 24) + 32) = v3;
std::filebuf::~filebuf((char *)this + 40);
std::ios_base::~ios_base((Logger *)((char *)this + 280));
v4 = *(_QWORD **)this;
v5 = (_QWORD *)((char *)this + 16);
if ( v4 != v5 )
operator delete(v4, *v5 + 1LL);
}
|
~Logger:
PUSH RBX
MOV RBX,RDI
ADD RDI,0x90
CALL 0x00102050
TEST AL,AL
JZ 0x00102b19
LAB_00102b10:
LEA RDI,[RBX + 0x20]
CALL 0x00102200
LAB_00102b19:
MOV RAX,qword ptr [0x00104fc0]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBX + 0x20],RCX
MOV RCX,qword ptr [RCX + -0x18]
MOV qword ptr [RBX + RCX*0x1 + 0x20],RAX
LEA RDI,[RBX + 0x28]
CALL 0x00102180
LEA RDI,[RBX + 0x118]
CALL 0x00102080
MOV RDI,qword ptr [RBX]
ADD RBX,0x10
CMP RDI,RBX
JZ 0x00102b61
MOV RSI,qword ptr [RBX]
INC RSI
POP RBX
JMP 0x001021d0
LAB_00102b61:
POP RBX
RET
|
/* Logger::~Logger() */
void __thiscall Logger::~Logger(Logger *this)
{
long lVar1;
int8 uVar2;
char cVar3;
cVar3 = std::__basic_file<char>::is_open();
if (cVar3 != '\0') {
/* try { // try from 00102b10 to 00102b18 has its CatchHandler @ 00102b63 */
std::ofstream::close();
}
lVar1 = *(long *)PTR_VTT_00104fc0;
uVar2 = *(int8 *)(PTR_VTT_00104fc0 + 0x18);
*(long *)(this + 0x20) = lVar1;
*(int8 *)(this + *(long *)(lVar1 + -0x18) + 0x20) = uVar2;
std::filebuf::~filebuf((filebuf *)(this + 0x28));
std::ios_base::~ios_base((ios_base *)(this + 0x118));
if (*(Logger **)this != this + 0x10) {
operator_delete(*(Logger **)this,*(long *)(this + 0x10) + 1);
return;
}
return;
}
|
|
10,863 |
my_hash_free_elements
|
eloqsql/mysys/hash.c
|
static inline void my_hash_free_elements(HASH *hash)
{
uint records= hash->records;
if (records == 0)
return;
/*
Set records to 0 early to guard against anyone looking at the structure
during the free process
*/
hash->records= 0;
if (hash->free)
{
HASH_LINK *data=dynamic_element(&hash->array,0,HASH_LINK*);
HASH_LINK *end= data + records;
do
{
(*hash->free)((data++)->data);
} while (data < end);
}
}
|
O0
|
c
|
my_hash_free_elements:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x3119f
jmp 0x311fd
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x311fd
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x10, %rdx
movq %rdx, -0x18(%rbp)
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x311d4
jmp 0x311fd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_free_elements:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov [rbp+var_C], eax
cmp [rbp+var_C], 0
jnz short loc_3119F
jmp short loc_311FD
loc_3119F:
mov rax, [rbp+var_8]
mov qword ptr [rax+18h], 0
mov rax, [rbp+var_8]
cmp qword ptr [rax+60h], 0
jz short loc_311FD
mov rax, [rbp+var_8]
mov rax, [rax+28h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov ecx, [rbp+var_C]
shl rcx, 4
add rax, rcx
mov [rbp+var_20], rax
loc_311D4:
mov rax, [rbp+var_8]
mov rax, [rax+60h]
mov rcx, [rbp+var_18]
mov rdx, rcx
add rdx, 10h
mov [rbp+var_18], rdx
mov rdi, [rcx+8]
call rax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jb short loc_311D4
jmp short $+2
loc_311FD:
add rsp, 20h
pop rbp
retn
|
unsigned long long my_hash_free_elements(unsigned long long a1)
{
unsigned long long result; // rax
unsigned long long v2; // rcx
unsigned long long v3; // [rsp+0h] [rbp-20h]
unsigned long long v4; // [rsp+8h] [rbp-18h]
unsigned int v5; // [rsp+14h] [rbp-Ch]
result = *(_QWORD *)(a1 + 24);
v5 = result;
if ( (_DWORD)result )
{
*(_QWORD *)(a1 + 24) = 0LL;
result = a1;
if ( *(_QWORD *)(a1 + 96) )
{
v4 = *(_QWORD *)(a1 + 40);
v3 = 16LL * v5 + v4;
do
{
v2 = v4;
v4 += 16LL;
(*(void ( **)(_QWORD))(a1 + 96))(*(_QWORD *)(v2 + 8));
result = v4;
}
while ( v4 < v3 );
}
}
return result;
}
|
my_hash_free_elements:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV dword ptr [RBP + -0xc],EAX
CMP dword ptr [RBP + -0xc],0x0
JNZ 0x0013119f
JMP 0x001311fd
LAB_0013119f:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001311fd
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0xc]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_001311d4:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x60]
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,RCX
ADD RDX,0x10
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RCX + 0x8]
CALL RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JC 0x001311d4
JMP 0x001311fd
LAB_001311fd:
ADD RSP,0x20
POP RBP
RET
|
void my_hash_free_elements(long param_1)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong local_20;
uVar1 = *(ulong *)(param_1 + 0x18);
if (((int)uVar1 != 0) && (*(int8 *)(param_1 + 0x18) = 0, *(long *)(param_1 + 0x60) != 0)) {
uVar2 = *(ulong *)(param_1 + 0x28);
local_20 = uVar2;
do {
uVar3 = local_20 + 0x10;
(**(code **)(param_1 + 0x60))(*(int8 *)(local_20 + 8));
local_20 = uVar3;
} while (uVar3 < uVar2 + (uVar1 & 0xffffffff) * 0x10);
}
return;
}
|
|
10,864 |
void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::vector<float, std::allocator<float>>, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::vector<float, std::allocator<float>> const&)
|
monkey531[P]llama/common/./json.hpp
|
static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
{
using std::begin;
using std::end;
j.m_data.m_value.destroy(j.m_data.m_type);
j.m_data.m_type = value_t::array;
j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
j.set_parents();
j.assert_invariant();
}
|
O0
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::vector<float, std::allocator<float>>, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::vector<float, std::allocator<float>> const&):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rax
movzbl (%rax), %esi
callq 0xa5b00
movq 0x20(%rsp), %rax
movb $0x2, (%rax)
movq 0x18(%rsp), %rdi
callq 0x19f6f0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x19f720
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x19f5d0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rdi
callq 0xa7360
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xa1e20
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IfSaIfEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSN_RKSM_:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rdi, [rsp+28h+var_8]
add rdi, 8
mov rax, [rsp+28h+var_8]
movzx esi, byte ptr [rax]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t)
mov rax, [rsp+28h+var_8]
mov byte ptr [rax], 2
mov rdi, [rsp+28h+var_10]
call _ZSt5beginISt6vectorIfSaIfEEEDTcldtfp_5beginEERKT_
mov [rsp+28h+var_18], rax
mov rdi, [rsp+28h+var_10]
call _ZSt3endISt6vectorIfSaIfEEEDTcldtfp_3endEERKT_
mov [rsp+28h+var_20], rax
lea rdi, [rsp+28h+var_18]
lea rsi, [rsp+28h+var_20]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJN9__gnu_cxx17__normal_iteratorIPKfS3_IfSaIfEEEESN_EEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,__gnu_cxx::__normal_iterator<float const*,std::vector<float>>,__gnu_cxx::__normal_iterator<float const*,std::vector<float>>>(__gnu_cxx::__normal_iterator<float const*,std::vector<float>>,__gnu_cxx::__normal_iterator<float const*,std::vector<float>> &&)
mov rcx, rax
mov rax, [rsp+28h+var_8]
mov [rax+8], rcx
mov rdi, [rsp+28h+var_8]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE11set_parentsEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::set_parents(void)
mov rdi, [rsp+28h+var_8]
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
add rsp, 28h
retn
|
long long ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IfSaIfEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSN_RKSM_(
long long a1,
long long a2)
{
long long v2; // rax
long long v4; // [rsp+8h] [rbp-20h] BYREF
long long v5; // [rsp+10h] [rbp-18h] BYREF
long long v6; // [rsp+18h] [rbp-10h]
long long v7; // [rsp+20h] [rbp-8h]
v7 = a1;
v6 = a2;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
(long long *)(a1 + 8),
*(_BYTE *)a1);
*(_BYTE *)a1 = 2;
v5 = std::begin<std::vector<float>>(v6);
v4 = std::end<std::vector<float>>(v6);
v2 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,__gnu_cxx::__normal_iterator<float const*,std::vector<float>>,__gnu_cxx::__normal_iterator<float const*,std::vector<float>>>(
&v5,
&v4);
*(_QWORD *)(v7 + 8) = v2;
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>::set_parents();
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v7);
}
|
set:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
CALL 0x001a04d0
POP RAX
RET
|
/* std::set<int, std::less<int>, std::allocator<int> >::set() */
set<int,std::less<int>,std::allocator<int>> * __thiscall
std::set<int,std::less<int>,std::allocator<int>>::set
(set<int,std::less<int>,std::allocator<int>> *this)
{
_Rb_tree<int,int,std::_Identity<int>,std::less<int>,std::allocator<int>>::_Rb_tree
((_Rb_tree<int,int,std::_Identity<int>,std::less<int>,std::allocator<int>> *)this);
return this;
}
|
|
10,865 |
void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::vector<float, std::allocator<float>>, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::vector<float, std::allocator<float>> const&)
|
monkey531[P]llama/common/./json.hpp
|
static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
{
using std::begin;
using std::end;
j.m_data.m_value.destroy(j.m_data.m_type);
j.m_data.m_type = value_t::array;
j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
j.set_parents();
j.assert_invariant();
}
|
O1
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::vector<float, std::allocator<float>>, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::vector<float, std::allocator<float>> const&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movzbl (%r14), %esi
callq 0x4524e
movb $0x2, (%r14)
movq (%rbx), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x8(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
callq 0x5fb34
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x449aa
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IiSaIiEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSN_RKSM_:
push r14
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
add rdi, 8
movzx esi, byte ptr [r14]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t)
mov byte ptr [r14], 2
mov rax, [rbx]
lea rdi, [rsp+28h+var_18]
mov [rdi], rax
mov rax, [rbx+8]
lea rsi, [rsp+28h+var_20]
mov [rsi], rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJN9__gnu_cxx17__normal_iteratorIPKiS3_IiSaIiEEEESN_EEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>> &&)
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
add rsp, 18h
pop rbx
pop r14
retn
|
long long ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IiSaIiEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSN_RKSM_(
unsigned __int8 *a1)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
(void **)a1 + 1,
*a1);
*a1 = 2;
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>();
*((_QWORD *)a1 + 1) = result;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
return result;
}
|
_ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IiSaIiEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSN_RKSM_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
ADD RDI,0x8
MOVZX ESI,byte ptr [R14]
CALL 0x0014524e
MOV byte ptr [R14],0x2
MOV RAX,qword ptr [RBX]
LEA RDI,[RSP + 0x10]
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RBX + 0x8]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
CALL 0x0015fb34
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x001449aa
ADD RSP,0x18
POP RBX
POP R14
RET
|
void _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IiSaIiEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSN_RKSM_
(int1 *param_1,int8 *param_2)
{
vector *pvVar1;
int8 local_20;
int8 local_18;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy((json_value *)(param_1 + 8),*param_1);
*param_1 = 2;
local_18 = *param_2;
local_20 = param_2[1];
pvVar1 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,__gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>,__gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>>
((__normal_iterator *)&local_18,(__normal_iterator *)&local_20);
*(vector **)(param_1 + 8) = pvVar1;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
return;
}
|
|
10,866 |
void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::vector<float, std::allocator<float>>, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::vector<float, std::allocator<float>> const&)
|
monkey531[P]llama/common/./json.hpp
|
static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
{
using std::begin;
using std::end;
j.m_data.m_value.destroy(j.m_data.m_type);
j.m_data.m_type = value_t::array;
j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
j.set_parents();
j.assert_invariant();
}
|
O2
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::vector<float, std::allocator<float>>, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::vector<float, std::allocator<float>> const&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movzbl (%r14), %esi
callq 0x3f74e
movb $0x2, (%r14)
movq (%rbx), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x8(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
callq 0x88e82
movq %rax, 0x8(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3eca6
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IS8_IfSaIfEESaISK_EETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSP_RKSO_:
push r14
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
add rdi, 8
movzx esi, byte ptr [r14]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t)
mov byte ptr [r14], 2
mov rax, [rbx]
lea rdi, [rsp+28h+var_18]
mov [rdi], rax
mov rax, [rbx+8]
lea rsi, [rsp+28h+var_20]
mov [rsi], rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJN9__gnu_cxx17__normal_iteratorIPKS3_IfSaIfEES3_ISK_SaISK_EEEESP_EEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,__gnu_cxx::__normal_iterator<std::vector const*<float,std::allocator<float>>,std::vector<std::vector const*>>,__gnu_cxx::__normal_iterator<std::vector const*<float,std::allocator<float>>,std::vector<std::vector const*>>>(__gnu_cxx::__normal_iterator<std::vector const*<float,std::allocator<float>>,std::vector<std::vector const*>>,__gnu_cxx::__normal_iterator<std::vector const*<float,std::allocator<float>>,std::vector<std::vector const*>> &&)
mov [r14+8], rax
push 1
pop rsi
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
add rsp, 18h
pop rbx
pop r14
retn
|
long long ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IS8_IfSaIfEESaISK_EETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSP_RKSO_(
unsigned __int8 *a1)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
(void **)a1 + 1,
*a1);
*a1 = 2;
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,__gnu_cxx::__normal_iterator<std::vector const*<float,std::allocator<float>>,std::vector<std::vector const*>>,__gnu_cxx::__normal_iterator<std::vector const*<float,std::allocator<float>>,std::vector<std::vector const*>>>();
*((_QWORD *)a1 + 1) = result;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
return result;
}
|
_ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IS8_IfSaIfEESaISK_EETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSP_RKSO_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
ADD RDI,0x8
MOVZX ESI,byte ptr [R14]
CALL 0x0013f74e
MOV byte ptr [R14],0x2
MOV RAX,qword ptr [RBX]
LEA RDI,[RSP + 0x10]
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RBX + 0x8]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
CALL 0x00188e82
MOV qword ptr [R14 + 0x8],RAX
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x0013eca6
ADD RSP,0x18
POP RBX
POP R14
RET
|
void _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IS8_IfSaIfEESaISK_EETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSP_RKSO_
(int1 *param_1,int8 *param_2)
{
vector *pvVar1;
int8 local_20;
int8 local_18;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy((json_value *)(param_1 + 8),*param_1);
*param_1 = 2;
local_18 = *param_2;
local_20 = param_2[1];
pvVar1 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,__gnu_cxx::__normal_iterator<std::vector<float,std::allocator<float>>const*,std::vector<std::vector<float,std::allocator<float>>,std::allocator<std::vector<float,std::allocator<float>>>>>,__gnu_cxx::__normal_iterator<std::vector<float,std::allocator<float>>const*,std::vector<std::vector<float,std::allocator<float>>,std::allocator<std::vector<float,std::allocator<float>>>>>>
((__normal_iterator *)&local_18,(__normal_iterator *)&local_20);
*(vector **)(param_1 + 8) = pvVar1;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
return;
}
|
|
10,867 |
void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::vector<float, std::allocator<float>>, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::vector<float, std::allocator<float>> const&)
|
monkey531[P]llama/common/./json.hpp
|
static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
{
using std::begin;
using std::end;
j.m_data.m_value.destroy(j.m_data.m_type);
j.m_data.m_type = value_t::array;
j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
j.set_parents();
j.assert_invariant();
}
|
O3
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::vector<float, std::allocator<float>>, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::vector<float, std::allocator<float>> const&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movzbl (%r14), %esi
callq 0x441ae
movb $0x2, (%r14)
movq (%rbx), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x8(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
callq 0x9d0c8
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x438fc
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IfSaIfEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSN_RKSM_:
push r14
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
add rdi, 8
movzx esi, byte ptr [r14]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t)
mov byte ptr [r14], 2
mov rax, [rbx]
lea rdi, [rsp+28h+var_18]
mov [rdi], rax
mov rax, [rbx+8]
lea rsi, [rsp+28h+var_20]
mov [rsi], rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJN9__gnu_cxx17__normal_iteratorIPKfS3_IfSaIfEEEESN_EEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,__gnu_cxx::__normal_iterator<float const*,std::vector<float>>,__gnu_cxx::__normal_iterator<float const*,std::vector<float>>>(__gnu_cxx::__normal_iterator<float const*,std::vector<float>>,__gnu_cxx::__normal_iterator<float const*,std::vector<float>> &&)
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
add rsp, 18h
pop rbx
pop r14
retn
|
long long ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IfSaIfEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSN_RKSM_(
unsigned __int8 *a1)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
(void ***)a1 + 1,
*a1);
*a1 = 2;
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,__gnu_cxx::__normal_iterator<float const*,std::vector<float>>,__gnu_cxx::__normal_iterator<float const*,std::vector<float>>>();
*((_QWORD *)a1 + 1) = result;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
return result;
}
|
_ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IfSaIfEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSN_RKSM_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
ADD RDI,0x8
MOVZX ESI,byte ptr [R14]
CALL 0x001441ae
MOV byte ptr [R14],0x2
MOV RAX,qword ptr [RBX]
LEA RDI,[RSP + 0x10]
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RBX + 0x8]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
CALL 0x0019d0c8
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x001438fc
ADD RSP,0x18
POP RBX
POP R14
RET
|
void _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES8_IfSaIfEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSN_RKSM_
(int1 *param_1,int8 *param_2)
{
vector *pvVar1;
int8 local_20;
int8 local_18;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy((json_value *)(param_1 + 8),*param_1);
*param_1 = 2;
local_18 = *param_2;
local_20 = param_2[1];
pvVar1 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,__gnu_cxx::__normal_iterator<float_const*,std::vector<float,std::allocator<float>>>,__gnu_cxx::__normal_iterator<float_const*,std::vector<float,std::allocator<float>>>>
((__normal_iterator *)&local_18,(__normal_iterator *)&local_20);
*(vector **)(param_1 + 8) = pvVar1;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
return;
}
|
|
10,868 |
vio_ssl_close
|
eloqsql/vio/viossl.c
|
int vio_ssl_close(Vio *vio)
{
int r= 0;
SSL *ssl= (SSL*)vio->ssl_arg;
DBUG_ENTER("vio_ssl_close");
if (ssl)
{
/*
THE SSL standard says that SSL sockets must send and receive a close_notify
alert on socket shutdown to avoid truncation attacks. However, this can
cause problems since we often hold a lock during shutdown and this IO can
take an unbounded amount of time to complete. Since our packets are self
describing with length, we aren't vunerable to these attacks. Therefore,
we just shutdown by closing the socket (quiet shutdown).
*/
SSL_set_quiet_shutdown(ssl, 1);
switch ((r= SSL_shutdown(ssl))) {
case 1:
/* Shutdown successful */
break;
case 0:
/*
Shutdown not yet finished - since the socket is going to
be closed there is no need to call SSL_shutdown() a second
time to wait for the other side to respond
*/
break;
default: /* Shutdown failed */
DBUG_PRINT("vio_error", ("SSL_shutdown() failed, error: %d",
SSL_get_error(ssl, r)));
break;
}
}
DBUG_RETURN(vio_close(vio));
}
|
O0
|
c
|
vio_ssl_close:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xaba024
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x434800
movq -0x18(%rbp), %rdi
callq 0x433440
movl %eax, -0xc(%rbp)
movl %eax, %ecx
movl %ecx, -0x1c(%rbp)
testl %eax, %eax
je 0xaba01a
jmp 0xaba00e
movl -0x1c(%rbp), %eax
subl $0x1, %eax
jne 0xaba01c
jmp 0xaba018
jmp 0xaba022
jmp 0xaba022
jmp 0xaba01e
jmp 0xaba020
jmp 0xaba022
jmp 0xaba024
jmp 0xaba026
movq -0x8(%rbp), %rdi
callq 0xab8fb0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
vio_ssl_close:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
mov rax, [rbp+var_8]
mov rax, [rax+1E0h]
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_ABA024
mov rdi, [rbp+var_18]
mov esi, 1
call _SSL_set_quiet_shutdown
mov rdi, [rbp+var_18]
call _SSL_shutdown
mov [rbp+var_C], eax
mov ecx, eax
mov [rbp+var_1C], ecx
test eax, eax
jz short loc_ABA01A
jmp short $+2
loc_ABA00E:
mov eax, [rbp+var_1C]
sub eax, 1
jnz short loc_ABA01C
jmp short $+2
loc_ABA018:
jmp short loc_ABA022
loc_ABA01A:
jmp short loc_ABA022
loc_ABA01C:
jmp short $+2
loc_ABA01E:
jmp short $+2
loc_ABA020:
jmp short $+2
loc_ABA022:
jmp short $+2
loc_ABA024:
jmp short $+2
loc_ABA026:
mov rdi, [rbp+var_8]
call vio_close
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
|
long long vio_ssl_close(long long a1)
{
long long v2; // [rsp+8h] [rbp-18h]
v2 = *(_QWORD *)(a1 + 480);
if ( v2 )
{
SSL_set_quiet_shutdown(v2, 1LL);
SSL_shutdown(v2);
}
return (unsigned int)vio_close(a1);
}
|
set_row:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x48]
CALL 0x005b3720
MOV RDI,qword ptr [RBP + -0x58]
ADD RDI,0x8
LEA RSI,[0x16ee3d0]
CALL 0x005eeca0
MOV dword ptr [RBP + -0x4c],0x0
LAB_00aba004:
LEA RDI,[RBP + -0x48]
XOR ESI,ESI
CALL 0x005b37f0
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JZ 0x00aba0dc
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RCX + 0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV dword ptr [RCX + 0x8],EDX
ADD RAX,0x8
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xa8]
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,RAX
CALL 0x005eeca0
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x28]
MOV DX,word ptr [RCX + 0xc]
MOV RCX,qword ptr [RAX + 0x20]
MOV word ptr [RCX + 0xc],DX
MOV RCX,qword ptr [RBP + -0x28]
MOV CL,byte ptr [RCX + 0xe]
MOV RAX,qword ptr [RAX + 0x20]
AND CL,0x1
MOV byte ptr [RAX + 0xe],CL
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x005b7930
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x58]
AND CL,0x1
MOV byte ptr [RAX + 0x28],CL
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RAX + 0x18]
CALL 0x005f5510
MOV RCX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x4c]
MOV qword ptr [RCX + RDX*0x8],RAX
CMP RAX,0x0
JNZ 0x00aba0ae
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00aba0fe
LAB_00aba0ae:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x4c]
MOV RDI,qword ptr [RCX + RDX*0x8]
MOV RSI,qword ptr [RAX + 0x18]
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x620]
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x00aba004
LAB_00aba0dc:
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x10],0x1
JBE 0x00aba0fa
MOV RDI,qword ptr [RBP + -0x58]
ADD RDI,0x8
LEA RSI,[0x16ee0b8]
CALL 0x005eeca0
LAB_00aba0fa:
MOV byte ptr [RBP + -0x1],0x0
LAB_00aba0fe:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x60
POP RBP
RET
|
/* subselect_engine::set_row(List<Item>&, Item_cache**) */
int1 __thiscall
subselect_engine::set_row(subselect_engine *this,List *param_1,Item_cache **param_2)
{
byte bVar1;
Type_handler *pTVar2;
Item_cache *pIVar3;
uint local_54;
List_iterator_fast<Item> local_50 [32];
Item *local_30;
Item_cache **local_28;
List *local_20;
subselect_engine *local_18;
local_28 = param_2;
local_20 = param_1;
local_18 = this;
List_iterator_fast<Item>::List_iterator_fast(local_50,param_1);
Type_handler_hybrid_field_type::set_handler
((Type_handler_hybrid_field_type *)(this + 8),(Type_handler *)type_handler_varchar);
local_54 = 0;
while( true ) {
local_30 = (Item *)List_iterator_fast<Item>::operator++(local_50,0);
if (local_30 == (Item *)0x0) {
if (1 < *(uint *)(local_20 + 0x10)) {
Type_handler_hybrid_field_type::set_handler
((Type_handler_hybrid_field_type *)(this + 8),(Type_handler *)type_handler_row);
}
return 0;
}
*(int4 *)(*(long *)(this + 0x20) + 8) = *(int4 *)(local_30 + 8);
pTVar2 = (Type_handler *)(**(code **)(*(long *)local_30 + 0xa8))();
Type_handler_hybrid_field_type::set_handler((Type_handler_hybrid_field_type *)(this + 8),pTVar2)
;
*(int2 *)(*(long *)(this + 0x20) + 0xc) = *(int2 *)(local_30 + 0xc);
*(byte *)(*(long *)(this + 0x20) + 0xe) = (byte)local_30[0xe] & 1;
bVar1 = Item::maybe_null(local_30);
this[0x28] = (subselect_engine)(bVar1 & 1);
pIVar3 = (Item_cache *)Item::get_cache(local_30,*(THD **)(this + 0x18));
local_28[local_54] = pIVar3;
if (pIVar3 == (Item_cache *)0x0) break;
(**(code **)(*(long *)local_28[local_54] + 0x620))
(local_28[local_54],*(int8 *)(this + 0x18),local_30);
local_54 = local_54 + 1;
}
return 1;
}
|
|
10,869 |
hash_tree_root
|
corpus-core[P]colibri-stateless/src/util/ssz_merkle.c
|
static void hash_tree_root(ssz_ob_t ob, uint8_t* out, merkle_ctx_t* parent) {
memset(out, 0, 32);
if (!ob.def) return;
merkle_ctx_t ctx = {0};
ctx.root_gindex = 1;
calc_leafes(&ctx, ob);
if (parent) {
ctx.proof = parent->proof;
ctx.root_gindex = ob.def->type == SSZ_TYPE_LIST ? parent->last_gindex * 2 : parent->last_gindex;
}
if (ctx.num_leafes == 1)
set_leaf(ob, 0, out, NULL);
else
merkle_hash(&ctx, 0, 0, out);
// mix_in_length s
if (ob.def->type == SSZ_TYPE_LIST || ob.def->type == SSZ_TYPE_BIT_LIST) {
uint8_t length[32] = {0};
uint64_to_le(length, (uint64_t) ssz_len(ob));
sha256_merkle(bytes(out, 32), bytes(length, 32), out);
if (ctx.proof) {
int pos = gindex_indexOf(ctx.proof->witnesses, ctx.root_gindex + 1);
if (pos >= 0 && ctx.proof->proof->data.data)
memcpy(ctx.proof->proof->data.data + pos * 32, length, 32);
}
}
}
|
O0
|
c
|
hash_tree_root:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x231c0
movq -0xa0(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xa2121
jmp 0xa232b
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x231c0
movq -0xa0(%rbp), %rax
movq $0x1, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa2c40
cmpq $0x0, -0x10(%rbp)
je 0xa21b4
movq -0xa0(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rax
cmpl $0x4, 0x8(%rax)
jne 0xa219a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
shlq %rax
movq %rax, -0xa8(%rbp)
jmp 0xa21a9
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x30(%rbp)
jne 0xa21eb
movq -0xa0(%rbp), %rax
movq -0x8(%rbp), %rsi
xorl %edi, %edi
xorl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa2cc0
jmp 0xa21fc
movq -0x8(%rbp), %rcx
leaq -0x50(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xa2f80
movq -0xa0(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x4, 0x8(%rax)
je 0xa2222
movq -0xa0(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x6, 0x8(%rax)
jne 0xa232b
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x231c0
movq -0xa0(%rbp), %rax
leaq -0x70(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa0830
movq -0xb0(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x9de70
movl $0x20, -0x80(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x20, -0x90(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %r8
movl -0x80(%rbp), %edi
movq -0x78(%rbp), %rsi
movl -0x90(%rbp), %edx
movq -0x88(%rbp), %rcx
callq 0xa49e0
cmpq $0x0, -0x18(%rbp)
je 0xa2329
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0xa3280
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
jl 0xa2327
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0xa2327
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movl -0x94(%rbp), %ecx
shll $0x5, %ecx
movslq %ecx, %rcx
movq -0x70(%rbp), %rdx
movq %rdx, (%rax,%rcx)
movq -0x68(%rbp), %rdx
movq %rdx, 0x8(%rax,%rcx)
movq -0x60(%rbp), %rdx
movq %rdx, 0x10(%rax,%rcx)
movq -0x58(%rbp), %rdx
movq %rdx, 0x18(%rax,%rcx)
jmp 0xa2329
jmp 0xa232b
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
hash_tree_root:
push rbp
mov rbp, rsp
sub rsp, 0D0h
lea rax, [rbp+arg_0]
mov [rbp+var_A0], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
xor esi, esi
mov edx, 20h ; ' '
call _memset
mov rax, [rbp+var_A0]
cmp qword ptr [rax+10h], 0
jnz short loc_A2121
jmp loc_A232B
loc_A2121:
lea rdi, [rbp+var_50]
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov rax, [rbp+var_A0]
mov [rbp+var_28], 1
lea rdi, [rbp+var_50]
mov rcx, [rax]
mov [rsp+0D0h+var_D0], rcx
mov rcx, [rax+8]
mov [rsp+0D0h+var_C8], rcx
mov rax, [rax+10h]
mov [rsp+0D0h+var_C0], rax
call calc_leafes
cmp [rbp+var_10], 0
jz short loc_A21B4
mov rax, [rbp+var_A0]
mov rcx, [rbp+var_10]
mov rcx, [rcx+38h]
mov [rbp+var_18], rcx
mov rax, [rax+10h]
cmp dword ptr [rax+8], 4
jnz short loc_A219A
mov rax, [rbp+var_10]
mov rax, [rax+30h]
shl rax, 1
mov [rbp+var_A8], rax
jmp short loc_A21A9
loc_A219A:
mov rax, [rbp+var_10]
mov rax, [rax+30h]
mov [rbp+var_A8], rax
loc_A21A9:
mov rax, [rbp+var_A8]
mov [rbp+var_28], rax
loc_A21B4:
cmp [rbp+var_30], 1
jnz short loc_A21EB
mov rax, [rbp+var_A0]
mov rsi, [rbp+var_8]
xor edi, edi
xor ecx, ecx
mov edx, ecx
mov rcx, [rax]
mov [rsp+0D0h+var_D0], rcx
mov rcx, [rax+8]
mov [rsp+0D0h+var_C8], rcx
mov rax, [rax+10h]
mov [rsp+0D0h+var_C0], rax
call set_leaf
jmp short loc_A21FC
loc_A21EB:
mov rcx, [rbp+var_8]
lea rdi, [rbp+var_50]
xor edx, edx
mov esi, edx
call merkle_hash
loc_A21FC:
mov rax, [rbp+var_A0]
mov rax, [rax+10h]
cmp dword ptr [rax+8], 4
jz short loc_A2222
mov rax, [rbp+var_A0]
mov rax, [rax+10h]
cmp dword ptr [rax+8], 6
jnz loc_A232B
loc_A2222:
lea rdi, [rbp+var_70]
xor esi, esi
mov edx, 20h ; ' '
call _memset
mov rax, [rbp+var_A0]
lea rcx, [rbp+var_70]
mov [rbp+var_B0], rcx
mov rcx, [rax]
mov [rsp+0D0h+var_D0], rcx
mov rcx, [rax+8]
mov [rsp+0D0h+var_C8], rcx
mov rax, [rax+10h]
mov [rsp+0D0h+var_C0], rax
call ssz_len
mov rdi, [rbp+var_B0]
mov eax, eax
mov esi, eax
call uint64_to_le
mov [rbp+var_80], 20h ; ' '
mov rax, [rbp+var_8]
mov [rbp+var_78], rax
mov [rbp+var_90], 20h ; ' '
lea rax, [rbp+var_70]
mov [rbp+var_88], rax
mov r8, [rbp+var_8]
mov edi, [rbp+var_80]
mov rsi, [rbp+var_78]
mov edx, [rbp+var_90]
mov rcx, [rbp+var_88]
call sha256_merkle
cmp [rbp+var_18], 0
jz short loc_A2329
mov rax, [rbp+var_18]
mov rdi, [rax]
mov rsi, [rbp+var_28]
add rsi, 1
call gindex_indexOf
mov [rbp+var_94], eax
cmp [rbp+var_94], 0
jl short loc_A2327
mov rax, [rbp+var_18]
mov rax, [rax+8]
cmp qword ptr [rax+8], 0
jz short loc_A2327
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rax, [rax+8]
mov ecx, [rbp+var_94]
shl ecx, 5
movsxd rcx, ecx
mov rdx, [rbp+var_70]
mov [rax+rcx], rdx
mov rdx, [rbp+var_68]
mov [rax+rcx+8], rdx
mov rdx, [rbp+var_60]
mov [rax+rcx+10h], rdx
mov rdx, [rbp+var_58]
mov [rax+rcx+18h], rdx
loc_A2327:
jmp short $+2
loc_A2329:
jmp short $+2
loc_A232B:
add rsp, 0D0h
pop rbp
retn
|
long long * hash_tree_root(
long long a1,
long long a2,
_DWORD a3,
_DWORD a4,
_DWORD a5,
_DWORD a6,
long long a7,
unsigned __int8 *a8,
long long a9)
{
long long *result; // rax
int v10; // edx
int v11; // r8d
int v12; // r9d
int v13; // r8d
int v14; // r9d
int v15; // edx
int v16; // r8d
int v17; // r9d
unsigned int v18; // eax
long long v19; // rcx
long long v20; // [rsp+28h] [rbp-A8h]
int v21; // [rsp+3Ch] [rbp-94h]
_QWORD v22[4]; // [rsp+60h] [rbp-70h] BYREF
_BYTE v23[32]; // [rsp+80h] [rbp-50h] BYREF
int v24; // [rsp+A0h] [rbp-30h]
long long v25; // [rsp+A8h] [rbp-28h]
_QWORD *v26; // [rsp+B8h] [rbp-18h]
long long v27; // [rsp+C0h] [rbp-10h]
long long v28; // [rsp+C8h] [rbp-8h]
v28 = a1;
v27 = a2;
memset(a1, 0LL, 32LL);
result = &a7;
if ( a9 )
{
memset(v23, 0LL, 64LL);
v25 = 1LL;
calc_leafes((unsigned int)v23, 0, v10, (_DWORD)a8, v11, v12, a7, a8, a9);
if ( v27 )
{
v26 = *(_QWORD **)(v27 + 56);
if ( *(_DWORD *)(a9 + 8) == 4 )
v20 = 2LL * *(_QWORD *)(v27 + 48);
else
v20 = *(_QWORD *)(v27 + 48);
v25 = v20;
}
if ( v24 == 1 )
set_leaf(0, v28, 0, (_DWORD)a8, v13, v14, a7, a8, a9);
else
merkle_hash(v23, 0LL, 0LL, v28);
if ( *(_DWORD *)(a9 + 8) == 4 || (result = (long long *)a9, *(_DWORD *)(a9 + 8) == 6) )
{
memset(v22, 0LL, sizeof(v22));
v18 = ssz_len((unsigned int)v22, 0, v15, (_DWORD)a8, v16, v17, a7, a8, a9);
uint64_to_le((long long)v22, v18);
result = (long long *)sha256_merkle(32LL, v28, 32LL, v22, v28);
if ( v26 )
{
result = (long long *)gindex_indexOf(*v26, v25 + 1);
v21 = (int)result;
if ( (int)result >= 0 )
{
result = (long long *)v26[1];
if ( result[1] )
{
result = *(long long **)(v26[1] + 8LL);
v19 = 4 * v21;
result[v19] = v22[0];
result[v19 + 1] = v22[1];
result[v19 + 2] = v22[2];
result[v19 + 3] = v22[3];
}
}
}
}
}
return result;
}
|
hash_tree_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0xa0],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x001231c0
MOV RAX,qword ptr [RBP + -0xa0]
CMP qword ptr [RAX + 0x10],0x0
JNZ 0x001a2121
JMP 0x001a232b
LAB_001a2121:
LEA RDI,[RBP + -0x50]
XOR ESI,ESI
MOV EDX,0x40
CALL 0x001231c0
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x28],0x1
LEA RDI,[RBP + -0x50]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001a2c40
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001a21b4
MOV RAX,qword ptr [RBP + -0xa0]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x38]
MOV qword ptr [RBP + -0x18],RCX
MOV RAX,qword ptr [RAX + 0x10]
CMP dword ptr [RAX + 0x8],0x4
JNZ 0x001a219a
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x30]
SHL RAX,0x1
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x001a21a9
LAB_001a219a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0xa8],RAX
LAB_001a21a9:
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001a21b4:
CMP dword ptr [RBP + -0x30],0x1
JNZ 0x001a21eb
MOV RAX,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x8]
XOR EDI,EDI
XOR ECX,ECX
MOV EDX,ECX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001a2cc0
JMP 0x001a21fc
LAB_001a21eb:
MOV RCX,qword ptr [RBP + -0x8]
LEA RDI,[RBP + -0x50]
XOR EDX,EDX
MOV ESI,EDX
CALL 0x001a2f80
LAB_001a21fc:
MOV RAX,qword ptr [RBP + -0xa0]
MOV RAX,qword ptr [RAX + 0x10]
CMP dword ptr [RAX + 0x8],0x4
JZ 0x001a2222
MOV RAX,qword ptr [RBP + -0xa0]
MOV RAX,qword ptr [RAX + 0x10]
CMP dword ptr [RAX + 0x8],0x6
JNZ 0x001a232b
LAB_001a2222:
LEA RDI,[RBP + -0x70]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x001231c0
MOV RAX,qword ptr [RBP + -0xa0]
LEA RCX,[RBP + -0x70]
MOV qword ptr [RBP + -0xb0],RCX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001a0830
MOV RDI,qword ptr [RBP + -0xb0]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x0019de70
MOV dword ptr [RBP + -0x80],0x20
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x78],RAX
MOV dword ptr [RBP + -0x90],0x20
LEA RAX,[RBP + -0x70]
MOV qword ptr [RBP + -0x88],RAX
MOV R8,qword ptr [RBP + -0x8]
MOV EDI,dword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x90]
MOV RCX,qword ptr [RBP + -0x88]
CALL 0x001a49e0
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001a2329
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x1
CALL 0x001a3280
MOV dword ptr [RBP + -0x94],EAX
CMP dword ptr [RBP + -0x94],0x0
JL 0x001a2327
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x001a2327
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x94]
SHL ECX,0x5
MOVSXD RCX,ECX
MOV RDX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX + RCX*0x1],RDX
MOV RDX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + RCX*0x1 + 0x8],RDX
MOV RDX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + RCX*0x1 + 0x10],RDX
MOV RDX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX + RCX*0x1 + 0x18],RDX
LAB_001a2327:
JMP 0x001a2329
LAB_001a2329:
JMP 0x001a232b
LAB_001a232b:
ADD RSP,0xd0
POP RBP
RET
|
void hash_tree_root(void *param_1,long param_2)
{
long lVar1;
int4 uVar2;
int iVar3;
long lVar4;
int8 in_R9;
int8 in_stack_00000008;
int8 in_stack_00000010;
long in_stack_00000018;
long local_b0;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int1 local_58 [32];
int local_38;
long local_30;
int8 *local_20;
long local_18;
void *local_10;
local_18 = param_2;
local_10 = param_1;
memset(param_1,0,0x20);
if (in_stack_00000018 != 0) {
memset(local_58,0,0x40);
local_30 = 1;
calc_leafes(local_58);
if (local_18 != 0) {
local_20 = *(int8 **)(local_18 + 0x38);
if (*(int *)(in_stack_00000018 + 8) == 4) {
local_b0 = *(long *)(local_18 + 0x30) << 1;
}
else {
local_b0 = *(long *)(local_18 + 0x30);
}
local_30 = local_b0;
}
if (local_38 == 1) {
set_leaf(0,local_10,0);
}
else {
merkle_hash(local_58,0,0,local_10);
}
if ((*(int *)(in_stack_00000018 + 8) == 4) || (*(int *)(in_stack_00000018 + 8) == 6)) {
memset(&local_78,0,0x20);
uVar2 = ssz_len();
uint64_to_le(&local_78,uVar2);
sha256_merkle(0x20,local_10,0x20,&local_78,local_10,in_R9,in_stack_00000008,in_stack_00000010,
in_stack_00000018);
if ((local_20 != (int8 *)0x0) &&
((iVar3 = gindex_indexOf(*local_20,local_30 + 1), -1 < iVar3 &&
(*(long *)(local_20[1] + 8) != 0)))) {
lVar1 = *(long *)(local_20[1] + 8);
lVar4 = (long)(iVar3 << 5);
*(int8 *)(lVar1 + lVar4) = local_78;
*(int8 *)(lVar1 + 8 + lVar4) = local_70;
*(int8 *)(lVar1 + 0x10 + lVar4) = local_68;
*(int8 *)(lVar1 + 0x18 + lVar4) = local_60;
}
}
}
return;
}
|
|
10,870 |
hash_tree_root
|
corpus-core[P]colibri-stateless/src/util/ssz_merkle.c
|
static void hash_tree_root(ssz_ob_t ob, uint8_t* out, merkle_ctx_t* parent) {
memset(out, 0, 32);
if (!ob.def) return;
merkle_ctx_t ctx = {0};
ctx.root_gindex = 1;
calc_leafes(&ctx, ob);
if (parent) {
ctx.proof = parent->proof;
ctx.root_gindex = ob.def->type == SSZ_TYPE_LIST ? parent->last_gindex * 2 : parent->last_gindex;
}
if (ctx.num_leafes == 1)
set_leaf(ob, 0, out, NULL);
else
merkle_hash(&ctx, 0, 0, out);
// mix_in_length s
if (ob.def->type == SSZ_TYPE_LIST || ob.def->type == SSZ_TYPE_BIT_LIST) {
uint8_t length[32] = {0};
uint64_to_le(length, (uint64_t) ssz_len(ob));
sha256_merkle(bytes(out, 32), bytes(length, 32), out);
if (ctx.proof) {
int pos = gindex_indexOf(ctx.proof->witnesses, ctx.root_gindex + 1);
if (pos >= 0 && ctx.proof->proof->data.data)
memcpy(ctx.proof->proof->data.data + pos * 32, length, 32);
}
}
}
|
O3
|
c
|
hash_tree_root:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0xd0(%rsp), %r13
testq %r13, %r13
je 0x556bf
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc0(%rsp), %rcx
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x50(%rsp)
movq $0x1, 0x48(%rsp)
movq 0x10(%rcx), %rax
leaq 0x60(%rsp), %rdi
movq %rax, 0x10(%rdi)
movups (%rcx), %xmm0
movaps %xmm0, (%rdi)
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x5618f
cmpl $0x2, %eax
jb 0x55567
bsrl %eax, %ecx
movl %ecx, %ebp
xorl $-0x20, %ebp
leal -0x1(%rax), %edx
addl $0x21, %ebp
testl %edx, %eax
cmovel %ecx, %ebp
movl %ebp, 0x38(%rsp)
leaq 0x60(%rsp), %r15
movl $0x1, %r12d
movq %r15, %rdi
movl $0x1, %esi
callq 0x5618f
movl %ebp, %ecx
shll %cl, %r12d
movl %eax, 0x3c(%rsp)
movl %r12d, 0x40(%rsp)
movaps (%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x30(%rsp)
testq %r14, %r14
je 0x555c5
movq 0x38(%r14), %rax
movq %rax, 0x58(%rsp)
cmpl $0x4, 0x8(%r13)
sete %cl
movq 0x30(%r14), %rax
shlq %cl, %rax
movq %rax, 0x48(%rsp)
testl %ebp, %ebp
leaq 0xc0(%rsp), %r15
je 0x555e4
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x55e9b
jmp 0x55601
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
xorl %edi, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x55cb6
movq 0x10(%r15), %rax
movl 0x8(%rax), %eax
orl $0x2, %eax
cmpl $0x6, %eax
jne 0x556bf
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x547b8
movl %eax, %esi
movq %r14, %rdi
callq 0x52fb6
movl $0x20, %edi
movq %rbx, %rsi
movl $0x20, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x56da4
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0x556bf
movq (%rax), %rcx
movl (%rcx), %edx
cmpq $0x8, %rdx
jb 0x556bf
movq 0x48(%rsp), %rsi
incq %rsi
movq 0x8(%rcx), %rdi
shlq $0x2, %rdx
andq $-0x20, %rdx
xorl %ecx, %ecx
cmpq %rsi, (%rdi)
je 0x5569c
addq $0x20, %rcx
addq $0x8, %rdi
cmpq %rcx, %rdx
jne 0x55688
jmp 0x556bf
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x556bf
andl $-0x20, %ecx
movaps 0x60(%rsp), %xmm0
movaps 0x70(%rsp), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
hash_tree_root:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov r13, [rsp+0B8h+arg_10]
test r13, r13
jz loc_556BF
mov r14, rsi
mov rbx, rdi
lea rcx, [rsp+0B8h+arg_0]
movups [rsp+0B8h+var_78], xmm0
movups [rsp+0B8h+var_68], xmm0
mov qword ptr [rsp+0B8h+var_78+8], 1
mov rax, [rcx+10h]
lea rdi, [rsp+0B8h+var_58]
mov [rdi+10h], rax
movups xmm0, xmmword ptr [rcx]
movaps xmmword ptr [rdi], xmm0
xor ebp, ebp
xor esi, esi
call calc_num_leafes
cmp eax, 2
jb short loc_55567
bsr ecx, eax
mov ebp, ecx
xor ebp, 0FFFFFFE0h
lea edx, [rax-1]
add ebp, 21h ; '!'
test eax, edx
cmovz ebp, ecx
loc_55567:
mov [rsp+0B8h+var_80], ebp
lea r15, [rsp+0B8h+var_58]
mov r12d, 1
mov rdi, r15
mov esi, 1
call calc_num_leafes
mov ecx, ebp
shl r12d, cl
mov [rsp+0B8h+var_7C], eax
mov dword ptr [rsp+0B8h+var_78], r12d
movaps xmm0, xmmword ptr [r15]
movaps [rsp+0B8h+var_98], xmm0
mov rax, [r15+10h]
mov [rsp+0B8h+var_88], rax
test r14, r14
jz short loc_555C5
mov rax, [r14+38h]
mov qword ptr [rsp+0B8h+var_68+8], rax
cmp dword ptr [r13+8], 4
setz cl
mov rax, [r14+30h]
shl rax, cl
mov qword ptr [rsp+0B8h+var_78+8], rax
loc_555C5:
test ebp, ebp
lea r15, [rsp+0B8h+arg_0]
jz short loc_555E4
lea rdi, [rsp+0B8h+var_98]
xor esi, esi
xor edx, edx
mov rcx, rbx
call merkle_hash
jmp short loc_55601
loc_555E4:
mov rax, [r15+10h]
mov [rsp+0B8h+var_A8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+0B8h+var_B8], xmm0
xor edi, edi
mov rsi, rbx
xor edx, edx
call set_leaf
loc_55601:
mov rax, [r15+10h]
mov eax, [rax+8]
or eax, 2
cmp eax, 6
jnz loc_556BF
xorps xmm0, xmm0
lea r14, [rsp+0B8h+var_58]
movaps xmmword ptr [r14+10h], xmm0
movaps xmmword ptr [r14], xmm0
mov rax, [r15+10h]
mov [rsp+0B8h+var_A8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+0B8h+var_B8], xmm0
call ssz_len
mov esi, eax
mov rdi, r14
call uint64_to_le
mov edi, 20h ; ' '
mov rsi, rbx
mov edx, 20h ; ' '
mov rcx, r14
mov r8, rbx
call sha256_merkle
mov rax, qword ptr [rsp+0B8h+var_68+8]
test rax, rax
jz short loc_556BF
mov rcx, [rax]
mov edx, [rcx]
cmp rdx, 8
jb short loc_556BF
mov rsi, qword ptr [rsp+0B8h+var_78+8]
inc rsi
mov rdi, [rcx+8]
shl rdx, 2
and rdx, 0FFFFFFFFFFFFFFE0h
xor ecx, ecx
loc_55688:
cmp [rdi], rsi
jz short loc_5569C
add rcx, 20h ; ' '
add rdi, 8
cmp rdx, rcx
jnz short loc_55688
jmp short loc_556BF
loc_5569C:
mov rax, [rax+8]
mov rax, [rax+8]
test rax, rax
jz short loc_556BF
and ecx, 0FFFFFFE0h
movaps xmm0, [rsp+0B8h+var_58]
movaps xmm1, [rsp+0B8h+var_48]
movups xmmword ptr [rax+rcx+10h], xmm1
movups xmmword ptr [rax+rcx], xmm0
loc_556BF:
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
void hash_tree_root(
_OWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__int128 a7,
long long a8)
{
unsigned int v9; // ebp
unsigned int v10; // eax
unsigned int v11; // ecx
int v12; // eax
int v13; // r8d
int v14; // r9d
unsigned int v15; // ecx
__int128 *v16; // rdi
long long v17; // rsi
long long v18; // rdx
long long v19; // rcx
long long v20; // r8
long long v21; // r9
unsigned int v22; // eax
unsigned long long v23; // rdx
_QWORD *v24; // rdi
unsigned long long v25; // rdx
long long v26; // rcx
long long v27; // rax
unsigned int v28; // ecx
__int128 v29; // xmm0
__int128 v30; // [rsp+20h] [rbp-98h] BYREF
long long v31; // [rsp+30h] [rbp-88h]
unsigned int v32; // [rsp+38h] [rbp-80h]
int v33; // [rsp+3Ch] [rbp-7Ch]
long long v34; // [rsp+40h] [rbp-78h]
long long v35; // [rsp+48h] [rbp-70h]
__int128 v36; // [rsp+50h] [rbp-68h]
__int128 v37; // [rsp+60h] [rbp-58h] BYREF
__int128 v38; // [rsp+70h] [rbp-48h]
a1[1] = 0LL;
*a1 = 0LL;
if ( a8 )
{
v34 = 0LL;
v36 = 0LL;
v35 = 1LL;
*(_QWORD *)&v38 = a8;
v37 = a7;
v9 = 0;
v10 = calc_num_leafes(&v37, 0LL);
if ( v10 >= 2 )
{
_BitScanReverse(&v11, v10);
v9 = (v11 ^ 0xFFFFFFE0) + 33;
if ( ((v10 - 1) & v10) == 0 )
v9 = v11;
}
v32 = v9;
v12 = calc_num_leafes(&v37, 1LL);
v15 = v9;
v33 = v12;
LODWORD(v34) = 1 << v9;
v30 = v37;
v31 = v38;
if ( a2 )
{
*((_QWORD *)&v36 + 1) = *(_QWORD *)(a2 + 56);
LOBYTE(v15) = *(_DWORD *)(a8 + 8) == 4;
v35 = *(_QWORD *)(a2 + 48) << v15;
}
if ( v9 )
{
v16 = &v30;
v17 = 0LL;
merkle_hash(&v30, 0LL, 0LL, a1);
}
else
{
v16 = 0LL;
v17 = (long long)a1;
set_leaf(0, (_DWORD)a1, 0, v15, v13, v14, a7, DWORD2(a7), a8);
}
if ( (*(_DWORD *)(a8 + 8) | 2) == 6 )
{
v38 = 0LL;
v37 = 0LL;
v22 = ssz_len((long long)v16, v17, v18, v19, v20, v21, a7, *((unsigned int **)&a7 + 1), a8);
uint64_to_le(&v37, v22);
sha256_merkle(32LL, a1, 32LL, &v37, a1);
if ( *((_QWORD *)&v36 + 1) )
{
v23 = ***((unsigned int ***)&v36 + 1);
if ( v23 >= 8 )
{
v24 = *(_QWORD **)(**((_QWORD **)&v36 + 1) + 8LL);
v25 = (4 * v23) & 0xFFFFFFFFFFFFFFE0LL;
v26 = 0LL;
while ( *v24 != v35 + 1 )
{
v26 += 32LL;
++v24;
if ( v25 == v26 )
return;
}
v27 = *(_QWORD *)(*(_QWORD *)(*((_QWORD *)&v36 + 1) + 8LL) + 8LL);
if ( v27 )
{
v28 = v26 & 0xFFFFFFE0;
v29 = v37;
*(_OWORD *)(v27 + v28 + 16) = v38;
*(_OWORD *)(v27 + v28) = v29;
}
}
}
}
}
}
|
hash_tree_root:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV R13,qword ptr [RSP + 0xd0]
TEST R13,R13
JZ 0x001556bf
MOV R14,RSI
MOV RBX,RDI
LEA RCX,[RSP + 0xc0]
MOVUPS xmmword ptr [RSP + 0x40],XMM0
MOVUPS xmmword ptr [RSP + 0x50],XMM0
MOV qword ptr [RSP + 0x48],0x1
MOV RAX,qword ptr [RCX + 0x10]
LEA RDI,[RSP + 0x60]
MOV qword ptr [RDI + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RCX]
MOVAPS xmmword ptr [RDI],XMM0
XOR EBP,EBP
XOR ESI,ESI
CALL 0x0015618f
CMP EAX,0x2
JC 0x00155567
BSR ECX,EAX
MOV EBP,ECX
XOR EBP,0xffffffe0
LEA EDX,[RAX + -0x1]
ADD EBP,0x21
TEST EAX,EDX
CMOVZ EBP,ECX
LAB_00155567:
MOV dword ptr [RSP + 0x38],EBP
LEA R15,[RSP + 0x60]
MOV R12D,0x1
MOV RDI,R15
MOV ESI,0x1
CALL 0x0015618f
MOV ECX,EBP
SHL R12D,CL
MOV dword ptr [RSP + 0x3c],EAX
MOV dword ptr [RSP + 0x40],R12D
MOVAPS XMM0,xmmword ptr [R15]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x30],RAX
TEST R14,R14
JZ 0x001555c5
MOV RAX,qword ptr [R14 + 0x38]
MOV qword ptr [RSP + 0x58],RAX
CMP dword ptr [R13 + 0x8],0x4
SETZ CL
MOV RAX,qword ptr [R14 + 0x30]
SHL RAX,CL
MOV qword ptr [RSP + 0x48],RAX
LAB_001555c5:
TEST EBP,EBP
LEA R15,[RSP + 0xc0]
JZ 0x001555e4
LEA RDI,[RSP + 0x20]
XOR ESI,ESI
XOR EDX,EDX
MOV RCX,RBX
CALL 0x00155e9b
JMP 0x00155601
LAB_001555e4:
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
XOR EDI,EDI
MOV RSI,RBX
XOR EDX,EDX
CALL 0x00155cb6
LAB_00155601:
MOV RAX,qword ptr [R15 + 0x10]
MOV EAX,dword ptr [RAX + 0x8]
OR EAX,0x2
CMP EAX,0x6
JNZ 0x001556bf
XORPS XMM0,XMM0
LEA R14,[RSP + 0x60]
MOVAPS xmmword ptr [R14 + 0x10],XMM0
MOVAPS xmmword ptr [R14],XMM0
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x001547b8
MOV ESI,EAX
MOV RDI,R14
CALL 0x00152fb6
MOV EDI,0x20
MOV RSI,RBX
MOV EDX,0x20
MOV RCX,R14
MOV R8,RBX
CALL 0x00156da4
MOV RAX,qword ptr [RSP + 0x58]
TEST RAX,RAX
JZ 0x001556bf
MOV RCX,qword ptr [RAX]
MOV EDX,dword ptr [RCX]
CMP RDX,0x8
JC 0x001556bf
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
MOV RDI,qword ptr [RCX + 0x8]
SHL RDX,0x2
AND RDX,-0x20
XOR ECX,ECX
LAB_00155688:
CMP qword ptr [RDI],RSI
JZ 0x0015569c
ADD RCX,0x20
ADD RDI,0x8
CMP RDX,RCX
JNZ 0x00155688
JMP 0x001556bf
LAB_0015569c:
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
TEST RAX,RAX
JZ 0x001556bf
AND ECX,0xffffffe0
MOVAPS XMM0,xmmword ptr [RSP + 0x60]
MOVAPS XMM1,xmmword ptr [RSP + 0x70]
MOVUPS xmmword ptr [RAX + RCX*0x1 + 0x10],XMM1
MOVUPS xmmword ptr [RAX + RCX*0x1],XMM0
LAB_001556bf:
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void hash_tree_root(int8 *param_1,long param_2)
{
int8 *puVar1;
long lVar2;
uint uVar3;
uint uVar4;
int4 uVar5;
ulong uVar6;
ulong uVar7;
uint uVar8;
long *plVar9;
int8 in_R9;
int4 uStack0000000000000008;
int4 uStack000000000000000c;
int4 uStack0000000000000010;
int4 uStack0000000000000014;
long in_stack_00000018;
int4 uStack_98;
int4 uStack_94;
int4 uStack_90;
int4 uStack_8c;
long lStack_88;
uint uStack_80;
int4 uStack_7c;
int8 local_78;
long lStack_70;
int8 local_68;
int8 *puStack_60;
int8 local_58;
int8 uStack_50;
long local_48;
int8 uStack_40;
param_1[2] = 0;
param_1[3] = 0;
*param_1 = 0;
param_1[1] = 0;
if (in_stack_00000018 != 0) {
local_78 = 0;
local_68 = 0;
puStack_60 = (int8 *)0x0;
lStack_70 = 1;
local_48 = in_stack_00000018;
local_58._0_4_ = uStack0000000000000008;
local_58._4_4_ = uStack000000000000000c;
uStack_50._0_4_ = uStack0000000000000010;
uStack_50._4_4_ = uStack0000000000000014;
uVar4 = calc_num_leafes(&local_58,0);
uVar8 = 0;
if (1 < uVar4) {
uVar3 = 0x1f;
if (uVar4 != 0) {
for (; uVar4 >> uVar3 == 0; uVar3 = uVar3 - 1) {
}
}
uVar8 = (uVar3 ^ 0xffffffe0) + 0x21;
if ((uVar4 & uVar4 - 1) == 0) {
uVar8 = uVar3;
}
}
uStack_80 = uVar8;
uStack_7c = calc_num_leafes(&local_58,1);
local_78 = CONCAT44(local_78._4_4_,1 << ((byte)uVar8 & 0x1f));
uStack_98 = (int4)local_58;
uStack_94 = local_58._4_4_;
uStack_90 = (int4)uStack_50;
uStack_8c = uStack_50._4_4_;
lStack_88 = local_48;
if (param_2 != 0) {
puStack_60 = *(int8 **)(param_2 + 0x38);
lStack_70 = *(long *)(param_2 + 0x30) << (*(int *)(in_stack_00000018 + 8) == 4);
}
if (uVar8 == 0) {
set_leaf(0,param_1,0);
}
else {
merkle_hash(&uStack_98,0,0,param_1);
}
if ((*(uint *)(in_stack_00000018 + 8) | 2) == 6) {
local_48 = 0;
uStack_40 = 0;
local_58 = 0;
uStack_50 = 0;
uVar5 = ssz_len();
uint64_to_le(&local_58,uVar5);
sha256_merkle(0x20,param_1,0x20,&local_58,param_1,in_R9,uStack0000000000000008,
uStack0000000000000010,in_stack_00000018);
if (puStack_60 != (int8 *)0x0) {
uVar7 = (ulong)*(uint *)*puStack_60;
if (7 < uVar7) {
plVar9 = *(long **)((uint *)*puStack_60 + 2);
uVar6 = 0;
do {
if (*plVar9 == lStack_70 + 1) {
lVar2 = *(long *)(puStack_60[1] + 8);
if (lVar2 == 0) {
return;
}
puVar1 = (int8 *)(lVar2 + 0x10 + (uVar6 & 0xffffffff));
*puVar1 = local_48;
puVar1[1] = uStack_40;
puVar1 = (int8 *)(lVar2 + (uVar6 & 0xffffffff));
*puVar1 = local_58;
puVar1[1] = uStack_50;
return;
}
uVar6 = uVar6 + 0x20;
plVar9 = plVar9 + 1;
} while ((uVar7 & 0x3ffffffffffffff8) * 4 != uVar6);
}
}
}
}
return;
}
|
|
10,871 |
create_fromuni
|
eloqsql/strings/ctype-simple.c
|
static my_bool
create_fromuni(struct charset_info_st *cs,
MY_CHARSET_LOADER *loader)
{
uni_idx idx[PLANE_NUM];
int i,n;
/*
Check that Unicode map is loaded.
It can be not loaded when the collation is
listed in Index.xml but not specified
in the character set specific XML file.
*/
if (!cs->tab_to_uni)
return TRUE;
/* Clear plane statistics */
bzero(idx,sizeof(idx));
/* Count number of characters in each plane */
for (i=0; i< 0x100; i++)
{
uint16 wc=cs->tab_to_uni[i];
int pl= PLANE_NUMBER(wc);
if (wc || !i)
{
if (!idx[pl].nchars)
{
idx[pl].uidx.from=wc;
idx[pl].uidx.to=wc;
}else
{
idx[pl].uidx.from=wc<idx[pl].uidx.from?wc:idx[pl].uidx.from;
idx[pl].uidx.to=wc>idx[pl].uidx.to?wc:idx[pl].uidx.to;
}
idx[pl].nchars++;
}
}
/* Sort planes in descending order */
qsort(&idx,PLANE_NUM,sizeof(uni_idx),&pcmp);
for (i=0; i < PLANE_NUM; i++)
{
int ch,numchars;
uchar *tab;
/* Skip empty plane */
if (!idx[i].nchars)
break;
numchars=idx[i].uidx.to-idx[i].uidx.from+1;
if (!(idx[i].uidx.tab= tab= (uchar*)
(loader->once_alloc) (numchars *
sizeof(*idx[i].uidx.tab))))
return TRUE;
bzero(tab,numchars*sizeof(*tab));
for (ch=1; ch < PLANE_SIZE; ch++)
{
uint16 wc=cs->tab_to_uni[ch];
if (wc >= idx[i].uidx.from && wc <= idx[i].uidx.to && wc)
{
int ofs= wc - idx[i].uidx.from;
if (!tab[ofs] || tab[ofs] > 0x7F) /* Prefer ASCII*/
{
/*
Some character sets can have double encoding. For example,
in ARMSCII8, the following characters are encoded twice:
Encoding#1 Encoding#2 Unicode Character Name
---------- ---------- ------- --------------
0x27 0xFF U+0027 APOSTROPHE
0x28 0xA5 U+0028 LEFT PARENTHESIS
0x29 0xA4 U+0029 RIGHT PARENTHESIS
0x2C 0xAB U+002C COMMA
0x2D 0xAC U+002D HYPHEN-MINUS
0x2E 0xA9 U+002E FULL STOP
That is, both 0x27 and 0xFF convert to Unicode U+0027.
When converting back from Unicode to ARMSCII,
we prefer the ASCII range, that is we want U+0027
to convert to 0x27 rather than to 0xFF.
*/
tab[ofs]= ch;
}
}
}
}
/* Allocate and fill reverse table for each plane */
n=i;
if (!(cs->tab_from_uni= (MY_UNI_IDX *)
(loader->once_alloc)(sizeof(MY_UNI_IDX) * (n + 1))))
return TRUE;
for (i=0; i< n; i++)
((struct my_uni_idx_st*)cs->tab_from_uni)[i]= idx[i].uidx;
/* Set end-of-list marker */
bzero((char*) &cs->tab_from_uni[i],sizeof(MY_UNI_IDX));
return FALSE;
}
|
O0
|
c
|
create_fromuni:
pushq %rbp
movq %rsp, %rbp
subq $0x1850, %rsp # imm = 0x1850
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x7f4a7
movb $0x1, -0x1(%rbp)
jmp 0x7f97a
leaq -0x1820(%rbp), %rdi
xorl %esi, %esi
movl $0x1800, %edx # imm = 0x1800
callq 0x261c0
movl $0x0, -0x1824(%rbp)
cmpl $0x100, -0x1824(%rbp) # imm = 0x100
jge 0x7f698
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x1824(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x182a(%rbp)
movzwl -0x182a(%rbp), %eax
sarl $0x8, %eax
movl $0x100, %ecx # imm = 0x100
cltd
idivl %ecx
movl %edx, -0x1830(%rbp)
movzwl -0x182a(%rbp), %eax
cmpl $0x0, %eax
jne 0x7f51f
cmpl $0x0, -0x1824(%rbp)
jne 0x7f682
movslq -0x1830(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x7f57e
movw -0x182a(%rbp), %cx
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
movw -0x182a(%rbp), %cx
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0xa(%rax)
jmp 0x7f666
movzwl -0x182a(%rbp), %eax
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x7f5b1
movzwl -0x182a(%rbp), %eax
movl %eax, -0x184c(%rbp)
jmp 0x7f5d0
movslq -0x1830(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzwl 0x8(%rax), %eax
movl %eax, -0x184c(%rbp)
movl -0x184c(%rbp), %eax
movw %ax, %cx
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
movzwl -0x182a(%rbp), %eax
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0xa(%rcx), %ecx
cmpl %ecx, %eax
jle 0x7f625
movzwl -0x182a(%rbp), %eax
movl %eax, -0x1850(%rbp)
jmp 0x7f644
movslq -0x1830(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzwl 0xa(%rax), %eax
movl %eax, -0x1850(%rbp)
movl -0x1850(%rbp), %eax
movw %ax, %cx
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0xa(%rax)
movslq -0x1830(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x7f684
movl -0x1824(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1824(%rbp)
jmp 0x7f4c4
leaq -0x1820(%rbp), %rdi
movl $0x100, %esi # imm = 0x100
movl $0x18, %edx
leaq 0x2e0(%rip), %rcx # 0x7f990
callq 0x26610
movl $0x0, -0x1824(%rbp)
cmpl $0x100, -0x1824(%rbp) # imm = 0x100
jge 0x7f8b1
movslq -0x1824(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x7f6ee
jmp 0x7f8b1
movslq -0x1824(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzwl 0xa(%rax), %eax
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x8(%rcx), %ecx
subl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x1838(%rbp)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0x1838(%rbp), %rdi
shlq $0x0, %rdi
callq *%rax
movq %rax, -0x1840(%rbp)
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x7f772
movb $0x1, -0x1(%rbp)
jmp 0x7f97a
movq -0x1840(%rbp), %rdi
movslq -0x1838(%rbp), %rdx
shlq $0x0, %rdx
xorl %esi, %esi
callq 0x261c0
movl $0x1, -0x1834(%rbp)
cmpl $0x100, -0x1834(%rbp) # imm = 0x100
jge 0x7f89b
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x1834(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x1842(%rbp)
movzwl -0x1842(%rbp), %eax
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jl 0x7f885
movzwl -0x1842(%rbp), %eax
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0xa(%rcx), %ecx
cmpl %ecx, %eax
jg 0x7f885
movzwl -0x1842(%rbp), %eax
cmpl $0x0, %eax
je 0x7f885
movzwl -0x1842(%rbp), %eax
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x8(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x1848(%rbp)
movq -0x1840(%rbp), %rax
movslq -0x1848(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x7f86a
movq -0x1840(%rbp), %rax
movslq -0x1848(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x7f, %eax
jle 0x7f883
movl -0x1834(%rbp), %eax
movb %al, %dl
movq -0x1840(%rbp), %rax
movslq -0x1848(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x7f885
jmp 0x7f887
movl -0x1834(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1834(%rbp)
jmp 0x7f795
jmp 0x7f89d
movl -0x1824(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1824(%rbp)
jmp 0x7f6bf
movl -0x1824(%rbp), %eax
movl %eax, -0x1828(%rbp)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movl -0x1828(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdi
shlq $0x4, %rdi
callq *%rax
movq -0x10(%rbp), %rcx
movq %rax, 0x70(%rcx)
cmpq $0x0, %rax
jne 0x7f8f1
movb $0x1, -0x1(%rbp)
jmp 0x7f97a
movl $0x0, -0x1824(%rbp)
movl -0x1824(%rbp), %eax
cmpl -0x1828(%rbp), %eax
jge 0x7f954
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0x1824(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x1824(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1824(%rbp)
jmp 0x7f8fb
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
movslq -0x1824(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x261c0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x1850, %rsp # imm = 0x1850
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
create_fromuni:
push rbp
mov rbp, rsp
sub rsp, 1850h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
cmp qword ptr [rax+68h], 0
jnz short loc_7F4A7
mov [rbp+var_1], 1
jmp loc_7F97A
loc_7F4A7:
lea rdi, [rbp+var_1820]
xor esi, esi
mov edx, 1800h
call _memset
mov [rbp+var_1824], 0
loc_7F4C4:
cmp [rbp+var_1824], 100h
jge loc_7F698
mov rax, [rbp+var_10]
mov rax, [rax+68h]
movsxd rcx, [rbp+var_1824]
mov ax, [rax+rcx*2]
mov [rbp+var_182A], ax
movzx eax, [rbp+var_182A]
sar eax, 8
mov ecx, 100h
cdq
idiv ecx
mov [rbp+var_1830], edx
movzx eax, [rbp+var_182A]
cmp eax, 0
jnz short loc_7F51F
cmp [rbp+var_1824], 0
jnz loc_7F682
loc_7F51F:
movsxd rcx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
cmp dword ptr [rax], 0
jnz short loc_7F57E
mov cx, [rbp+var_182A]
movsxd rdx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rdx, 18h
add rax, rdx
mov [rax+8], cx
mov cx, [rbp+var_182A]
movsxd rdx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rdx, 18h
add rax, rdx
mov [rax+0Ah], cx
jmp loc_7F666
loc_7F57E:
movzx eax, [rbp+var_182A]
movsxd rdx, [rbp+var_1830]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+8]
cmp eax, ecx
jge short loc_7F5B1
movzx eax, [rbp+var_182A]
mov [rbp+var_184C], eax
jmp short loc_7F5D0
loc_7F5B1:
movsxd rcx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
movzx eax, word ptr [rax+8]
mov [rbp+var_184C], eax
loc_7F5D0:
mov eax, [rbp+var_184C]
mov cx, ax
movsxd rdx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rdx, 18h
add rax, rdx
mov [rax+8], cx
movzx eax, [rbp+var_182A]
movsxd rdx, [rbp+var_1830]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+0Ah]
cmp eax, ecx
jle short loc_7F625
movzx eax, [rbp+var_182A]
mov [rbp+var_1850], eax
jmp short loc_7F644
loc_7F625:
movsxd rcx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
movzx eax, word ptr [rax+0Ah]
mov [rbp+var_1850], eax
loc_7F644:
mov eax, [rbp+var_1850]
mov cx, ax
movsxd rdx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rdx, 18h
add rax, rdx
mov [rax+0Ah], cx
loc_7F666:
movsxd rcx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
mov ecx, [rax]
add ecx, 1
mov [rax], ecx
loc_7F682:
jmp short $+2
loc_7F684:
mov eax, [rbp+var_1824]
add eax, 1
mov [rbp+var_1824], eax
jmp loc_7F4C4
loc_7F698:
lea rdi, [rbp+var_1820]
mov esi, 100h
mov edx, 18h
lea rcx, pcmp
call _qsort
mov [rbp+var_1824], 0
loc_7F6BF:
cmp [rbp+var_1824], 100h
jge loc_7F8B1
movsxd rcx, [rbp+var_1824]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
cmp dword ptr [rax], 0
jnz short loc_7F6EE
jmp loc_7F8B1
loc_7F6EE:
movsxd rcx, [rbp+var_1824]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
movzx eax, word ptr [rax+0Ah]
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+8]
sub eax, ecx
add eax, 1
mov [rbp+var_1838], eax
mov rax, [rbp+var_18]
mov rax, [rax+80h]
movsxd rdi, [rbp+var_1838]
shl rdi, 0
call rax
mov [rbp+var_1840], rax
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
mov [rcx+10h], rax
cmp rax, 0
jnz short loc_7F772
mov [rbp+var_1], 1
jmp loc_7F97A
loc_7F772:
mov rdi, [rbp+var_1840]
movsxd rdx, [rbp+var_1838]
shl rdx, 0
xor esi, esi
call _memset
mov [rbp+var_1834], 1
loc_7F795:
cmp [rbp+var_1834], 100h
jge loc_7F89B
mov rax, [rbp+var_10]
mov rax, [rax+68h]
movsxd rcx, [rbp+var_1834]
mov ax, [rax+rcx*2]
mov [rbp+var_1842], ax
movzx eax, [rbp+var_1842]
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+8]
cmp eax, ecx
jl loc_7F885
movzx eax, [rbp+var_1842]
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+0Ah]
cmp eax, ecx
jg short loc_7F885
movzx eax, [rbp+var_1842]
cmp eax, 0
jz short loc_7F885
movzx eax, [rbp+var_1842]
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+8]
sub eax, ecx
mov [rbp+var_1848], eax
mov rax, [rbp+var_1840]
movsxd rcx, [rbp+var_1848]
cmp byte ptr [rax+rcx], 0
jz short loc_7F86A
mov rax, [rbp+var_1840]
movsxd rcx, [rbp+var_1848]
movzx eax, byte ptr [rax+rcx]
cmp eax, 7Fh
jle short loc_7F883
loc_7F86A:
mov eax, [rbp+var_1834]
mov dl, al
mov rax, [rbp+var_1840]
movsxd rcx, [rbp+var_1848]
mov [rax+rcx], dl
loc_7F883:
jmp short $+2
loc_7F885:
jmp short $+2
loc_7F887:
mov eax, [rbp+var_1834]
add eax, 1
mov [rbp+var_1834], eax
jmp loc_7F795
loc_7F89B:
jmp short $+2
loc_7F89D:
mov eax, [rbp+var_1824]
add eax, 1
mov [rbp+var_1824], eax
jmp loc_7F6BF
loc_7F8B1:
mov eax, [rbp+var_1824]
mov [rbp+var_1828], eax
mov rax, [rbp+var_18]
mov rax, [rax+80h]
mov ecx, [rbp+var_1828]
add ecx, 1
movsxd rdi, ecx
shl rdi, 4
call rax
mov rcx, [rbp+var_10]
mov [rcx+70h], rax
cmp rax, 0
jnz short loc_7F8F1
mov [rbp+var_1], 1
jmp loc_7F97A
loc_7F8F1:
mov [rbp+var_1824], 0
loc_7F8FB:
mov eax, [rbp+var_1824]
cmp eax, [rbp+var_1828]
jge short loc_7F954
mov rax, [rbp+var_10]
mov rax, [rax+70h]
movsxd rcx, [rbp+var_1824]
shl rcx, 4
add rax, rcx
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
mov rdx, [rcx+8]
mov [rax], rdx
mov rcx, [rcx+10h]
mov [rax+8], rcx
mov eax, [rbp+var_1824]
add eax, 1
mov [rbp+var_1824], eax
jmp short loc_7F8FB
loc_7F954:
mov rax, [rbp+var_10]
mov rdi, [rax+70h]
movsxd rax, [rbp+var_1824]
shl rax, 4
add rdi, rax
xor esi, esi
mov edx, 10h
call _memset
mov [rbp+var_1], 0
loc_7F97A:
mov al, [rbp+var_1]
add rsp, 1850h
pop rbp
retn
|
char create_fromuni(long long a1, long long a2)
{
long long v2; // rax
_QWORD *v3; // rax
unsigned __int16 v5; // [rsp+0h] [rbp-1850h]
__int16 v6; // [rsp+4h] [rbp-184Ch]
int v7; // [rsp+8h] [rbp-1848h]
unsigned __int16 v8; // [rsp+Eh] [rbp-1842h]
long long v9; // [rsp+10h] [rbp-1840h]
int v10; // [rsp+18h] [rbp-1838h]
int k; // [rsp+1Ch] [rbp-1834h]
int v12; // [rsp+20h] [rbp-1830h]
unsigned __int16 v13; // [rsp+26h] [rbp-182Ah]
int v14; // [rsp+28h] [rbp-1828h]
int i; // [rsp+2Ch] [rbp-1824h]
int j; // [rsp+2Ch] [rbp-1824h]
int m; // [rsp+2Ch] [rbp-1824h]
_DWORD v18[1538]; // [rsp+30h] [rbp-1820h] BYREF
long long v19; // [rsp+1838h] [rbp-18h]
long long v20; // [rsp+1840h] [rbp-10h]
v20 = a1;
v19 = a2;
if ( !*(_QWORD *)(a1 + 104) )
return 1;
memset(v18, 0LL, 6144LL);
for ( i = 0; i < 256; ++i )
{
v13 = *(_WORD *)(*(_QWORD *)(v20 + 104) + 2LL * i);
v12 = ((int)v13 >> 8) % 256;
if ( v13 || !i )
{
if ( v18[6 * v12] )
{
if ( v13 >= (int)LOWORD(v18[6 * v12 + 2]) )
v6 = v18[6 * v12 + 2];
else
v6 = *(_WORD *)(*(_QWORD *)(v20 + 104) + 2LL * i);
LOWORD(v18[6 * v12 + 2]) = v6;
if ( v13 <= (int)HIWORD(v18[6 * v12 + 2]) )
v5 = HIWORD(v18[6 * v12 + 2]);
else
v5 = v13;
HIWORD(v18[6 * v12 + 2]) = v5;
}
else
{
LOWORD(v18[6 * v12 + 2]) = v13;
HIWORD(v18[6 * v12 + 2]) = v13;
}
++v18[6 * v12];
}
}
qsort(v18, 256LL, 24LL, pcmp);
for ( j = 0; j < 256 && v18[6 * j]; ++j )
{
v10 = HIWORD(v18[6 * j + 2]) - LOWORD(v18[6 * j + 2]) + 1;
v9 = (*(long long ( **)(_QWORD))(v19 + 128))(v10);
*(_QWORD *)&v18[6 * j + 4] = v9;
if ( !v9 )
return 1;
memset(v9, 0LL, v10);
for ( k = 1; k < 256; ++k )
{
v8 = *(_WORD *)(*(_QWORD *)(v20 + 104) + 2LL * k);
if ( v8 >= (int)LOWORD(v18[6 * j + 2]) && v8 <= (int)HIWORD(v18[6 * j + 2]) )
{
if ( v8 )
{
v7 = v8 - LOWORD(v18[6 * j + 2]);
if ( !*(_BYTE *)(v9 + v7) || *(unsigned __int8 *)(v9 + v7) > 0x7Fu )
*(_BYTE *)(v9 + v7) = k;
}
}
}
}
v14 = j;
v2 = (*(long long ( **)(long long))(v19 + 128))(16LL * (j + 1));
*(_QWORD *)(v20 + 112) = v2;
if ( !v2 )
return 1;
for ( m = 0; m < v14; ++m )
{
v3 = (_QWORD *)(16LL * m + *(_QWORD *)(v20 + 112));
*v3 = *(_QWORD *)&v18[6 * m + 2];
v3[1] = *(_QWORD *)&v18[6 * m + 4];
}
memset(16LL * m + *(_QWORD *)(v20 + 112), 0LL, 16LL);
return 0;
}
|
create_fromuni:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1850
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x0017f4a7
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017f97a
LAB_0017f4a7:
LEA RDI,[RBP + -0x1820]
XOR ESI,ESI
MOV EDX,0x1800
CALL 0x001261c0
MOV dword ptr [RBP + -0x1824],0x0
LAB_0017f4c4:
CMP dword ptr [RBP + -0x1824],0x100
JGE 0x0017f698
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOVSXD RCX,dword ptr [RBP + -0x1824]
MOV AX,word ptr [RAX + RCX*0x2]
MOV word ptr [RBP + -0x182a],AX
MOVZX EAX,word ptr [RBP + -0x182a]
SAR EAX,0x8
MOV ECX,0x100
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x1830],EDX
MOVZX EAX,word ptr [RBP + -0x182a]
CMP EAX,0x0
JNZ 0x0017f51f
CMP dword ptr [RBP + -0x1824],0x0
JNZ 0x0017f682
LAB_0017f51f:
MOVSXD RCX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
CMP dword ptr [RAX],0x0
JNZ 0x0017f57e
MOV CX,word ptr [RBP + -0x182a]
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RAX,RDX
MOV word ptr [RAX + 0x8],CX
MOV CX,word ptr [RBP + -0x182a]
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RAX,RDX
MOV word ptr [RAX + 0xa],CX
JMP 0x0017f666
LAB_0017f57e:
MOVZX EAX,word ptr [RBP + -0x182a]
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0x8]
CMP EAX,ECX
JGE 0x0017f5b1
MOVZX EAX,word ptr [RBP + -0x182a]
MOV dword ptr [RBP + -0x184c],EAX
JMP 0x0017f5d0
LAB_0017f5b1:
MOVSXD RCX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOVZX EAX,word ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x184c],EAX
LAB_0017f5d0:
MOV EAX,dword ptr [RBP + -0x184c]
MOV CX,AX
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RAX,RDX
MOV word ptr [RAX + 0x8],CX
MOVZX EAX,word ptr [RBP + -0x182a]
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0xa]
CMP EAX,ECX
JLE 0x0017f625
MOVZX EAX,word ptr [RBP + -0x182a]
MOV dword ptr [RBP + -0x1850],EAX
JMP 0x0017f644
LAB_0017f625:
MOVSXD RCX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOVZX EAX,word ptr [RAX + 0xa]
MOV dword ptr [RBP + -0x1850],EAX
LAB_0017f644:
MOV EAX,dword ptr [RBP + -0x1850]
MOV CX,AX
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RAX,RDX
MOV word ptr [RAX + 0xa],CX
LAB_0017f666:
MOVSXD RCX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
MOV dword ptr [RAX],ECX
LAB_0017f682:
JMP 0x0017f684
LAB_0017f684:
MOV EAX,dword ptr [RBP + -0x1824]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1824],EAX
JMP 0x0017f4c4
LAB_0017f698:
LEA RDI,[RBP + -0x1820]
MOV ESI,0x100
MOV EDX,0x18
LEA RCX,[0x17f990]
CALL 0x00126610
MOV dword ptr [RBP + -0x1824],0x0
LAB_0017f6bf:
CMP dword ptr [RBP + -0x1824],0x100
JGE 0x0017f8b1
MOVSXD RCX,dword ptr [RBP + -0x1824]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
CMP dword ptr [RAX],0x0
JNZ 0x0017f6ee
JMP 0x0017f8b1
LAB_0017f6ee:
MOVSXD RCX,dword ptr [RBP + -0x1824]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOVZX EAX,word ptr [RAX + 0xa]
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0x8]
SUB EAX,ECX
ADD EAX,0x1
MOV dword ptr [RBP + -0x1838],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x80]
MOVSXD RDI,dword ptr [RBP + -0x1838]
SHL RDI,0x0
CALL RAX
MOV qword ptr [RBP + -0x1840],RAX
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JNZ 0x0017f772
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017f97a
LAB_0017f772:
MOV RDI,qword ptr [RBP + -0x1840]
MOVSXD RDX,dword ptr [RBP + -0x1838]
SHL RDX,0x0
XOR ESI,ESI
CALL 0x001261c0
MOV dword ptr [RBP + -0x1834],0x1
LAB_0017f795:
CMP dword ptr [RBP + -0x1834],0x100
JGE 0x0017f89b
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOVSXD RCX,dword ptr [RBP + -0x1834]
MOV AX,word ptr [RAX + RCX*0x2]
MOV word ptr [RBP + -0x1842],AX
MOVZX EAX,word ptr [RBP + -0x1842]
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0x8]
CMP EAX,ECX
JL 0x0017f885
MOVZX EAX,word ptr [RBP + -0x1842]
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0xa]
CMP EAX,ECX
JG 0x0017f885
MOVZX EAX,word ptr [RBP + -0x1842]
CMP EAX,0x0
JZ 0x0017f885
MOVZX EAX,word ptr [RBP + -0x1842]
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0x8]
SUB EAX,ECX
MOV dword ptr [RBP + -0x1848],EAX
MOV RAX,qword ptr [RBP + -0x1840]
MOVSXD RCX,dword ptr [RBP + -0x1848]
CMP byte ptr [RAX + RCX*0x1],0x0
JZ 0x0017f86a
MOV RAX,qword ptr [RBP + -0x1840]
MOVSXD RCX,dword ptr [RBP + -0x1848]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x7f
JLE 0x0017f883
LAB_0017f86a:
MOV EAX,dword ptr [RBP + -0x1834]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x1840]
MOVSXD RCX,dword ptr [RBP + -0x1848]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_0017f883:
JMP 0x0017f885
LAB_0017f885:
JMP 0x0017f887
LAB_0017f887:
MOV EAX,dword ptr [RBP + -0x1834]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1834],EAX
JMP 0x0017f795
LAB_0017f89b:
JMP 0x0017f89d
LAB_0017f89d:
MOV EAX,dword ptr [RBP + -0x1824]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1824],EAX
JMP 0x0017f6bf
LAB_0017f8b1:
MOV EAX,dword ptr [RBP + -0x1824]
MOV dword ptr [RBP + -0x1828],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,dword ptr [RBP + -0x1828]
ADD ECX,0x1
MOVSXD RDI,ECX
SHL RDI,0x4
CALL RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x70],RAX
CMP RAX,0x0
JNZ 0x0017f8f1
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017f97a
LAB_0017f8f1:
MOV dword ptr [RBP + -0x1824],0x0
LAB_0017f8fb:
MOV EAX,dword ptr [RBP + -0x1824]
CMP EAX,dword ptr [RBP + -0x1828]
JGE 0x0017f954
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x70]
MOVSXD RCX,dword ptr [RBP + -0x1824]
SHL RCX,0x4
ADD RAX,RCX
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOV RDX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x1824]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1824],EAX
JMP 0x0017f8fb
LAB_0017f954:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x70]
MOVSXD RAX,dword ptr [RBP + -0x1824]
SHL RAX,0x4
ADD RDI,RAX
XOR ESI,ESI
MOV EDX,0x10
CALL 0x001261c0
MOV byte ptr [RBP + -0x1],0x0
LAB_0017f97a:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x1850
POP RBP
RET
|
int1 create_fromuni(long param_1,long param_2)
{
ushort uVar1;
ushort uVar2;
int iVar3;
void *__s;
long lVar4;
int8 *puVar5;
uint uVar6;
int local_183c;
int local_182c;
int local_1828 [2];
ushort auStack_1820 [4];
int8 auStack_1818 [767];
long local_20;
long local_18;
int1 local_9;
if (*(long *)(param_1 + 0x68) == 0) {
local_9 = 1;
}
else {
local_20 = param_2;
local_18 = param_1;
memset(local_1828,0,0x1800);
for (local_182c = 0; local_182c < 0x100; local_182c = local_182c + 1) {
uVar1 = *(ushort *)(*(long *)(local_18 + 0x68) + (long)local_182c * 2);
uVar6 = (uint)((int)(uint)uVar1 >> 8) % 0x100;
if ((uVar1 != 0) || (local_182c == 0)) {
if (local_1828[(long)(int)uVar6 * 6] == 0) {
auStack_1820[(long)(int)uVar6 * 0xc] = uVar1;
auStack_1820[(long)(int)uVar6 * 0xc + 1] = uVar1;
}
else {
uVar2 = uVar1;
if (auStack_1820[(long)(int)uVar6 * 0xc] <= uVar1) {
uVar2 = auStack_1820[(long)(int)uVar6 * 0xc];
}
auStack_1820[(long)(int)uVar6 * 0xc] = uVar2;
if (uVar1 <= auStack_1820[(long)(int)uVar6 * 0xc + 1]) {
uVar1 = auStack_1820[(long)(int)uVar6 * 0xc + 1];
}
auStack_1820[(long)(int)uVar6 * 0xc + 1] = uVar1;
}
local_1828[(long)(int)uVar6 * 6] = local_1828[(long)(int)uVar6 * 6] + 1;
}
}
qsort(local_1828,0x100,0x18,pcmp);
local_182c = 0;
while ((iVar3 = local_182c, local_182c < 0x100 && (local_1828[(long)local_182c * 6] != 0))) {
iVar3 = ((uint)auStack_1820[(long)local_182c * 0xc + 1] -
(uint)auStack_1820[(long)local_182c * 0xc]) + 1;
__s = (void *)(**(code **)(local_20 + 0x80))((long)iVar3);
auStack_1818[(long)local_182c * 3] = __s;
if (__s == (void *)0x0) {
return 1;
}
memset(__s,0,(long)iVar3);
for (local_183c = 1; local_183c < 0x100; local_183c = local_183c + 1) {
uVar1 = *(ushort *)(*(long *)(local_18 + 0x68) + (long)local_183c * 2);
if ((((auStack_1820[(long)local_182c * 0xc] <= uVar1) &&
(uVar1 <= auStack_1820[(long)local_182c * 0xc + 1])) && (uVar1 != 0)) &&
((iVar3 = (uint)uVar1 - (uint)auStack_1820[(long)local_182c * 0xc],
*(char *)((long)__s + (long)iVar3) == '\0' ||
(0x7f < *(byte *)((long)__s + (long)iVar3))))) {
*(char *)((long)__s + (long)iVar3) = (char)local_183c;
}
}
local_182c = local_182c + 1;
}
lVar4 = (**(code **)(local_20 + 0x80))((long)(local_182c + 1) << 4);
*(long *)(local_18 + 0x70) = lVar4;
if (lVar4 == 0) {
local_9 = 1;
}
else {
for (local_182c = 0; local_182c < iVar3; local_182c = local_182c + 1) {
puVar5 = (int8 *)(*(long *)(local_18 + 0x70) + (long)local_182c * 0x10);
*puVar5 = *(int8 *)(auStack_1820 + (long)local_182c * 0xc);
puVar5[1] = auStack_1818[(long)local_182c * 3];
}
memset((void *)(*(long *)(local_18 + 0x70) + (long)local_182c * 0x10),0,0x10);
local_9 = 0;
}
}
return local_9;
}
|
|
10,872 |
LefDefParser::lefGetIntDefine(char const*, int*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lef_keywords.cpp
|
inline int
lefGetIntDefine(const char* name, int* value)
{
map<string, int, lefCompareStrings>::iterator search = lefData->defineb_set.find(strip_case(name));
if ( search != lefData->defineb_set.end()) {
*value = search->second;
return TRUE;
}
return FALSE;
}
|
O3
|
cpp
|
LefDefParser::lefGetIntDefine(char const*, int*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x50974(%rip), %r12 # 0x775e0
movl $0x16b8, %r14d # imm = 0x16B8
addq (%r12), %r14
movq %rsp, %rdi
leaq 0xc(%rsp), %rdx
callq 0x26796
movq (%r12), %rax
cmpl $0x0, 0x220(%rax)
je 0x26ccb
movq %rsp, %rsi
movq %r14, %rdi
callq 0x26e88
movq %rax, %r14
movq (%rsp), %rdi
addq $-0x18, %rdi
leaq 0xe(%rsp), %rsi
callq 0x2130
movl $0x16c0, %eax # imm = 0x16C0
addq (%r12), %rax
cmpq %rax, %r14
je 0x26d1b
movl 0x28(%r14), %eax
movl %eax, (%rbx)
movl $0x1, %eax
jmp 0x26d1d
movq (%rsp), %rax
movl -0x8(%rax), %ecx
testl %ecx, %ecx
js 0x26ce2
movq %rsp, %rdi
callq 0x2070
movq (%rsp), %rax
movq %rsp, %r15
movq %rax, %r13
movl -0x8(%rax), %ecx
testl %ecx, %ecx
js 0x26cfb
movq %r15, %rdi
callq 0x2070
movq (%rsp), %rax
addq -0x18(%rax), %rax
cmpq %rax, %r13
je 0x26c90
movsbl (%r13), %edi
callq 0x2390
movb %al, (%r13)
incq %r13
movq (%rsp), %rax
jmp 0x26ce8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x26d3f
movq %rax, %rbx
movq (%rsp), %rdi
addq $-0x18, %rdi
leaq 0xf(%rsp), %rsi
jmp 0x26d4f
movq %rax, %rbx
movq (%rsp), %rdi
addq $-0x18, %rdi
leaq 0xd(%rsp), %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x2350
|
_ZN12LefDefParser15lefGetIntDefineEPKcPi:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rbx, rsi
mov rsi, rdi
lea r12, _ZN12LefDefParser7lefDataE; LefDefParser::lefData
mov r14d, 16B8h
add r14, [r12]
mov rdi, rsp
lea rdx, [rsp+38h+var_2C]
call _ZNSsC2ISaIcEEEPKcRKS0_; std::string::string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rax, [r12]
cmp dword ptr [rax+220h], 0
jz short loc_26CCB
loc_26C90:
mov rsi, rsp
mov rdi, r14
call _ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_EN12LefDefParser17lefCompareStringsESaIS2_EE4findERS1_; std::_Rb_tree<std::string,std::pair<std::string const,int>,std::_Select1st<std::pair<std::string const,int>>,LefDefParser::lefCompareStrings,std::allocator<std::pair<std::string const,int>>>::find(std::string const&)
mov r14, rax
mov rdi, [rsp+38h+var_38]
add rdi, 0FFFFFFFFFFFFFFE8h
lea rsi, [rsp+38h+var_2A]
call __ZNSs4_Rep10_M_disposeERKSaIcE; std::string::_Rep::_M_dispose(std::allocator<char> const&)
mov eax, 16C0h
add rax, [r12]
cmp r14, rax
jz short loc_26D1B
mov eax, [r14+28h]
mov [rbx], eax
mov eax, 1
jmp short loc_26D1D
loc_26CCB:
mov rax, [rsp+38h+var_38]
mov ecx, [rax-8]
test ecx, ecx
js short loc_26CE2
mov rdi, rsp; this
call __ZNSs12_M_leak_hardEv; std::string::_M_leak_hard(void)
mov rax, [rsp+38h+var_38]
loc_26CE2:
mov r15, rsp
mov r13, rax
loc_26CE8:
mov ecx, [rax-8]
test ecx, ecx
js short loc_26CFB
mov rdi, r15; this
call __ZNSs12_M_leak_hardEv; std::string::_M_leak_hard(void)
mov rax, [rsp+38h+var_38]
loc_26CFB:
add rax, [rax-18h]
cmp r13, rax
jz short loc_26C90
movsx edi, byte ptr [r13+0]
call _toupper
mov [r13+0], al
inc r13
mov rax, [rsp+38h+var_38]
jmp short loc_26CE8
loc_26D1B:
xor eax, eax
loc_26D1D:
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short loc_26D3F
mov rbx, rax
mov rdi, [rsp+0]
add rdi, 0FFFFFFFFFFFFFFE8h
lea rsi, [rsp+arg_7]
jmp short loc_26D4F
loc_26D3F:
mov rbx, rax
mov rdi, [rsp+0]
add rdi, 0FFFFFFFFFFFFFFE8h
lea rsi, [rsp+arg_5]
loc_26D4F:
call __ZNSs4_Rep10_M_disposeERKSaIcE; std::string::_Rep::_M_dispose(std::allocator<char> const&)
mov rdi, rbx
call __Unwind_Resume
|
long long LefDefParser::lefGetIntDefine(LefDefParser *this, char *a2, int *a3)
{
long long v3; // r14
long long v4; // r14
long long v6; // rax
_BYTE *i; // r13
long long v8; // [rsp+0h] [rbp-38h] BYREF
_BYTE v9[2]; // [rsp+Ch] [rbp-2Ch] BYREF
_BYTE v10[42]; // [rsp+Eh] [rbp-2Ah] BYREF
v3 = *(_QWORD *)LefDefParser::lefData + 5816LL;
std::string::string<std::allocator<char>>(&v8, (long long)this, (long long)v9);
if ( !*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 544LL) )
{
v6 = v8;
if ( *(int *)(v8 - 8) >= 0 )
{
std::string::_M_leak_hard((std::string *)&v8);
v6 = v8;
}
for ( i = (_BYTE *)v6; ; ++i )
{
if ( *(int *)(v6 - 8) >= 0 )
{
std::string::_M_leak_hard((std::string *)&v8);
v6 = v8;
}
if ( i == (_BYTE *)(*(_QWORD *)(v6 - 24) + v6) )
break;
*i = toupper((unsigned int)(char)*i);
v6 = v8;
}
}
v4 = std::_Rb_tree<std::string,std::pair<std::string const,int>,std::_Select1st<std::pair<std::string const,int>>,LefDefParser::lefCompareStrings,std::allocator<std::pair<std::string const,int>>>::find(
v3,
&v8);
std::string::_Rep::_M_dispose(v8 - 24, v10);
if ( v4 == *(_QWORD *)LefDefParser::lefData + 5824LL )
return 0LL;
*(_DWORD *)a2 = *(_DWORD *)(v4 + 40);
return 1LL;
}
|
lefGetIntDefine:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV RSI,RDI
LEA R12,[0x1775e0]
MOV R14D,0x16b8
ADD R14,qword ptr [R12]
MOV RDI,RSP
LEA RDX,[RSP + 0xc]
CALL 0x00126796
MOV RAX,qword ptr [R12]
CMP dword ptr [RAX + 0x220],0x0
JZ 0x00126ccb
LAB_00126c90:
MOV RSI,RSP
MOV RDI,R14
CALL 0x00126e88
MOV R14,RAX
MOV RDI,qword ptr [RSP]
ADD RDI,-0x18
LEA RSI,[RSP + 0xe]
CALL 0x00102130
MOV EAX,0x16c0
ADD RAX,qword ptr [R12]
CMP R14,RAX
JZ 0x00126d1b
MOV EAX,dword ptr [R14 + 0x28]
MOV dword ptr [RBX],EAX
MOV EAX,0x1
JMP 0x00126d1d
LAB_00126ccb:
MOV RAX,qword ptr [RSP]
MOV ECX,dword ptr [RAX + -0x8]
TEST ECX,ECX
JS 0x00126ce2
LAB_00126cd6:
MOV RDI,RSP
CALL 0x00102070
MOV RAX,qword ptr [RSP]
LAB_00126ce2:
MOV R15,RSP
MOV R13,RAX
LAB_00126ce8:
MOV ECX,dword ptr [RAX + -0x8]
TEST ECX,ECX
JS 0x00126cfb
LAB_00126cef:
MOV RDI,R15
CALL 0x00102070
LAB_00126cf7:
MOV RAX,qword ptr [RSP]
LAB_00126cfb:
ADD RAX,qword ptr [RAX + -0x18]
CMP R13,RAX
JZ 0x00126c90
MOVSX EDI,byte ptr [R13]
CALL 0x00102390
MOV byte ptr [R13],AL
INC R13
MOV RAX,qword ptr [RSP]
JMP 0x00126ce8
LAB_00126d1b:
XOR EAX,EAX
LAB_00126d1d:
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* LefDefParser::lefGetIntDefine(char const*, int*) */
bool LefDefParser::lefGetIntDefine(char *param_1,int *param_2)
{
int iVar1;
long lVar2;
char *pcVar3;
_Rb_tree<std::string,std::pair<std::string_const,int>,std::_Select1st<std::pair<std::string_const,int>>,LefDefParser::lefCompareStrings,std::allocator<std::pair<std::string_const,int>>>
*this;
bool bVar4;
char *local_38;
allocator local_2c [4];
this = (_Rb_tree<std::string,std::pair<std::string_const,int>,std::_Select1st<std::pair<std::string_const,int>>,LefDefParser::lefCompareStrings,std::allocator<std::pair<std::string_const,int>>>
*)(lefData + 0x16b8);
std::string::string<std::allocator<char>>((string *)&local_38,param_1,local_2c);
if (*(int *)(lefData + 0x220) == 0) {
pcVar3 = local_38;
if (-1 < *(int *)(local_38 + -8)) {
/* try { // try from 00126cd6 to 00126cdd has its CatchHandler @ 00126d2b */
std::string::_M_leak_hard();
pcVar3 = local_38;
}
while( true ) {
if (-1 < *(int *)(local_38 + -8)) {
/* try { // try from 00126cef to 00126cf6 has its CatchHandler @ 00126d3f */
std::string::_M_leak_hard();
}
if (pcVar3 == local_38 + *(long *)(local_38 + -0x18)) break;
iVar1 = toupper((int)*pcVar3);
*pcVar3 = (char)iVar1;
pcVar3 = pcVar3 + 1;
}
}
/* try { // try from 00126c90 to 00126c9a has its CatchHandler @ 00126d2d */
lVar2 = std::
_Rb_tree<std::string,std::pair<std::string_const,int>,std::_Select1st<std::pair<std::string_const,int>>,LefDefParser::lefCompareStrings,std::allocator<std::pair<std::string_const,int>>>
::find(this,(string *)&local_38);
std::string::_Rep::_M_dispose((allocator *)(local_38 + -0x18));
bVar4 = lVar2 != lefData + 0x16c0;
if (bVar4) {
*param_2 = *(int *)(lVar2 + 0x28);
}
return bVar4;
}
|
|
10,873 |
mysql_fetch_row_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_fetch_row_start(MYSQL_ROW *ret, MYSQL_RES *result)
{
MK_ASYNC_START_BODY(
mysql_fetch_row,
result->handle,
{
WIN_SET_NONBLOCKING(result->handle)
parms.result= result;
},
NULL,
r_ptr,
/*
If we already fetched all rows from server (eg. mysql_store_result()),
then result->handle will be NULL and we cannot suspend. But that is fine,
since in this case mysql_fetch_row cannot block anyway. Just return
directly.
*/
if (!result->handle)
{
*ret= mysql_fetch_row(result);
return 0;
})
}
|
O0
|
c
|
mysql_fetch_row_start:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x9ce3a
movq -0x18(%rbp), %rdi
callq 0x84670
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x9cf4e
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
leaq 0xf0(%rip), %rsi # 0x9cf60
leaq -0x30(%rbp), %rdx
callq 0xa3d80
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0x9cea8
movq -0x28(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x9cf4e
cmpl $0x0, -0x1c(%rbp)
jge 0x9cf38
jmp 0x9ceb4
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x2644a4(%rip), %rax # 0x301380
movq (%rax), %rsi
movl $0x5, %edx
callq 0x60180
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
addq $0x97, %rdi
leaq 0x264482(%rip), %rax # 0x301390
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x60180
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x9cf47
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
mysql_fetch_row_start:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp qword ptr [rax+78h], 0
jnz short loc_9CE3A
mov rdi, [rbp+var_18]
call mysql_fetch_row
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 0
jmp loc_9CF4E
loc_9CE3A:
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_28]
add rdi, 38h ; '8'
lea rsi, mysql_fetch_row_start_internal
lea rdx, [rbp+var_30]
call my_context_spawn
mov [rbp+var_1C], eax
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 0
cmp [rbp+var_1C], 0
jle short loc_9CEA8
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_9CF4E
loc_9CEA8:
cmp [rbp+var_1C], 0
jge loc_9CF38
jmp short $+2
loc_9CEB4:
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov dword ptr [rax+90h], 7D8h
mov rax, [rbp+var_18]
mov rdi, [rax+78h]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov byte ptr [rax+29Ch], 0
mov rax, [rbp+var_18]
mov rdi, [rax+78h]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax], 0
jmp short loc_9CF47
loc_9CF38:
mov rax, [rbp+var_28]
mov rcx, [rax+8]
mov rax, [rbp+var_10]
mov [rax], rcx
loc_9CF47:
mov [rbp+var_4], 0
loc_9CF4E:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long mysql_fetch_row_start(long long *a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-30h] BYREF
unsigned int *v4; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
long long v6; // [rsp+18h] [rbp-18h]
long long *v7; // [rsp+20h] [rbp-10h]
v7 = a1;
v6 = a2;
if ( *(_QWORD *)(a2 + 120) )
{
v4 = *(unsigned int **)(*(_QWORD *)(*(_QWORD *)(v6 + 120) + 1152LL) + 40LL);
v3 = v6;
*((_BYTE *)v4 + 20) = 1;
v5 = my_context_spawn(v4 + 14, mysql_fetch_row_start_internal, &v3);
*((_BYTE *)v4 + 21) = 0;
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
if ( v5 >= 0 )
{
*v7 = *((_QWORD *)v4 + 1);
}
else
{
*(_DWORD *)(*(_QWORD *)(v6 + 120) + 144LL) = 2008;
strncpy(*(_QWORD *)(v6 + 120) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(v6 + 120) + 668LL) = 0;
strncpy(*(_QWORD *)(v6 + 120) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(v6 + 120) + 662LL) = 0;
*v7 = 0LL;
}
return 0;
}
else
{
*((_BYTE *)v4 + 21) = 1;
return *v4;
}
}
else
{
*v7 = mysql_fetch_row(v6);
return 0;
}
}
|
mysql_fetch_row_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x78],0x0
JNZ 0x0019ce3a
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00184670
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019cf4e
LAB_0019ce3a:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x38
LEA RSI,[0x19cf60]
LEA RDX,[RBP + -0x30]
CALL 0x001a3d80
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x0019cea8
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0019cf4e
LAB_0019cea8:
CMP dword ptr [RBP + -0x1c],0x0
JGE 0x0019cf38
JMP 0x0019ceb4
LAB_0019ceb4:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x78]
ADD RDI,0x297
LEA RAX,[0x401380]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00160180
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV byte ptr [RAX + 0x29c],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x78]
ADD RDI,0x97
LEA RAX,[0x401390]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00160180
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],0x0
JMP 0x0019cf47
LAB_0019cf38:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
LAB_0019cf47:
MOV dword ptr [RBP + -0x4],0x0
LAB_0019cf4e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_fetch_row_start(int8 *param_1,long param_2)
{
int8 uVar1;
long local_38;
int4 *local_30;
int local_24;
long local_20;
int8 *local_18;
int4 local_c;
local_20 = param_2;
local_18 = param_1;
if (*(long *)(param_2 + 0x78) == 0) {
uVar1 = mysql_fetch_row(param_2);
*local_18 = uVar1;
local_c = 0;
}
else {
local_30 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x78) + 0x480) + 0x28);
*(int1 *)(local_30 + 5) = 1;
local_38 = param_2;
local_24 = my_context_spawn(local_30 + 0xe,mysql_fetch_row_start_internal,&local_38);
*(int1 *)((long)local_30 + 0x15) = 0;
*(int1 *)(local_30 + 5) = 0;
if (local_24 < 1) {
if (local_24 < 0) {
*(int4 *)(*(long *)(local_20 + 0x78) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(local_20 + 0x78) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(local_20 + 0x78) + 0x29c) = 0;
strncpy((char *)(*(long *)(local_20 + 0x78) + 0x97),PTR_s_Client_run_out_of_memory_004013d0,
0x1ff);
*(int1 *)(*(long *)(local_20 + 0x78) + 0x296) = 0;
*local_18 = 0;
}
else {
*local_18 = *(int8 *)(local_30 + 2);
}
local_c = 0;
}
else {
*(int1 *)((long)local_30 + 0x15) = 1;
local_c = *local_30;
}
}
return local_c;
}
|
|
10,874 |
google::protobuf::RepeatedField<bool>::at(int)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h
|
inline Element& RepeatedField<Element>::at(int index) {
GOOGLE_CHECK_GE(index, 0);
GOOGLE_CHECK_LT(index, current_size_);
return elements()[index];
}
|
O0
|
c
|
google::protobuf::RepeatedField<bool>::at(int):
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0xbc(%rsp), %eax
movb $0x0, 0x7f(%rsp)
cmpl $0x0, %eax
jl 0x180916
jmp 0x180969
leaq 0x263793(%rip), %rdx # 0x3e40b0
leaq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3, %esi
movl $0x29b, %ecx # imm = 0x29B
callq 0x19a670
movq 0x10(%rsp), %rdi
movb $0x1, 0x7f(%rsp)
leaq 0x25ffff(%rip), %rsi # 0x3e0949
callq 0x199f30
movq %rax, 0x18(%rsp)
jmp 0x180956
movq 0x18(%rsp), %rsi
leaq 0x6b(%rsp), %rdi
callq 0x19a0e0
jmp 0x180967
jmp 0x180969
testb $0x1, 0x7f(%rsp)
jne 0x180972
jmp 0x18097f
leaq 0x80(%rsp), %rdi
callq 0x19a6b0
movq 0x20(%rsp), %rcx
movl 0xbc(%rsp), %eax
movl (%rcx), %ecx
movb $0x0, 0x2f(%rsp)
cmpl %ecx, %eax
jge 0x180998
jmp 0x1809e6
leaq 0x263711(%rip), %rdx # 0x3e40b0
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x3, %esi
movl $0x29c, %ecx # imm = 0x29C
callq 0x19a670
movq (%rsp), %rdi
movb $0x1, 0x2f(%rsp)
leaq 0x25ffa1(%rip), %rsi # 0x3e0968
callq 0x199f30
movq %rax, 0x8(%rsp)
jmp 0x1809d3
movq 0x8(%rsp), %rsi
leaq 0x2e(%rsp), %rdi
callq 0x19a0e0
jmp 0x1809e4
jmp 0x1809e6
testb $0x1, 0x2f(%rsp)
jne 0x1809ef
jmp 0x1809f9
leaq 0x30(%rsp), %rdi
callq 0x19a6b0
movq 0x20(%rsp), %rdi
callq 0x180630
movslq 0xbc(%rsp), %rcx
addq %rcx, %rax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0x180a2d
jmp 0x180a3a
leaq 0x80(%rsp), %rdi
callq 0x19a6b0
jmp 0x180a5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x180a53
jmp 0x180a5d
leaq 0x30(%rsp), %rdi
callq 0x19a6b0
jmp 0x180a5f
movq 0x70(%rsp), %rdi
callq 0x90db0
nopl (%rax)
|
_ZN6google8protobuf13RepeatedFieldIbE2atEi:
sub rsp, 0C8h
mov [rsp+0C8h+var_8], rdi
mov [rsp+0C8h+var_C], esi
mov rax, [rsp+0C8h+var_8]
mov [rsp+0C8h+var_A8], rax
mov eax, [rsp+0C8h+var_C]
mov [rsp+0C8h+var_49], 0
cmp eax, 0
jl short loc_180916
jmp short loc_180969
loc_180916:
lea rdx, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0C8h+var_48]
mov [rsp+0C8h+var_B8], rdi
mov esi, 3
mov ecx, 29Bh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0C8h+var_B8]
mov [rsp+0C8h+var_49], 1
lea rsi, aCheckFailedInd; "CHECK failed: (index) >= (0): "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0C8h+var_B0], rax
jmp short $+2
loc_180956:
mov rsi, [rsp+0C8h+var_B0]
lea rdi, [rsp+0C8h+var_5D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_180967:
jmp short $+2
loc_180969:
test [rsp+0C8h+var_49], 1
jnz short loc_180972
jmp short loc_18097F
loc_180972:
lea rdi, [rsp+0C8h+var_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_18097F:
mov rcx, [rsp+0C8h+var_A8]
mov eax, [rsp+0C8h+var_C]
mov ecx, [rcx]
mov [rsp+0C8h+var_99], 0
cmp eax, ecx
jge short loc_180998
jmp short loc_1809E6
loc_180998:
lea rdx, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0C8h+var_98]
mov [rsp+0C8h+var_C8], rdi
mov esi, 3
mov ecx, 29Ch
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0C8h+var_C8]
mov [rsp+0C8h+var_99], 1
lea rsi, aCheckFailedInd_0; "CHECK failed: (index) < (current_size_)"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0C8h+var_C0], rax
jmp short $+2
loc_1809D3:
mov rsi, [rsp+0C8h+var_C0]
lea rdi, [rsp+0C8h+var_9A]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1809E4:
jmp short $+2
loc_1809E6:
test [rsp+0C8h+var_99], 1
jnz short loc_1809EF
jmp short loc_1809F9
loc_1809EF:
lea rdi, [rsp+0C8h+var_98]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1809F9:
mov rdi, [rsp+0C8h+var_A8]
call _ZNK6google8protobuf13RepeatedFieldIbE8elementsEv; google::protobuf::RepeatedField<bool>::elements(void)
movsxd rcx, [rsp+0C8h+var_C]
add rax, rcx
add rsp, 0C8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_68], rcx
mov [rsp+arg_64], eax
test [rsp+arg_77], 1
jnz short loc_180A2D
jmp short loc_180A3A
loc_180A2D:
lea rdi, [rsp+arg_78]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_180A3A:
jmp short loc_180A5F
mov rcx, rax
mov eax, edx
mov [rsp+arg_68], rcx
mov [rsp+arg_64], eax
test [rsp+arg_27], 1
jnz short loc_180A53
jmp short loc_180A5D
loc_180A53:
lea rdi, [rsp+arg_28]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_180A5D:
jmp short $+2
loc_180A5F:
mov rdi, [rsp+arg_68]
call __Unwind_Resume
|
long long google::protobuf::RepeatedField<bool>::at(_DWORD *a1, int a2)
{
int v2; // ecx
long long v3; // rax
long long v5; // [rsp+8h] [rbp-C0h]
long long v6; // [rsp+18h] [rbp-B0h]
char v7; // [rsp+2Eh] [rbp-9Ah] BYREF
char v8; // [rsp+2Fh] [rbp-99h]
_BYTE v9[59]; // [rsp+30h] [rbp-98h] BYREF
char v10[20]; // [rsp+6Bh] [rbp-5Dh] BYREF
char v11; // [rsp+7Fh] [rbp-49h]
_BYTE v12[60]; // [rsp+80h] [rbp-48h] BYREF
int v13; // [rsp+BCh] [rbp-Ch]
_DWORD *v14; // [rsp+C0h] [rbp-8h]
v14 = a1;
v13 = a2;
v11 = 0;
if ( a2 < 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
v12,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h",
667LL);
v11 = 1;
v6 = google::protobuf::internal::LogMessage::operator<<(v12, "CHECK failed: (index) >= (0): ");
google::protobuf::internal::LogFinisher::operator=(v10, v6);
}
if ( (v11 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v12);
v2 = *a1;
v8 = 0;
if ( v13 >= v2 )
{
google::protobuf::internal::LogMessage::LogMessage(
v9,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h",
668LL);
v8 = 1;
v5 = google::protobuf::internal::LogMessage::operator<<(v9, "CHECK failed: (index) < (current_size_): ");
google::protobuf::internal::LogFinisher::operator=(&v7, v5);
}
if ( (v8 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v9);
v3 = google::protobuf::RepeatedField<bool>::elements((long long)a1);
return v13 + v3;
}
| |||
10,875 |
google::protobuf::RepeatedField<bool>::at(int)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h
|
inline Element& RepeatedField<Element>::at(int index) {
GOOGLE_CHECK_GE(index, 0);
GOOGLE_CHECK_LT(index, current_size_);
return elements()[index];
}
|
O3
|
c
|
google::protobuf::RepeatedField<bool>::at(int):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
jns 0x81a85
leaq 0xe4b58(%rip), %rdx # 0x1665a0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x29b, %ecx # imm = 0x29B
callq 0x857c2
leaq 0xe4ba4(%rip), %rsi # 0x16660a
movq %r14, %rdi
callq 0x852c0
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x8539a
leaq 0x8(%rsp), %rdi
callq 0x857e0
cmpl %ebp, (%rbx)
jg 0x81acd
leaq 0xe4b10(%rip), %rdx # 0x1665a0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x29c, %ecx # imm = 0x29C
callq 0x857c2
leaq 0xe4b7b(%rip), %rsi # 0x166629
movq %r14, %rdi
callq 0x852c0
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x8539a
leaq 0x8(%rsp), %rdi
callq 0x857e0
movslq %ebp, %rax
shlq $0x3, %rax
addq 0x8(%rbx), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x81ae7
jmp 0x81ae7
jmp 0x81ae7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x857e0
movq %rbx, %rdi
callq 0x2e220
|
_ZN6google8protobuf13RepeatedFieldImE2atEi:
push rbp
push r14
push rbx
sub rsp, 40h
mov ebp, esi
mov rbx, rdi
test esi, esi
jns short loc_81A85
lea rdx, aWorkspaceLlm4b_15; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 29Bh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedInd; "CHECK failed: (index) >= (0): "
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_81A85:
cmp [rbx], ebp
jg short loc_81ACD
lea rdx, aWorkspaceLlm4b_15; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 29Ch
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedInd_0; "CHECK failed: (index) < (current_size_)"...
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_81ACD:
movsxd rax, ebp
shl rax, 3
add rax, [rbx+8]
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
jmp short loc_81AE7
jmp short loc_81AE7
jmp short $+2
loc_81AE7:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
|
long long google::protobuf::RepeatedField<unsigned long>::at(long long a1, int a2)
{
long long v2; // rax
long long v3; // rax
char v5; // [rsp+7h] [rbp-51h] BYREF
_BYTE v6[80]; // [rsp+8h] [rbp-50h] BYREF
if ( a2 < 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
v6,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h",
667LL);
v2 = google::protobuf::internal::LogMessage::operator<<(v6, "CHECK failed: (index) >= (0): ");
google::protobuf::internal::LogFinisher::operator=(&v5, v2);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v6);
}
if ( *(_DWORD *)a1 <= a2 )
{
google::protobuf::internal::LogMessage::LogMessage(
v6,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h",
668LL);
v3 = google::protobuf::internal::LogMessage::operator<<(v6, "CHECK failed: (index) < (current_size_): ");
google::protobuf::internal::LogFinisher::operator=(&v5, v3);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v6);
}
return *(_QWORD *)(a1 + 8) + 8LL * a2;
}
|
at:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV EBP,ESI
MOV RBX,RDI
TEST ESI,ESI
JNS 0x00181a85
LEA RDX,[0x2665a0]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x29b
CALL 0x001857c2
LAB_00181a5f:
LEA RSI,[0x26660a]
MOV RDI,R14
CALL 0x001852c0
LAB_00181a6e:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x0018539a
LAB_00181a7b:
LEA RDI,[RSP + 0x8]
CALL 0x001857e0
LAB_00181a85:
CMP dword ptr [RBX],EBP
JG 0x00181acd
LEA RDX,[0x2665a0]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x29c
CALL 0x001857c2
LAB_00181aa7:
LEA RSI,[0x266629]
MOV RDI,R14
CALL 0x001852c0
LAB_00181ab6:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x0018539a
LAB_00181ac3:
LEA RDI,[RSP + 0x8]
CALL 0x001857e0
LAB_00181acd:
MOVSXD RAX,EBP
SHL RAX,0x3
ADD RAX,qword ptr [RBX + 0x8]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
/* google::protobuf::RepeatedField<unsigned long>::at(int) */
long __thiscall
google::protobuf::RepeatedField<unsigned_long>::at(RepeatedField<unsigned_long> *this,int param_1)
{
LogMessage *pLVar1;
LogFinisher local_51;
LogMessage local_50 [56];
if (param_1 < 0) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h"
,0x29b);
/* try { // try from 00181a5f to 00181a6d has its CatchHandler @ 00181ae3 */
pLVar1 = (LogMessage *)
internal::LogMessage::operator<<(local_50,"CHECK failed: (index) >= (0): ");
/* try { // try from 00181a6e to 00181a7a has its CatchHandler @ 00181ae1 */
internal::LogFinisher::operator=(&local_51,pLVar1);
internal::LogMessage::~LogMessage(local_50);
}
if (*(int *)this <= param_1) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h"
,0x29c);
/* try { // try from 00181aa7 to 00181ab5 has its CatchHandler @ 00181ae7 */
pLVar1 = (LogMessage *)
internal::LogMessage::operator<<(local_50,"CHECK failed: (index) < (current_size_): ");
/* try { // try from 00181ab6 to 00181ac2 has its CatchHandler @ 00181ae5 */
internal::LogFinisher::operator=(&local_51,pLVar1);
internal::LogMessage::~LogMessage(local_50);
}
return (long)param_1 * 8 + *(long *)(this + 8);
}
|
|
10,876 |
gindex_indexOf
|
corpus-core[P]colibri-stateless/src/util/ssz_merkle.c
|
static int gindex_indexOf(buffer_t* index_list, gindex_t index) {
int len = index_list->data.len / sizeof(gindex_t);
gindex_t* index_list_array = (gindex_t*) index_list->data.data;
for (int i = 0; i < len; i++) {
if (index_list_array[i] == index) return i;
}
return -1;
}
|
O0
|
c
|
gindex_indexOf:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrq $0x3, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xa1c8b
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0xa1c7e
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa1c92
jmp 0xa1c80
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa1c5c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
gindex_indexOf:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov eax, [rax]
shr rax, 3
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_28], rax
mov [rbp+var_2C], 0
loc_A1C5C:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_1C]
jge short loc_A1C8B
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_2C]
mov rax, [rax+rcx*8]
cmp rax, [rbp+var_18]
jnz short loc_A1C7E
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
jmp short loc_A1C92
loc_A1C7E:
jmp short $+2
loc_A1C80:
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_A1C5C
loc_A1C8B:
mov [rbp+var_4], 0FFFFFFFFh
loc_A1C92:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long gindex_indexOf(long long a1, long long a2)
{
unsigned int i; // [rsp+0h] [rbp-2Ch]
for ( i = 0; (signed int)i < *(_DWORD *)a1 >> 3; ++i )
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * (int)i) == a2 )
return i;
}
return (unsigned int)-1;
}
|
gindex_indexOf:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
SHR RAX,0x3
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV dword ptr [RBP + -0x2c],0x0
LAB_001a1c5c:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x001a1c8b
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RAX + RCX*0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x001a1c7e
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001a1c92
LAB_001a1c7e:
JMP 0x001a1c80
LAB_001a1c80:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001a1c5c
LAB_001a1c8b:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_001a1c92:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int gindex_indexOf(uint *param_1,long param_2)
{
int local_34;
local_34 = 0;
while( true ) {
if ((int)(*param_1 >> 3) <= local_34) {
return -1;
}
if (*(long *)(*(long *)(param_1 + 2) + (long)local_34 * 8) == param_2) break;
local_34 = local_34 + 1;
}
return local_34;
}
|
|
10,877 |
LefDefParser::lefwLayerRoutingStartSpacingtableTwoWidths()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwLayerRoutingStartSpacingtableTwoWidths()
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTING_START &&
lefwState != LEFW_LAYERROUTING)
return LEFW_BAD_ORDER;
if (!lefwIsRoutingReqData) {
return LEFW_BAD_ORDER;
}
if (lefwWriteEncrypt) {
encPrint(lefwFile, (char*) " SPACINGTABLE\n");
encPrint(lefwFile, (char*) " TWOWIDTHS");
} else {
fprintf(lefwFile, " SPACINGTABLE\n");
fprintf(lefwFile, " TWOWIDTHS");
}
lefwState = LEFW_LAYERROUTINGWIDTH;
lefwLines++;
return LEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::lefwLayerRoutingStartSpacingtableTwoWidths():
pushq %rax
leaq 0x1fab8(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x1335b
movl $0x1, 0x4(%rsp)
jmp 0x1342e
leaq 0x1fcee(%rip), %rax # 0x33050
cmpl $0x7, (%rax)
je 0x13380
leaq 0x1fce2(%rip), %rax # 0x33050
cmpl $0x1f, (%rax)
je 0x13380
movl $0x2, 0x4(%rsp)
jmp 0x1342e
leaq 0x1fd4d(%rip), %rax # 0x330d4
cmpl $0x0, (%rax)
jne 0x13399
movl $0x2, 0x4(%rsp)
jmp 0x1342e
cmpl $0x0, 0x1fd4c(%rip) # 0x330ec
je 0x133d4
leaq 0x1fa57(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x1758b(%rip), %rsi # 0x2a93e
movb $0x0, %al
callq 0x289b0
leaq 0x1fa3f(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x1761f(%rip), %rsi # 0x2a9ea
movb $0x0, %al
callq 0x289b0
jmp 0x13404
leaq 0x1fa25(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x17559(%rip), %rsi # 0x2a93e
movb $0x0, %al
callq 0x1100
leaq 0x1fa0d(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x175ed(%rip), %rsi # 0x2a9ea
movb $0x0, %al
callq 0x1100
leaq 0x1fc45(%rip), %rax # 0x33050
movl $0x20, (%rax)
leaq 0x1fc34(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x1fc28(%rip), %rax # 0x3304c
movl %ecx, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
|
_ZN12LefDefParser42lefwLayerRoutingStartSpacingtableTwoWidthsEv:
push rax
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_1335B
mov [rsp+8+var_4], 1
jmp loc_1342E
loc_1335B:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 7
jz short loc_13380
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 1Fh
jz short loc_13380
mov [rsp+8+var_4], 2
jmp loc_1342E
loc_13380:
lea rax, _ZN12LefDefParser20lefwIsRoutingReqDataE; LefDefParser::lefwIsRoutingReqData
cmp dword ptr [rax], 0
jnz short loc_13399
mov [rsp+8+var_4], 2
jmp loc_1342E
loc_13399:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_133D4
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aSpacingtable; " SPACINGTABLE\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aTwowidths; " TWOWIDTHS"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_13404
loc_133D4:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aSpacingtable; " SPACINGTABLE\n"
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aTwowidths; " TWOWIDTHS"
mov al, 0
call _fprintf
loc_13404:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 20h ; ' '
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov [rsp+8+var_4], 0
loc_1342E:
mov eax, [rsp+8+var_4]
pop rcx
retn
|
long long LefDefParser::lefwLayerRoutingStartSpacingtableTwoWidths(
LefDefParser *this,
long long a2,
int a3,
int a4,
int a5,
int a6)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwState == 7 || LefDefParser::lefwState == 31 )
{
if ( LefDefParser::lefwIsRoutingReqData )
{
if ( LefDefParser::lefwWriteEncrypt )
{
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" SPACINGTABLE\n", a3, a4, a5, a6);
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" TWOWIDTHS", v6, v7, v8, v9);
}
else
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " SPACINGTABLE\n");
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " TWOWIDTHS");
}
LefDefParser::lefwState = 32;
++LefDefParser::lefwLines;
return 0;
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
lefwLayerRoutingStartSpacingtableTwoWidths:
PUSH RAX
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x0011335b
MOV dword ptr [RSP + 0x4],0x1
JMP 0x0011342e
LAB_0011335b:
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x7
JZ 0x00113380
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x1f
JZ 0x00113380
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0011342e
LAB_00113380:
LEA RAX,[0x1330d4]
CMP dword ptr [RAX],0x0
JNZ 0x00113399
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0011342e
LAB_00113399:
CMP dword ptr [0x001330ec],0x0
JZ 0x001133d4
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12a93e]
MOV AL,0x0
CALL 0x001289b0
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12a9ea]
MOV AL,0x0
CALL 0x001289b0
JMP 0x00113404
LAB_001133d4:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12a93e]
MOV AL,0x0
CALL 0x00101100
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12a9ea]
MOV AL,0x0
CALL 0x00101100
LAB_00113404:
LEA RAX,[0x133050]
MOV dword ptr [RAX],0x20
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x4],0x0
LAB_0011342e:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::lefwLayerRoutingStartSpacingtableTwoWidths() */
int4 LefDefParser::lefwLayerRoutingStartSpacingtableTwoWidths(void)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if ((lefwState == 7) || (lefwState == 0x1f)) {
if (lefwIsRoutingReqData == 0) {
local_4 = 2;
}
else {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," SPACINGTABLE\n");
fprintf(lefwFile," TWOWIDTHS");
}
else {
encPrint(lefwFile," SPACINGTABLE\n");
encPrint(lefwFile," TWOWIDTHS");
}
lefwState = 0x20;
lefwLines = lefwLines + 1;
local_4 = 0;
}
}
else {
local_4 = 2;
}
return local_4;
}
|
|
10,878 |
common_sampler_accept(common_sampler*, int, bool)
|
monkey531[P]llama/common/sampling.cpp
|
void common_sampler_accept(struct common_sampler * gsmpl, llama_token token, bool accept_grammar) {
if (accept_grammar) {
llama_sampler_accept(gsmpl->grmr, token);
}
llama_sampler_accept(gsmpl->chain, token);
gsmpl->prev.push_back(token);
}
|
O1
|
cpp
|
common_sampler_accept(common_sampler*, int, bool):
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %edx, %edx
je 0xd2e45
movq 0x138(%rbx), %rdi
movl %ebp, %esi
callq 0x1b500
movq 0x140(%rbx), %rdi
movl %ebp, %esi
callq 0x1b500
movq 0x148(%rbx), %rcx
movq 0x150(%rbx), %rax
cmpq %rcx, %rax
jne 0xd2e7e
movq 0x158(%rbx), %rax
incq %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x158(%rbx)
jmp 0xd2e88
incq %rax
movq %rax, 0x150(%rbx)
movq 0x160(%rbx), %rax
movq 0x168(%rbx), %rdx
movl %ebp, (%rdx,%rax,4)
incq %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x160(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
_Z21common_sampler_acceptP14common_samplerib:
push rbp
push rbx
push rax
mov ebp, esi
mov rbx, rdi
test edx, edx
jz short loc_D2E45
mov rdi, [rbx+138h]
mov esi, ebp
call _llama_sampler_accept
loc_D2E45:
mov rdi, [rbx+140h]
mov esi, ebp
call _llama_sampler_accept
mov rcx, [rbx+148h]
mov rax, [rbx+150h]
cmp rax, rcx
jnz short loc_D2E7E
mov rax, [rbx+158h]
inc rax
xor edx, edx
div rcx
mov [rbx+158h], rdx
jmp short loc_D2E88
loc_D2E7E:
inc rax
mov [rbx+150h], rax
loc_D2E88:
mov rax, [rbx+160h]
mov rdx, [rbx+168h]
mov [rdx+rax*4], ebp
inc rax
xor edx, edx
div rcx
mov [rbx+160h], rdx
add rsp, 8
pop rbx
pop rbp
retn
|
unsigned long long common_sampler_accept(_QWORD *a1, unsigned int a2, int a3)
{
unsigned long long v3; // rcx
long long v4; // rax
long long v5; // rax
unsigned long long result; // rax
unsigned long long v7; // rtt
if ( a3 )
llama_sampler_accept(a1[39], a2);
llama_sampler_accept(a1[40], a2);
v3 = a1[41];
v4 = a1[42];
if ( v4 == v3 )
a1[43] = (a1[43] + 1LL) % v3;
else
a1[42] = v4 + 1;
v5 = a1[44];
*(_DWORD *)(a1[45] + 4 * v5) = a2;
v7 = v5 + 1;
result = (v5 + 1) / v3;
a1[44] = v7 % v3;
return result;
}
|
common_sampler_accept:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
TEST EDX,EDX
JZ 0x001d2e45
MOV RDI,qword ptr [RBX + 0x138]
MOV ESI,EBP
CALL 0x0011b500
LAB_001d2e45:
MOV RDI,qword ptr [RBX + 0x140]
MOV ESI,EBP
CALL 0x0011b500
MOV RCX,qword ptr [RBX + 0x148]
MOV RAX,qword ptr [RBX + 0x150]
CMP RAX,RCX
JNZ 0x001d2e7e
MOV RAX,qword ptr [RBX + 0x158]
INC RAX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x158],RDX
JMP 0x001d2e88
LAB_001d2e7e:
INC RAX
MOV qword ptr [RBX + 0x150],RAX
LAB_001d2e88:
MOV RAX,qword ptr [RBX + 0x160]
MOV RDX,qword ptr [RBX + 0x168]
MOV dword ptr [RDX + RAX*0x4],EBP
INC RAX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x160],RDX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* common_sampler_accept(common_sampler*, int, bool) */
ulong common_sampler_accept(common_sampler *param_1,int param_2,bool param_3)
{
ulong uVar1;
long lVar2;
ulong uVar3;
int7 in_register_00000011;
if ((int)CONCAT71(in_register_00000011,param_3) != 0) {
llama_sampler_accept(*(int8 *)(param_1 + 0x138),param_2);
}
llama_sampler_accept(*(int8 *)(param_1 + 0x140),param_2);
uVar1 = *(ulong *)(param_1 + 0x148);
if (*(ulong *)(param_1 + 0x150) == uVar1) {
*(ulong *)(param_1 + 0x158) = (*(long *)(param_1 + 0x158) + 1U) % uVar1;
}
else {
*(ulong *)(param_1 + 0x150) = *(ulong *)(param_1 + 0x150) + 1;
}
lVar2 = *(long *)(param_1 + 0x160);
*(int *)(*(long *)(param_1 + 0x168) + lVar2 * 4) = param_2;
uVar3 = lVar2 + 1;
*(ulong *)(param_1 + 0x160) = uVar3 % uVar1;
return uVar3 / uVar1;
}
|
|
10,879 |
common_sampler_accept(common_sampler*, int, bool)
|
monkey531[P]llama/common/sampling.cpp
|
void common_sampler_accept(struct common_sampler * gsmpl, llama_token token, bool accept_grammar) {
if (accept_grammar) {
llama_sampler_accept(gsmpl->grmr, token);
}
llama_sampler_accept(gsmpl->chain, token);
gsmpl->prev.push_back(token);
}
|
O3
|
cpp
|
common_sampler_accept(common_sampler*, int, bool):
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %edx, %edx
je 0xccffd
movq 0x138(%rbx), %rdi
movl %ebp, %esi
callq 0x1a4f0
movq 0x140(%rbx), %rdi
movl %ebp, %esi
callq 0x1a4f0
movq 0x148(%rbx), %rcx
movq 0x150(%rbx), %rsi
cmpq %rcx, %rsi
jne 0xcd036
movq 0x158(%rbx), %rax
incq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, 0x158(%rbx)
jmp 0xcd040
incq %rsi
movq %rsi, 0x150(%rbx)
movq 0x160(%rbx), %rax
movq 0x168(%rbx), %rdx
movl %ebp, (%rdx,%rax,4)
incq %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x160(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
_Z21common_sampler_acceptP14common_samplerib:
push rbp
push rbx
push rax
mov ebp, esi
mov rbx, rdi
test edx, edx
jz short loc_CCFFD
mov rdi, [rbx+138h]
mov esi, ebp
call _llama_sampler_accept
loc_CCFFD:
mov rdi, [rbx+140h]
mov esi, ebp
call _llama_sampler_accept
mov rcx, [rbx+148h]
mov rsi, [rbx+150h]
cmp rsi, rcx
jnz short loc_CD036
mov rax, [rbx+158h]
inc rax
xor edx, edx
div rsi
mov [rbx+158h], rdx
jmp short loc_CD040
loc_CD036:
inc rsi
mov [rbx+150h], rsi
loc_CD040:
mov rax, [rbx+160h]
mov rdx, [rbx+168h]
mov [rdx+rax*4], ebp
inc rax
xor edx, edx
div rcx
mov [rbx+160h], rdx
add rsp, 8
pop rbx
pop rbp
retn
|
unsigned long long common_sampler_accept(_QWORD *a1, unsigned int a2, int a3)
{
unsigned long long v4; // rcx
unsigned long long v5; // rsi
long long v6; // rax
unsigned long long result; // rax
unsigned long long v8; // rtt
if ( a3 )
llama_sampler_accept(a1[39], a2);
llama_sampler_accept(a1[40], a2);
v4 = a1[41];
v5 = a1[42];
if ( v5 == v4 )
a1[43] = (a1[43] + 1LL) % v5;
else
a1[42] = v5 + 1;
v6 = a1[44];
*(_DWORD *)(a1[45] + 4 * v6) = a2;
v8 = v6 + 1;
result = (v6 + 1) / v4;
a1[44] = v8 % v4;
return result;
}
| |||
10,880 |
dequantize_row_iq4_xs
|
llama.cpp/ggml/src/ggml-quants.c
|
void dequantize_row_iq4_xs(const block_iq4_xs * GGML_RESTRICT x, float * GGML_RESTRICT y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
for (int i = 0; i < nb; i++) {
const uint8_t * qs = x[i].qs;
const float d = GGML_FP16_TO_FP32(x[i].d);
for (int ib = 0; ib < QK_K/32; ++ib) {
const int ls = ((x[i].scales_l[ib/2] >> 4*(ib%2)) & 0xf) | (((x[i].scales_h >> 2*ib) & 3) << 4);
const float dl = d * (ls - 32);
for (int j = 0; j < 16; ++j) {
y[j+ 0] = dl * kvalues_iq4nl[qs[j] & 0xf];
y[j+16] = dl * kvalues_iq4nl[qs[j] >> 4];
}
y += 32;
qs += 16;
}
}
}
|
O3
|
c
|
dequantize_row_iq4_xs:
leaq 0xff(%rdx), %rax
testq %rdx, %rdx
cmovnsq %rdx, %rax
cmpq $0x100, %rdx # imm = 0x100
jl 0x331c0
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
sarq $0x8, %rax
xorl %edx, %edx
movq 0x36ec9(%rip), %r8 # 0x69fa8
leaq 0x1b97a(%rip), %r9 # 0x4ea60
movq %rdx, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rdx,8), %rcx
leaq (%rdi,%rcx), %r10
leaq (%rdi,%rcx), %r11
addq $0x8, %r11
movzwl -0x8(%r11), %ecx
movss (%r8,%rcx,4), %xmm0
movzwl -0x6(%r11), %ebx
xorl %r14d, %r14d
movl %r14d, %ecx
shrl %ecx
movzbl 0x4(%r10,%rcx), %r15d
leal (,%r14,4), %ecx
andb $0x4, %cl
shrl %cl, %r15d
leal (%r14,%r14), %ecx
movl %ebx, %r12d
shrl %cl, %r12d
andl $0xf, %r15d
shll $0x4, %r12d
andl $0x30, %r12d
leal (%r12,%r15), %ecx
addl $-0x20, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
mulss %xmm0, %xmm1
xorl %ecx, %ecx
movzbl (%r11,%rcx), %r15d
movl %r15d, %r12d
andl $0xf, %r12d
movsbl (%r12,%r9), %ebp
xorps %xmm2, %xmm2
cvtsi2ss %ebp, %xmm2
mulss %xmm1, %xmm2
movss %xmm2, (%rsi,%rcx,4)
shrl $0x4, %r15d
movsbl (%r15,%r9), %ebp
xorps %xmm2, %xmm2
cvtsi2ss %ebp, %xmm2
mulss %xmm1, %xmm2
movss %xmm2, 0x40(%rsi,%rcx,4)
incq %rcx
cmpq $0x10, %rcx
jne 0x33153
subq $-0x80, %rsi
addq $0x10, %r11
incl %r14d
cmpl $0x8, %r14d
jne 0x33110
incq %rdx
cmpq %rax, %rdx
jne 0x330e6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
dequantize_row_iq4_xs:
lea rax, [rdx+0FFh]
test rdx, rdx
cmovns rax, rdx
cmp rdx, 100h
jl locret_331C0
push rbp
push r15
push r14
push r12
push rbx
sar rax, 8
xor edx, edx
mov r8, cs:ggml_table_f32_f16_ptr
lea r9, kvalues_iq4nl
loc_330E6:
mov rcx, rdx
shl rcx, 7
lea rcx, [rcx+rdx*8]
lea r10, [rdi+rcx]
lea r11, [rdi+rcx]
add r11, 8
movzx ecx, word ptr [r11-8]
movss xmm0, dword ptr [r8+rcx*4]
movzx ebx, word ptr [r11-6]
xor r14d, r14d
loc_33110:
mov ecx, r14d
shr ecx, 1
movzx r15d, byte ptr [r10+rcx+4]
lea ecx, ds:0[r14*4]
and cl, 4
shr r15d, cl
lea ecx, [r14+r14]
mov r12d, ebx
shr r12d, cl
and r15d, 0Fh
shl r12d, 4
and r12d, 30h
lea ecx, [r12+r15]
add ecx, 0FFFFFFE0h
xorps xmm1, xmm1
cvtsi2ss xmm1, ecx
mulss xmm1, xmm0
xor ecx, ecx
loc_33153:
movzx r15d, byte ptr [r11+rcx]
mov r12d, r15d
and r12d, 0Fh
movsx ebp, byte ptr [r12+r9]
xorps xmm2, xmm2
cvtsi2ss xmm2, ebp
mulss xmm2, xmm1
movss dword ptr [rsi+rcx*4], xmm2
shr r15d, 4
movsx ebp, byte ptr [r15+r9]
xorps xmm2, xmm2
cvtsi2ss xmm2, ebp
mulss xmm2, xmm1
movss dword ptr [rsi+rcx*4+40h], xmm2
inc rcx
cmp rcx, 10h
jnz short loc_33153
sub rsi, 0FFFFFFFFFFFFFF80h
add r11, 10h
inc r14d
cmp r14d, 8
jnz loc_33110
inc rdx
cmp rdx, rax
jnz loc_330E6
pop rbx
pop r12
pop r14
pop r15
pop rbp
locret_331C0:
retn
|
long long dequantize_row_iq4_xs(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rdx
long long v5; // r11
float v6; // xmm0_4
unsigned int v7; // ebx
unsigned int i; // r14d
float v9; // xmm1_4
long long j; // rcx
unsigned int v11; // r15d
result = a3 + 255;
if ( a3 >= 0 )
result = a3;
if ( a3 >= 256 )
{
result >>= 8;
v4 = 0LL;
do
{
v5 = a1 + 136 * v4 + 8;
v6 = ggml_table_f32_f16[*(unsigned __int16 *)(a1 + 136 * v4)];
v7 = *(unsigned __int16 *)(a1 + 136 * v4 + 2);
for ( i = 0; i != 8; ++i )
{
v9 = (float)(((16 * (unsigned __int8)(v7 >> (2 * i))) & 0x30)
+ ((*(unsigned __int8 *)(a1 + 136 * v4 + (i >> 1) + 4) >> ((4 * i) & 4)) & 0xF)
- 32)
* v6;
for ( j = 0LL; j != 16; ++j )
{
v11 = *(unsigned __int8 *)(v5 + j);
*(float *)(a2 + 4 * j) = (float)kvalues_iq4nl[*(_BYTE *)(v5 + j) & 0xF] * v9;
*(float *)(a2 + 4 * j + 64) = (float)kvalues_iq4nl[v11 >> 4] * v9;
}
a2 += 128LL;
v5 += 16LL;
}
++v4;
}
while ( v4 != result );
}
return result;
}
|
dequantize_row_iq4_xs:
LEA RAX,[RDX + 0xff]
TEST RDX,RDX
CMOVNS RAX,RDX
CMP RDX,0x100
JL 0x001331c0
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SAR RAX,0x8
XOR EDX,EDX
MOV R8,qword ptr [0x00169fa8]
LEA R9,[0x14ea60]
LAB_001330e6:
MOV RCX,RDX
SHL RCX,0x7
LEA RCX,[RCX + RDX*0x8]
LEA R10,[RDI + RCX*0x1]
LEA R11,[RDI + RCX*0x1]
ADD R11,0x8
MOVZX ECX,word ptr [R11 + -0x8]
MOVSS XMM0,dword ptr [R8 + RCX*0x4]
MOVZX EBX,word ptr [R11 + -0x6]
XOR R14D,R14D
LAB_00133110:
MOV ECX,R14D
SHR ECX,0x1
MOVZX R15D,byte ptr [R10 + RCX*0x1 + 0x4]
LEA ECX,[R14*0x4]
AND CL,0x4
SHR R15D,CL
LEA ECX,[R14 + R14*0x1]
MOV R12D,EBX
SHR R12D,CL
AND R15D,0xf
SHL R12D,0x4
AND R12D,0x30
LEA ECX,[R12 + R15*0x1]
ADD ECX,-0x20
XORPS XMM1,XMM1
CVTSI2SS XMM1,ECX
MULSS XMM1,XMM0
XOR ECX,ECX
LAB_00133153:
MOVZX R15D,byte ptr [R11 + RCX*0x1]
MOV R12D,R15D
AND R12D,0xf
MOVSX EBP,byte ptr [R12 + R9*0x1]
XORPS XMM2,XMM2
CVTSI2SS XMM2,EBP
MULSS XMM2,XMM1
MOVSS dword ptr [RSI + RCX*0x4],XMM2
SHR R15D,0x4
MOVSX EBP,byte ptr [R15 + R9*0x1]
XORPS XMM2,XMM2
CVTSI2SS XMM2,EBP
MULSS XMM2,XMM1
MOVSS dword ptr [RSI + RCX*0x4 + 0x40],XMM2
INC RCX
CMP RCX,0x10
JNZ 0x00133153
SUB RSI,-0x80
ADD R11,0x10
INC R14D
CMP R14D,0x8
JNZ 0x00133110
INC RDX
CMP RDX,RAX
JNZ 0x001330e6
POP RBX
POP R12
POP R14
POP R15
POP RBP
LAB_001331c0:
RET
|
void dequantize_row_iq4_xs(long param_1,long param_2,long param_3)
{
ushort *puVar1;
float fVar2;
byte bVar3;
ushort uVar4;
int *puVar5;
long lVar6;
long lVar7;
long lVar8;
ushort *puVar9;
uint uVar10;
ulong uVar11;
float fVar12;
puVar5 = PTR_ggml_table_f32_f16_00169fa8;
lVar6 = param_3 + 0xff;
if (-1 < param_3) {
lVar6 = param_3;
}
if (0xff < param_3) {
lVar8 = 0;
do {
puVar1 = (ushort *)(param_1 + lVar8 * 0x88);
puVar9 = puVar1 + 4;
fVar2 = *(float *)(puVar5 + (ulong)*puVar1 * 4);
uVar4 = puVar1[1];
uVar11 = 0;
do {
fVar12 = (float)(int)((uVar4 >> ((char)uVar11 * '\x02' & 0x1fU) & 3) * 0x10 +
(*(byte *)(param_1 + lVar8 * 0x88 + 4 + (uVar11 >> 1)) >>
((char)uVar11 * '\x04' & 4U) & 0xf) + -0x20) * fVar2;
lVar7 = 0;
do {
bVar3 = *(byte *)((long)puVar9 + lVar7);
*(float *)(param_2 + lVar7 * 4) = (float)(int)(char)(&kvalues_iq4nl)[bVar3 & 0xf] * fVar12
;
*(float *)(param_2 + 0x40 + lVar7 * 4) =
(float)(int)(char)(&kvalues_iq4nl)[bVar3 >> 4] * fVar12;
lVar7 = lVar7 + 1;
} while (lVar7 != 0x10);
param_2 = param_2 + 0x80;
puVar9 = puVar9 + 8;
uVar10 = (int)uVar11 + 1;
uVar11 = (ulong)uVar10;
} while (uVar10 != 8);
lVar8 = lVar8 + 1;
} while (lVar8 != lVar6 >> 8);
}
return;
}
|
|
10,881 |
bool 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>::contains<char const (&) [7], 0>(char const (&) [7]) const
|
monkey531[P]llama/common/json.hpp
|
constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
}
|
O3
|
cpp
|
bool 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>::contains<char const (&) [7], 0>(char const (&) [7]) const:
cmpb $0x1, (%rdi)
jne 0xa4acf
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%r12), %rbx
cmpq 0x8(%r12), %rbx
je 0xa4ad2
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x181a0
testl %eax, %eax
je 0xa4ac2
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0xa4aa8
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0xa4ad5
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA7_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_A4ACF
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
mov r12, [rdi+8]
mov rbx, [r12]
cmp rbx, [r12+8]
jz short loc_A4AD2
mov r15, rsi
loc_A4AA8:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_A4AC2
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_A4AA8
loc_A4AC2:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_A4AD5
loc_A4ACF:
xor eax, eax
retn
loc_A4AD2:
mov rax, rbx
loc_A4AD5:
cmp rax, rbx
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA7_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
if ( *v2 == v2[1] )
{
v4 = *v2;
}
else
{
do
{
if ( !(unsigned int)std::string::compare(v3, a2) )
break;
v3 += 48LL;
}
while ( v3 != v2[1] );
v4 = v3;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
return v4 != v3;
}
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA7_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001a4acf
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [R12]
CMP RBX,qword ptr [R12 + 0x8]
JZ 0x001a4ad2
MOV R15,RSI
LAB_001a4aa8:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001181a0
TEST EAX,EAX
JZ 0x001a4ac2
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x001a4aa8
LAB_001a4ac2:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x001a4ad5
LAB_001a4acf:
XOR EAX,EAX
RET
LAB_001a4ad2:
MOV RAX,RBX
LAB_001a4ad5:
CMP RAX,RBX
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA7_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)*plVar1;
pcVar4 = pcVar3;
if (pcVar3 != (char *)plVar1[1]) {
do {
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar3 = pcVar3 + 0x30;
} while (pcVar3 != (char *)plVar1[1]);
pcVar4 = *(char **)(*(long *)(param_1 + 8) + 8);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != pcVar4);
}
|
|
10,882 |
common_init()::$_0::__invoke(ggml_log_level, char const*, void*)
|
monkey531[P]llama/common/common.cpp
|
void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
const char * build_type = " (debug)";
#endif
LOG_INF("build: %d (%s) with %s for %s%s\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT, LLAMA_COMPILER, LLAMA_BUILD_TARGET, build_type);
}
|
O0
|
cpp
|
common_init()::$_0::__invoke(ggml_log_level, char const*, void*):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
leaq 0x1ae8d8(%rip), %rcx # 0x2a35f8
cmpl (%rcx), %eax
jg 0xf4d43
callq 0x1bdea0
movq %rax, %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rcx
leaq 0x1164c8(%rip), %rdx # 0x20b204
movb $0x0, %al
callq 0x1bdf90
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
_ZZ11common_initvENK3$_0clE14ggml_log_levelPKcPv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_C], esi
mov [rsp+28h+var_18], rdx
mov [rsp+28h+var_20], rcx
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_F4D43
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov esi, [rsp+28h+var_C]
mov rcx, [rsp+28h+var_18]
lea rdx, aSetCustomJinja_0+0FEh; "%s"
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_F4D43:
add rsp, 28h
retn
|
long long common_init(void)::$_0::operator()(long long a1, int a2, int a3)
{
long long result; // rax
int v4; // eax
int v5; // r8d
int v6; // r9d
result = 0LL;
if ( common_log_verbosity_thold >= 0 )
{
v4 = common_log_main();
return common_log_add(v4, a2, (unsigned int)"%s", a3, v5, v6);
}
return result;
}
|
operator():
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ESI
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x8],RCX
XOR EAX,EAX
LEA RCX,[0x3a35f8]
CMP EAX,dword ptr [RCX]
JG 0x001f4d43
CALL 0x002bdea0
MOV RDI,RAX
MOV ESI,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RSP + 0x10]
LEA RDX,[0x30b204]
MOV AL,0x0
CALL 0x002bdf90
LAB_001f4d43:
ADD RSP,0x28
RET
|
/* common_init()::$_0::TEMPNAMEPLACEHOLDERVALUE(ggml_log_level, char const*, void*) const */
void common_init()::$_0::operator()(int8 param_1,int4 param_2,int8 param_3)
{
int8 uVar1;
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,param_2,"%s",param_3);
}
return;
}
|
|
10,883 |
common_init()::$_0::__invoke(ggml_log_level, char const*, void*)
|
monkey531[P]llama/common/common.cpp
|
void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
const char * build_type = " (debug)";
#endif
LOG_INF("build: %d (%s) with %s for %s%s\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT, LLAMA_COMPILER, LLAMA_BUILD_TARGET, build_type);
}
|
O3
|
cpp
|
common_init()::$_0::__invoke(ggml_log_level, char const*, void*):
pushq %rax
leaq 0x5e7f(%rip), %rdi # 0x7709a
xorl %esi, %esi
callq 0x1b020
leaq 0xbb1ef(%rip), %rax # 0x12c418
cmpl $0x0, (%rax)
js 0x7127d
callq 0xcb3a7
leaq 0xbaade(%rip), %rcx # 0x12bd18
movl (%rcx), %ecx
leaq 0xbaadd(%rip), %rdx # 0x12bd20
movq (%rdx), %r8
leaq 0xbaadb(%rip), %rdx # 0x12bd28
movq (%rdx), %r9
leaq 0xbaad9(%rip), %r10 # 0x12bd30
leaq 0x79888(%rip), %r11 # 0xeaae6
leaq 0x7c8c8(%rip), %rdx # 0xedb2d
movq %rax, %rdi
movl $0x2, %esi
xorl %eax, %eax
pushq %r11
pushq (%r10)
callq 0xcb444
addq $0x10, %rsp
popq %rax
retq
|
_Z11common_initv:
push rax
lea rdi, _ZZ11common_initvEN3$_08__invokeE14ggml_log_levelPKcPv; common_init(void)::$_0::__invoke(ggml_log_level,char const*,void *)
xor esi, esi
call _llama_log_set
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_7127D
call _Z15common_log_mainv; common_log_main(void)
lea rcx, LLAMA_BUILD_NUMBER
mov ecx, [rcx]
lea rdx, LLAMA_COMMIT
mov r8, [rdx]
lea rdx, LLAMA_COMPILER
mov r9, [rdx]
lea r10, LLAMA_BUILD_TARGET
lea r11, aErrorWhileHand_0+34h; ""
lea rdx, aBuildDSWithSFo; "build: %d (%s) with %s for %s%s\n"
mov rdi, rax
mov esi, 2
xor eax, eax
push r11
push qword ptr [r10]
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
add rsp, 10h
loc_7127D:
pop rax
retn
|
void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> common_init(void)
{
int v0; // eax
llama_log_set(common_init(void)::$_0::__invoke, 0LL);
if ( common_log_verbosity_thold >= 0 )
{
v0 = common_log_main();
common_log_add(
v0,
2,
(unsigned int)"build: %d (%s) with %s for %s%s\n",
LLAMA_BUILD_NUMBER,
LLAMA_COMMIT[0],
LLAMA_COMPILER[0]);
}
}
|
common_init:
PUSH RAX
LEA RDI,[0x17709a]
XOR ESI,ESI
CALL 0x0011b020
LEA RAX,[0x22c418]
CMP dword ptr [RAX],0x0
JS 0x0017127d
CALL 0x001cb3a7
LEA RCX,[0x22bd18]
MOV ECX,dword ptr [RCX]
LEA RDX,[0x22bd20]
MOV R8,qword ptr [RDX]
LEA RDX,[0x22bd28]
MOV R9,qword ptr [RDX]
LEA R10,[0x22bd30]
LEA R11,[0x1eaae6]
LEA RDX,[0x1edb2d]
MOV RDI,RAX
MOV ESI,0x2
XOR EAX,EAX
PUSH R11
PUSH qword ptr [R10]
CALL 0x001cb444
ADD RSP,0x10
LAB_0017127d:
POP RAX
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* common_init() */
int8 common_init(void)
{
int8 in_RAX;
int8 uVar1;
llama_log_set(common_init()::$_0::__invoke,0);
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,2,"build: %d (%s) with %s for %s%s\n",LLAMA_BUILD_NUMBER,LLAMA_COMMIT,
LLAMA_COMPILER,LLAMA_BUILD_TARGET,"");
}
return in_RAX;
}
|
|
10,884 |
my_uni_utf8mb3
|
eloqsql/strings/ctype-utf8.c
|
static int my_uni_utf8mb3(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *r, uchar *e)
{
if (wc < 0x80)
{
if (r >= e)
return MY_CS_TOOSMALL;
*r= (uchar) wc;
return 1;
}
if (wc < 0x800)
{
if (r + 2 > e)
return MY_CS_TOOSMALLN(2);
/* U+0080..U+07FF: 00000xxx.xxyyyyyy -> 110xxxxx 10yyyyyy */
*r++= (uchar) (0xC0 | (wc >> 6));
*r= (uchar) (0x80 | (wc & 0x3F));
return 2;
}
if (wc < 0x10000)
{
if (r + 3 > e)
return MY_CS_TOOSMALLN(3);
/* U+0800..U+FFFF: xxxxyyyy.yyzzzzzz -> 1110xxxx 10yyyyyy 10zzzzzz */
*r++= (uchar) (0xE0 | (wc >> 12));
*r++= (uchar) (0x80 | ((wc >> 6) & 0x3f));
*r= (uchar) (0x80 | (wc & 0x3f));
return 3;
}
return MY_CS_ILUNI;
}
|
O0
|
c
|
my_uni_utf8mb3:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x80, -0x18(%rbp)
jae 0x9bd8c
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x9bd74
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x9be80
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9be80
cmpq $0x800, -0x18(%rbp) # imm = 0x800
jae 0x9bdf3
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x9bdb0
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x9be80
movq -0x18(%rbp), %rax
shrq $0x6, %rax
orq $0xc0, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x9be80
cmpq $0x10000, -0x18(%rbp) # imm = 0x10000
jae 0x9be79
movq -0x20(%rbp), %rax
addq $0x3, %rax
cmpq -0x28(%rbp), %rax
jbe 0x9be14
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x9be80
movq -0x18(%rbp), %rax
shrq $0xc, %rax
orq $0xe0, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x9be80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_uni_utf8mb3:
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
cmp [rbp+var_18], 80h
jnb short loc_9BD8C
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_9BD74
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_9BE80
loc_9BD74:
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_9BE80
loc_9BD8C:
cmp [rbp+var_18], 800h
jnb short loc_9BDF3
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_9BDB0
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_9BE80
loc_9BDB0:
mov rax, [rbp+var_18]
shr rax, 6
or rax, 0C0h
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_18]
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 2
jmp loc_9BE80
loc_9BDF3:
cmp [rbp+var_18], 10000h
jnb short loc_9BE79
mov rax, [rbp+var_20]
add rax, 3
cmp rax, [rbp+var_28]
jbe short loc_9BE14
mov [rbp+var_4], 0FFFFFF99h
jmp short loc_9BE80
loc_9BE14:
mov rax, [rbp+var_18]
shr rax, 0Ch
or rax, 0E0h
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_18]
shr rax, 6
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_18]
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 3
jmp short loc_9BE80
loc_9BE79:
mov [rbp+var_4], 0
loc_9BE80:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_uni_utf8mb3(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
if ( a2 >= 0x80 )
{
if ( a2 >= 0x800 )
{
if ( a2 >= 0x10000 )
{
return 0;
}
else if ( (unsigned long long)(a3 + 3) <= a4 )
{
*a3 = (a2 >> 12) | 0xE0;
a3[1] = (a2 >> 6) & 0x3F | 0x80;
a3[2] = a2 & 0x3F | 0x80;
return 3;
}
else
{
return (unsigned int)-103;
}
}
else if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = (a2 >> 6) | 0xC0;
a3[1] = a2 & 0x3F | 0x80;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else if ( (unsigned long long)a3 < a4 )
{
*a3 = a2;
return 1;
}
else
{
return (unsigned int)-101;
}
}
|
my_uni_utf8mb3:
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
CMP qword ptr [RBP + -0x18],0x80
JNC 0x0019bd8c
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0019bd74
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0019be80
LAB_0019bd74:
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 0x0019be80
LAB_0019bd8c:
CMP qword ptr [RBP + -0x18],0x800
JNC 0x0019bdf3
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0019bdb0
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0019be80
LAB_0019bdb0:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
OR RAX,0xc0
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
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],CL
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0019be80
LAB_0019bdf3:
CMP qword ptr [RBP + -0x18],0x10000
JNC 0x0019be79
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0019be14
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x0019be80
LAB_0019be14:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0xc
OR RAX,0xe0
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
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],CL
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0019be80
LAB_0019be79:
MOV dword ptr [RBP + -0x4],0x0
LAB_0019be80:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_uni_utf8mb3(int8 param_1,ulong param_2,byte *param_3,byte *param_4)
{
byte bVar1;
int4 local_c;
bVar1 = (byte)param_2;
if (param_2 < 0x80) {
if (param_3 < param_4) {
*param_3 = bVar1;
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
}
else if (param_2 < 0x800) {
if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (byte)(param_2 >> 6) | 0xc0;
param_3[1] = bVar1 & 0x3f | 0x80;
local_c = 2;
}
}
else if (param_2 < 0x10000) {
if (param_4 < param_3 + 3) {
local_c = 0xffffff99;
}
else {
*param_3 = (byte)(param_2 >> 0xc) | 0xe0;
param_3[1] = (byte)(param_2 >> 6) & 0x3f | 0x80;
param_3[2] = bVar1 & 0x3f | 0x80;
local_c = 3;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
10,885 |
psi_cond_timedwait
|
eloqsql/mysys/my_thr_init.c
|
ATTRIBUTE_COLD int psi_cond_timedwait(mysql_cond_t *that, mysql_mutex_t *mutex,
const struct timespec *abstime,
const char *file, uint line)
{
PSI_cond_locker_state state;
PSI_cond_locker *locker= PSI_COND_CALL(start_cond_wait)
(&state, that->m_psi, mutex->m_psi, PSI_COND_TIMEDWAIT, file, line);
int result= my_cond_timedwait(&that->m_cond, &mutex->m_mutex, abstime);
if (psi_likely(locker))
PSI_COND_CALL(end_cond_wait)(locker, result);
return result;
}
|
O3
|
c
|
psi_cond_timedwait:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %r9d
movq %rcx, %r8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x35dddf(%rip), %r13 # 0x38d070
movq (%r13), %rax
movq 0x30(%rdi), %rsi
movq 0x40(%r15), %rdx
leaq -0x60(%rbp), %rdi
pushq $0x1
popq %rcx
callq *0x1c0(%rax)
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x29620
movl %eax, %r14d
testq %rbx, %rbx
jne 0x2f2d5
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r13), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x1c8(%rax)
jmp 0x2f2c3
|
psi_cond_timedwait:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r9d, r8d
mov r8, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
lea r13, PSI_server
mov rax, [r13+0]
mov rsi, [rdi+30h]
mov rdx, [r15+40h]
lea rdi, [rbp+var_60]
push 1
pop rcx
call qword ptr [rax+1C0h]
mov rbx, rax
mov rdi, r12
mov rsi, r15
mov rdx, r14
call _pthread_cond_timedwait
mov r14d, eax
test rbx, rbx
jnz short loc_2F2D5
loc_2F2C3:
mov eax, r14d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2F2D5:
mov rax, [r13+0]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+1C8h]
jmp short loc_2F2C3
|
long long psi_cond_timedwait(long long a1, long long a2, long long a3, long long a4, unsigned int a5)
{
long long v6; // rbx
unsigned int v7; // r14d
_BYTE v9[96]; // [rsp+0h] [rbp-60h] BYREF
v6 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, long long, _QWORD))PSI_server[56])(
v9,
*(_QWORD *)(a1 + 48),
*(_QWORD *)(a2 + 64),
1LL,
a4,
a5);
v7 = pthread_cond_timedwait(a1, a2, a3);
if ( v6 )
((void ( *)(long long, _QWORD))PSI_server[57])(v6, v7);
return v7;
}
|
psi_cond_timedwait:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R9D,R8D
MOV R8,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
LEA R13,[0x48d070]
MOV RAX,qword ptr [R13]
MOV RSI,qword ptr [RDI + 0x30]
MOV RDX,qword ptr [R15 + 0x40]
LEA RDI,[RBP + -0x60]
PUSH 0x1
POP RCX
CALL qword ptr [RAX + 0x1c0]
MOV RBX,RAX
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
CALL 0x00129620
MOV R14D,EAX
TEST RBX,RBX
JNZ 0x0012f2d5
LAB_0012f2c3:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012f2d5:
MOV RAX,qword ptr [R13]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x1c8]
JMP 0x0012f2c3
|
int psi_cond_timedwait(pthread_cond_t *param_1,pthread_mutex_t *param_2,timespec *param_3,
int8 param_4,int4 param_5)
{
int iVar1;
long lVar2;
int1 local_68 [56];
lVar2 = (**(code **)(PSI_server + 0x1c0))
(local_68,param_1[1].__align,*(int8 *)((long)param_2 + 0x40),1,param_4,
param_5);
iVar1 = pthread_cond_timedwait(param_1,param_2,param_3);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1c8))(lVar2,iVar1);
}
return iVar1;
}
|
|
10,886 |
cleanup_dirname
|
eloqsql/mysys/mf_pack.c
|
size_t cleanup_dirname(register char *to, const char *from)
{
reg5 size_t length;
reg2 char * pos;
reg3 char * from_ptr;
reg4 char * start;
char parent[5], /* for "FN_PARENTDIR" */
buff[FN_REFLEN + 1],*end_parentdir;
#ifdef BACKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
DBUG_ENTER("cleanup_dirname");
DBUG_PRINT("enter",("from: '%s'",from));
start=buff;
from_ptr=(char *) from;
#ifdef FN_DEVCHAR
if ((pos=strrchr(from_ptr,FN_DEVCHAR)) != 0)
{ /* Skip device part */
length=(size_t) (pos-from_ptr)+1;
start=strnmov(buff,from_ptr,length); from_ptr+=length;
}
#endif
parent[0]=FN_LIBCHAR;
length=(size_t) (strmov(parent+1,FN_PARENTDIR)-parent);
for (pos=start ; (*pos= *from_ptr++) != 0 ; pos++)
{
#ifdef BACKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, from_ptr - 1, from_ptr + 2)))
{
for (l-- ; l ; *++pos= *from_ptr++, l--);
start= pos + 1; /* Don't look inside multi-byte char */
continue;
}
#endif
if (*pos == '/')
*pos = FN_LIBCHAR;
if (*pos == FN_LIBCHAR)
{
if ((size_t) (pos-start) > length && memcmp(pos-length,parent,length) == 0)
{ /* If .../../; skip prev */
pos-=length;
if (pos != start)
{ /* not /../ */
pos--;
if (*pos == FN_HOMELIB && (pos == start || pos[-1] == FN_LIBCHAR))
{
if (!home_dir)
{
pos+=length+1; /* Don't unpack ~/.. */
continue;
}
pos=strmov(buff,home_dir)-1; /* Unpacks ~/.. */
if (*pos == FN_LIBCHAR)
pos--; /* home ended with '/' */
}
if (*pos == FN_CURLIB && (pos == start || pos[-1] == FN_LIBCHAR))
{
if (my_getwd(curr_dir,FN_REFLEN,MYF(0)))
{
pos+=length+1; /* Don't unpack ./.. */
continue;
}
pos=strmov(buff,curr_dir)-1; /* Unpacks ./.. */
if (*pos == FN_LIBCHAR)
pos--; /* home ended with '/' */
}
end_parentdir=pos;
while (pos >= start && *pos != FN_LIBCHAR) /* remove prev dir */
pos--;
if (pos[1] == FN_HOMELIB ||
(pos >= start && memcmp(pos, parent, length) == 0))
{ /* Don't remove ~user/ */
pos=strmov(end_parentdir+1,parent);
*pos=FN_LIBCHAR;
continue;
}
}
}
else if ((size_t) (pos-start) == length-1 &&
!memcmp(start,parent+1,length-1))
start=pos; /* Starts with "../" */
else if (pos-start > 0 && pos[-1] == FN_LIBCHAR)
{
#ifdef FN_NETWORK_DRIVES
if (pos-start != 1)
#endif
pos--; /* Remove dupplicate '/' */
}
else if (pos-start > 1 && pos[-1] == FN_CURLIB && pos[-2] == FN_LIBCHAR)
pos-=2; /* Skip /./ */
}
}
(void) strmov(to,buff);
DBUG_PRINT("exit",("to: '%s'",to));
DBUG_RETURN((size_t) (pos-buff));
}
|
O0
|
c
|
cleanup_dirname:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
jmp 0xea718
leaq -0x210(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x220(%rbp), %rax
movq %rax, -0x238(%rbp)
movb $0x2f, -0xd(%rbp)
leaq -0xd(%rbp), %rdi
addq $0x1, %rdi
leaq 0x6a9c8(%rip), %rsi # 0x15510f
callq 0x296a0
leaq -0xd(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x228(%rbp)
movq -0x240(%rbp), %rax
movq %rax, -0x230(%rbp)
movq -0x238(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x238(%rbp)
movb (%rax), %al
movq -0x230(%rbp), %rcx
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0xeab61
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xea7ad
movq -0x230(%rbp), %rax
movb $0x2f, (%rax)
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xeab48
movq -0x230(%rbp), %rax
movq -0x240(%rbp), %rcx
subq %rcx, %rax
cmpq -0x228(%rbp), %rax
jbe 0xeaa64
movq -0x230(%rbp), %rdi
xorl %eax, %eax
subq -0x228(%rbp), %rax
addq %rax, %rdi
leaq -0xd(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq 0x297a0
cmpl $0x0, %eax
jne 0xeaa64
movq -0x228(%rbp), %rdx
movq -0x230(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rax
cmpq -0x240(%rbp), %rax
je 0xeaa5f
movq -0x230(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0xea8ef
movq -0x230(%rbp), %rax
cmpq -0x240(%rbp), %rax
je 0xea880
movq -0x230(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0xea8ef
leaq 0xb9a171(%rip), %rax # 0xc849f8
cmpq $0x0, (%rax)
jne 0xea8ab
movq -0x228(%rbp), %rax
addq $0x1, %rax
addq -0x230(%rbp), %rax
movq %rax, -0x230(%rbp)
jmp 0xeab4a
leaq -0x210(%rbp), %rdi
leaq 0xb9a13f(%rip), %rax # 0xc849f8
movq (%rax), %rsi
callq 0x296a0
addq $-0x1, %rax
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xea8ed
movq -0x230(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x230(%rbp)
jmp 0xea8ef
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xea99b
movq -0x230(%rbp), %rax
cmpq -0x240(%rbp), %rax
je 0xea922
movq -0x230(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0xea99b
leaq 0xb9a0e7(%rip), %rdi # 0xc84a10
movl $0x200, %esi # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0xf1ac0
cmpl $0x0, %eax
je 0xea95a
movq -0x228(%rbp), %rax
addq $0x1, %rax
addq -0x230(%rbp), %rax
movq %rax, -0x230(%rbp)
jmp 0xeab4a
leaq -0x210(%rbp), %rdi
leaq 0xb9a0a8(%rip), %rsi # 0xc84a10
callq 0x296a0
addq $-0x1, %rax
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xea999
movq -0x230(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x230(%rbp)
jmp 0xea99b
movq -0x230(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x230(%rbp), %rcx
xorl %eax, %eax
cmpq -0x240(%rbp), %rcx
movb %al, -0x249(%rbp)
jb 0xea9d7
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x249(%rbp)
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0xea9e3
jmp 0xea9f7
movq -0x230(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x230(%rbp)
jmp 0xea9a9
movq -0x230(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x7e, %eax
je 0xeaa33
movq -0x230(%rbp), %rax
cmpq -0x240(%rbp), %rax
jb 0xeaa5d
movq -0x230(%rbp), %rdi
leaq -0xd(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq 0x297a0
cmpl $0x0, %eax
jne 0xeaa5d
movq -0x248(%rbp), %rdi
addq $0x1, %rdi
leaq -0xd(%rbp), %rsi
callq 0x296a0
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rax
movb $0x2f, (%rax)
jmp 0xeab4a
jmp 0xeaa5f
jmp 0xeab46
movq -0x230(%rbp), %rax
movq -0x240(%rbp), %rcx
subq %rcx, %rax
movq -0x228(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0xeaabc
movq -0x240(%rbp), %rdi
leaq -0xd(%rbp), %rsi
addq $0x1, %rsi
movq -0x228(%rbp), %rdx
subq $0x1, %rdx
callq 0x297a0
cmpl $0x0, %eax
jne 0xeaabc
movq -0x230(%rbp), %rax
movq %rax, -0x240(%rbp)
jmp 0xeab44
movq -0x230(%rbp), %rax
movq -0x240(%rbp), %rcx
subq %rcx, %rax
cmpq $0x0, %rax
jle 0xeaaf7
movq -0x230(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0xeaaf7
movq -0x230(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x230(%rbp)
jmp 0xeab42
movq -0x230(%rbp), %rax
movq -0x240(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jle 0xeab40
movq -0x230(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2e, %eax
jne 0xeab40
movq -0x230(%rbp), %rax
movsbl -0x2(%rax), %eax
cmpl $0x2f, %eax
jne 0xeab40
movq -0x230(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0x230(%rbp)
jmp 0xeab42
jmp 0xeab44
jmp 0xeab46
jmp 0xeab48
jmp 0xeab4a
movq -0x230(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x230(%rbp)
jmp 0xea768
movq -0x218(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x296a0
jmp 0xeab76
jmp 0xeab78
movq -0x230(%rbp), %rax
leaq -0x210(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x258(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xeabb2
movq -0x258(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
callq 0x29230
nopw (%rax,%rax)
|
cleanup_dirname:
push rbp
mov rbp, rsp
sub rsp, 260h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
jmp short $+2
loc_EA718:
lea rax, [rbp+var_210]
mov [rbp+var_240], rax
mov rax, [rbp+var_220]
mov [rbp+var_238], rax
mov [rbp+var_D], 2Fh ; '/'
lea rdi, [rbp+var_D]
add rdi, 1
lea rsi, asc_15510F; ".."
call _stpcpy
lea rcx, [rbp+var_D]
sub rax, rcx
mov [rbp+var_228], rax
mov rax, [rbp+var_240]
mov [rbp+var_230], rax
loc_EA768:
mov rax, [rbp+var_238]
mov rcx, rax
add rcx, 1
mov [rbp+var_238], rcx
mov al, [rax]
mov rcx, [rbp+var_230]
mov [rcx], al
movsx eax, al
cmp eax, 0
jz loc_EAB61
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_EA7AD
mov rax, [rbp+var_230]
mov byte ptr [rax], 2Fh ; '/'
loc_EA7AD:
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz loc_EAB48
mov rax, [rbp+var_230]
mov rcx, [rbp+var_240]
sub rax, rcx
cmp rax, [rbp+var_228]
jbe loc_EAA64
mov rdi, [rbp+var_230]
xor eax, eax
sub rax, [rbp+var_228]
add rdi, rax
lea rsi, [rbp+var_D]
mov rdx, [rbp+var_228]
call _memcmp
cmp eax, 0
jnz loc_EAA64
mov rdx, [rbp+var_228]
mov rax, [rbp+var_230]
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_230], rax
mov rax, [rbp+var_230]
cmp rax, [rbp+var_240]
jz loc_EAA5F
mov rax, [rbp+var_230]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_230], rax
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 7Eh ; '~'
jnz loc_EA8EF
mov rax, [rbp+var_230]
cmp rax, [rbp+var_240]
jz short loc_EA880
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jnz short loc_EA8EF
loc_EA880:
lea rax, home_dir
cmp qword ptr [rax], 0
jnz short loc_EA8AB
mov rax, [rbp+var_228]
add rax, 1
add rax, [rbp+var_230]
mov [rbp+var_230], rax
jmp loc_EAB4A
loc_EA8AB:
lea rdi, [rbp+var_210]
lea rax, home_dir
mov rsi, [rax]
call _stpcpy
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_230], rax
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_EA8ED
mov rax, [rbp+var_230]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_230], rax
loc_EA8ED:
jmp short $+2
loc_EA8EF:
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 2Eh ; '.'
jnz loc_EA99B
mov rax, [rbp+var_230]
cmp rax, [rbp+var_240]
jz short loc_EA922
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jnz short loc_EA99B
loc_EA922:
lea rdi, curr_dir
mov esi, 200h
xor eax, eax
mov edx, eax
call my_getwd
cmp eax, 0
jz short loc_EA95A
mov rax, [rbp+var_228]
add rax, 1
add rax, [rbp+var_230]
mov [rbp+var_230], rax
jmp loc_EAB4A
loc_EA95A:
lea rdi, [rbp+var_210]
lea rsi, curr_dir
call _stpcpy
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_230], rax
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_EA999
mov rax, [rbp+var_230]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_230], rax
loc_EA999:
jmp short $+2
loc_EA99B:
mov rax, [rbp+var_230]
mov [rbp+var_248], rax
loc_EA9A9:
mov rcx, [rbp+var_230]
xor eax, eax
cmp rcx, [rbp+var_240]
mov [rbp+var_249], al
jb short loc_EA9D7
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
setnz al
mov [rbp+var_249], al
loc_EA9D7:
mov al, [rbp+var_249]
test al, 1
jnz short loc_EA9E3
jmp short loc_EA9F7
loc_EA9E3:
mov rax, [rbp+var_230]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_230], rax
jmp short loc_EA9A9
loc_EA9F7:
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax+1]
cmp eax, 7Eh ; '~'
jz short loc_EAA33
mov rax, [rbp+var_230]
cmp rax, [rbp+var_240]
jb short loc_EAA5D
mov rdi, [rbp+var_230]
lea rsi, [rbp+var_D]
mov rdx, [rbp+var_228]
call _memcmp
cmp eax, 0
jnz short loc_EAA5D
loc_EAA33:
mov rdi, [rbp+var_248]
add rdi, 1
lea rsi, [rbp+var_D]
call _stpcpy
mov [rbp+var_230], rax
mov rax, [rbp+var_230]
mov byte ptr [rax], 2Fh ; '/'
jmp loc_EAB4A
loc_EAA5D:
jmp short $+2
loc_EAA5F:
jmp loc_EAB46
loc_EAA64:
mov rax, [rbp+var_230]
mov rcx, [rbp+var_240]
sub rax, rcx
mov rcx, [rbp+var_228]
sub rcx, 1
cmp rax, rcx
jnz short loc_EAABC
mov rdi, [rbp+var_240]
lea rsi, [rbp+var_D]
add rsi, 1
mov rdx, [rbp+var_228]
sub rdx, 1
call _memcmp
cmp eax, 0
jnz short loc_EAABC
mov rax, [rbp+var_230]
mov [rbp+var_240], rax
jmp loc_EAB44
loc_EAABC:
mov rax, [rbp+var_230]
mov rcx, [rbp+var_240]
sub rax, rcx
cmp rax, 0
jle short loc_EAAF7
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jnz short loc_EAAF7
mov rax, [rbp+var_230]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_230], rax
jmp short loc_EAB42
loc_EAAF7:
mov rax, [rbp+var_230]
mov rcx, [rbp+var_240]
sub rax, rcx
cmp rax, 1
jle short loc_EAB40
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax-1]
cmp eax, 2Eh ; '.'
jnz short loc_EAB40
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax-2]
cmp eax, 2Fh ; '/'
jnz short loc_EAB40
mov rax, [rbp+var_230]
add rax, 0FFFFFFFFFFFFFFFEh
mov [rbp+var_230], rax
loc_EAB40:
jmp short $+2
loc_EAB42:
jmp short $+2
loc_EAB44:
jmp short $+2
loc_EAB46:
jmp short $+2
loc_EAB48:
jmp short $+2
loc_EAB4A:
mov rax, [rbp+var_230]
add rax, 1
mov [rbp+var_230], rax
jmp loc_EA768
loc_EAB61:
mov rdi, [rbp+var_218]
lea rsi, [rbp+var_210]
call _stpcpy
jmp short $+2
loc_EAB76:
jmp short $+2
loc_EAB78:
mov rax, [rbp+var_230]
lea rcx, [rbp+var_210]
sub rax, rcx
mov [rbp+var_258], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_EABB2
mov rax, [rbp+var_258]
add rsp, 260h
pop rbp
retn
loc_EABB2:
call ___stack_chk_fail
|
long long cleanup_dirname(long long a1, _BYTE *a2)
{
_BYTE *v2; // rax
bool v4; // [rsp+17h] [rbp-249h]
_BYTE *v5; // [rsp+18h] [rbp-248h]
_BYTE *v6; // [rsp+20h] [rbp-240h]
_BYTE *i; // [rsp+30h] [rbp-230h]
unsigned long long v9; // [rsp+38h] [rbp-228h]
long long v10; // [rsp+48h] [rbp-218h]
_BYTE v11[515]; // [rsp+50h] [rbp-210h] BYREF
char v12; // [rsp+253h] [rbp-Dh] BYREF
_BYTE v13[12]; // [rsp+254h] [rbp-Ch] BYREF
*(_QWORD *)&v13[4] = __readfsqword(0x28u);
v10 = a1;
v6 = v11;
v12 = 47;
v9 = stpcpy(v13, "..") - (_QWORD)&v12;
for ( i = v11; ; ++i )
{
v2 = a2++;
LOBYTE(v2) = *v2;
*i = (_BYTE)v2;
if ( !(_BYTE)v2 )
break;
if ( *i == 47 )
*i = 47;
if ( *i == 47 )
{
if ( i - v6 > v9 && !(unsigned int)memcmp(&i[-v9], &v12, v9) )
{
i -= v9;
if ( i != v6 )
{
if ( *--i == 126 && (i == v6 || *(i - 1) == 47) )
{
if ( !home_dir )
{
i += v9 + 1;
continue;
}
i = (_BYTE *)(stpcpy(v11, home_dir) - 1);
if ( *i == 47 )
--i;
}
if ( *i == 46 && (i == v6 || *(i - 1) == 47) )
{
if ( (unsigned int)my_getwd(&curr_dir, 512LL, 0LL) )
{
i += v9 + 1;
continue;
}
i = (_BYTE *)(stpcpy(v11, &curr_dir) - 1);
if ( *i == 47 )
--i;
}
v5 = i;
while ( 1 )
{
v4 = 0;
if ( i >= v6 )
v4 = *i != 47;
if ( !v4 )
break;
--i;
}
if ( i[1] == 126 || i >= v6 && !(unsigned int)memcmp(i, &v12, v9) )
{
i = (_BYTE *)stpcpy(v5 + 1, &v12);
*i = 47;
}
}
}
else if ( i - v6 == v9 - 1 && !(unsigned int)memcmp(v6, v13, v9 - 1) )
{
v6 = i;
}
else if ( i - v6 > 0 && *(i - 1) == 47 )
{
--i;
}
else if ( i - v6 > 1 && *(i - 1) == 46 && *(i - 2) == 47 )
{
i -= 2;
}
}
}
stpcpy(v10, v11);
return i - v11;
}
|
cleanup_dirname:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x260
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
JMP 0x001ea718
LAB_001ea718:
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x240],RAX
MOV RAX,qword ptr [RBP + -0x220]
MOV qword ptr [RBP + -0x238],RAX
MOV byte ptr [RBP + -0xd],0x2f
LEA RDI,[RBP + -0xd]
ADD RDI,0x1
LEA RSI,[0x25510f]
CALL 0x001296a0
LEA RCX,[RBP + -0xd]
SUB RAX,RCX
MOV qword ptr [RBP + -0x228],RAX
MOV RAX,qword ptr [RBP + -0x240]
MOV qword ptr [RBP + -0x230],RAX
LAB_001ea768:
MOV RAX,qword ptr [RBP + -0x238]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x238],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x230]
MOV byte ptr [RCX],AL
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001eab61
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x001ea7ad
MOV RAX,qword ptr [RBP + -0x230]
MOV byte ptr [RAX],0x2f
LAB_001ea7ad:
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x001eab48
MOV RAX,qword ptr [RBP + -0x230]
MOV RCX,qword ptr [RBP + -0x240]
SUB RAX,RCX
CMP RAX,qword ptr [RBP + -0x228]
JBE 0x001eaa64
MOV RDI,qword ptr [RBP + -0x230]
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x228]
ADD RDI,RAX
LEA RSI,[RBP + -0xd]
MOV RDX,qword ptr [RBP + -0x228]
CALL 0x001297a0
CMP EAX,0x0
JNZ 0x001eaa64
MOV RDX,qword ptr [RBP + -0x228]
MOV RAX,qword ptr [RBP + -0x230]
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x230],RAX
MOV RAX,qword ptr [RBP + -0x230]
CMP RAX,qword ptr [RBP + -0x240]
JZ 0x001eaa5f
MOV RAX,qword ptr [RBP + -0x230]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x230],RAX
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7e
JNZ 0x001ea8ef
MOV RAX,qword ptr [RBP + -0x230]
CMP RAX,qword ptr [RBP + -0x240]
JZ 0x001ea880
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JNZ 0x001ea8ef
LAB_001ea880:
LEA RAX,[0xd849f8]
CMP qword ptr [RAX],0x0
JNZ 0x001ea8ab
MOV RAX,qword ptr [RBP + -0x228]
ADD RAX,0x1
ADD RAX,qword ptr [RBP + -0x230]
MOV qword ptr [RBP + -0x230],RAX
JMP 0x001eab4a
LAB_001ea8ab:
LEA RDI,[RBP + -0x210]
LEA RAX,[0xd849f8]
MOV RSI,qword ptr [RAX]
CALL 0x001296a0
ADD RAX,-0x1
MOV qword ptr [RBP + -0x230],RAX
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x001ea8ed
MOV RAX,qword ptr [RBP + -0x230]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x230],RAX
LAB_001ea8ed:
JMP 0x001ea8ef
LAB_001ea8ef:
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2e
JNZ 0x001ea99b
MOV RAX,qword ptr [RBP + -0x230]
CMP RAX,qword ptr [RBP + -0x240]
JZ 0x001ea922
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JNZ 0x001ea99b
LAB_001ea922:
LEA RDI,[0xd84a10]
MOV ESI,0x200
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f1ac0
CMP EAX,0x0
JZ 0x001ea95a
MOV RAX,qword ptr [RBP + -0x228]
ADD RAX,0x1
ADD RAX,qword ptr [RBP + -0x230]
MOV qword ptr [RBP + -0x230],RAX
JMP 0x001eab4a
LAB_001ea95a:
LEA RDI,[RBP + -0x210]
LEA RSI,[0xd84a10]
CALL 0x001296a0
ADD RAX,-0x1
MOV qword ptr [RBP + -0x230],RAX
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x001ea999
MOV RAX,qword ptr [RBP + -0x230]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x230],RAX
LAB_001ea999:
JMP 0x001ea99b
LAB_001ea99b:
MOV RAX,qword ptr [RBP + -0x230]
MOV qword ptr [RBP + -0x248],RAX
LAB_001ea9a9:
MOV RCX,qword ptr [RBP + -0x230]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x240]
MOV byte ptr [RBP + -0x249],AL
JC 0x001ea9d7
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
SETNZ AL
MOV byte ptr [RBP + -0x249],AL
LAB_001ea9d7:
MOV AL,byte ptr [RBP + -0x249]
TEST AL,0x1
JNZ 0x001ea9e3
JMP 0x001ea9f7
LAB_001ea9e3:
MOV RAX,qword ptr [RBP + -0x230]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x230],RAX
JMP 0x001ea9a9
LAB_001ea9f7:
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x7e
JZ 0x001eaa33
MOV RAX,qword ptr [RBP + -0x230]
CMP RAX,qword ptr [RBP + -0x240]
JC 0x001eaa5d
MOV RDI,qword ptr [RBP + -0x230]
LEA RSI,[RBP + -0xd]
MOV RDX,qword ptr [RBP + -0x228]
CALL 0x001297a0
CMP EAX,0x0
JNZ 0x001eaa5d
LAB_001eaa33:
MOV RDI,qword ptr [RBP + -0x248]
ADD RDI,0x1
LEA RSI,[RBP + -0xd]
CALL 0x001296a0
MOV qword ptr [RBP + -0x230],RAX
MOV RAX,qword ptr [RBP + -0x230]
MOV byte ptr [RAX],0x2f
JMP 0x001eab4a
LAB_001eaa5d:
JMP 0x001eaa5f
LAB_001eaa5f:
JMP 0x001eab46
LAB_001eaa64:
MOV RAX,qword ptr [RBP + -0x230]
MOV RCX,qword ptr [RBP + -0x240]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x228]
SUB RCX,0x1
CMP RAX,RCX
JNZ 0x001eaabc
MOV RDI,qword ptr [RBP + -0x240]
LEA RSI,[RBP + -0xd]
ADD RSI,0x1
MOV RDX,qword ptr [RBP + -0x228]
SUB RDX,0x1
CALL 0x001297a0
CMP EAX,0x0
JNZ 0x001eaabc
MOV RAX,qword ptr [RBP + -0x230]
MOV qword ptr [RBP + -0x240],RAX
JMP 0x001eab44
LAB_001eaabc:
MOV RAX,qword ptr [RBP + -0x230]
MOV RCX,qword ptr [RBP + -0x240]
SUB RAX,RCX
CMP RAX,0x0
JLE 0x001eaaf7
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JNZ 0x001eaaf7
MOV RAX,qword ptr [RBP + -0x230]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x230],RAX
JMP 0x001eab42
LAB_001eaaf7:
MOV RAX,qword ptr [RBP + -0x230]
MOV RCX,qword ptr [RBP + -0x240]
SUB RAX,RCX
CMP RAX,0x1
JLE 0x001eab40
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2e
JNZ 0x001eab40
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX + -0x2]
CMP EAX,0x2f
JNZ 0x001eab40
MOV RAX,qword ptr [RBP + -0x230]
ADD RAX,-0x2
MOV qword ptr [RBP + -0x230],RAX
LAB_001eab40:
JMP 0x001eab42
LAB_001eab42:
JMP 0x001eab44
LAB_001eab44:
JMP 0x001eab46
LAB_001eab46:
JMP 0x001eab48
LAB_001eab48:
JMP 0x001eab4a
LAB_001eab4a:
MOV RAX,qword ptr [RBP + -0x230]
ADD RAX,0x1
MOV qword ptr [RBP + -0x230],RAX
JMP 0x001ea768
LAB_001eab61:
MOV RDI,qword ptr [RBP + -0x218]
LEA RSI,[RBP + -0x210]
CALL 0x001296a0
JMP 0x001eab76
LAB_001eab76:
JMP 0x001eab78
LAB_001eab78:
MOV RAX,qword ptr [RBP + -0x230]
LEA RCX,[RBP + -0x210]
SUB RAX,RCX
MOV qword ptr [RBP + -0x258],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001eabb2
MOV RAX,qword ptr [RBP + -0x258]
ADD RSP,0x260
POP RBP
RET
LAB_001eabb2:
CALL 0x00129230
|
long cleanup_dirname(char *param_1,char *param_2)
{
char cVar1;
int iVar2;
char *pcVar3;
ulong __n;
char *pcVar4;
long in_FS_OFFSET;
bool bVar5;
char *local_248;
char *local_240;
char *local_238;
char local_218 [515];
char local_15;
char acStack_14 [4];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_248 = local_218;
local_15 = '/';
pcVar3 = stpcpy(acStack_14,"..");
__n = (long)pcVar3 - (long)&local_15;
local_240 = param_2;
local_238 = local_248;
do {
cVar1 = *local_240;
*local_238 = cVar1;
if (cVar1 == '\0') {
stpcpy(param_1,local_218);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)local_238 - (long)local_218;
}
if (*local_238 == '/') {
*local_238 = '/';
}
if (*local_238 == '/') {
if ((__n < (ulong)((long)local_238 - (long)local_248)) &&
(iVar2 = memcmp(local_238 + -__n,&local_15,__n), iVar2 == 0)) {
local_238 = local_238 + -__n;
if (local_238 != local_248) {
pcVar3 = local_238 + -1;
if ((*pcVar3 == '~') && ((pcVar3 == local_248 || (local_238[-2] == '/')))) {
if (home_dir == (char *)0x0) {
local_238 = pcVar3 + __n + 1;
goto LAB_001eab4a;
}
pcVar4 = stpcpy(local_218,home_dir);
pcVar3 = pcVar4 + -1;
if (pcVar4[-1] == '/') {
pcVar3 = pcVar4 + -2;
}
}
local_238 = pcVar3;
pcVar3 = local_238;
if ((*local_238 == '.') && ((local_238 == local_248 || (local_238[-1] == '/')))) {
iVar2 = my_getwd(&curr_dir,0x200,0);
if (iVar2 != 0) {
local_238 = local_238 + __n + 1;
goto LAB_001eab4a;
}
pcVar4 = stpcpy(local_218,&curr_dir);
local_238 = pcVar4 + -1;
pcVar3 = local_238;
if (*local_238 == '/') {
local_238 = pcVar4 + -2;
pcVar3 = local_238;
}
}
while( true ) {
bVar5 = false;
if (local_248 <= local_238) {
bVar5 = *local_238 != '/';
}
if (!bVar5) break;
local_238 = local_238 + -1;
}
if ((local_238[1] == '~') ||
((local_248 <= local_238 && (iVar2 = memcmp(local_238,&local_15,__n), iVar2 == 0)))) {
local_238 = stpcpy(pcVar3 + 1,&local_15);
*local_238 = '/';
}
}
}
else if (((long)local_238 - (long)local_248 == __n - 1) &&
(iVar2 = memcmp(local_248,acStack_14,__n - 1), iVar2 == 0)) {
local_248 = local_238;
}
else if (((long)local_238 - (long)local_248 < 1) || (local_238[-1] != '/')) {
if ((1 < (long)local_238 - (long)local_248) &&
((local_238[-1] == '.' && (local_238[-2] == '/')))) {
local_238 = local_238 + -2;
}
}
else {
local_238 = local_238 + -1;
}
}
LAB_001eab4a:
local_238 = local_238 + 1;
local_240 = local_240 + 1;
} while( true );
}
|
|
10,887 |
str_to_TIME
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
int str_to_TIME(const char *str, size_t length, MYSQL_TIME *tm)
{
const char *p = str;
const char *end = str + length;
int is_time = 0;
if (!p)
goto error;
while (p < end && isspace(*p))
p++;
while (p < end && isspace(end[-1]))
end--;
if (end -p < 5)
goto error;
if (*p == '-')
{
tm->neg = 1;
/* Only TIME can't be negative.*/
is_time = 1;
p++;
}
else
{
int i;
tm->neg = 0;
/*
Date parsing (in server) accepts leading zeroes, thus position of the delimiters
is not fixed. Scan the string to find out what we need to parse.
*/
for (i = 1; p + i < end; i++)
{
if(p[i] == '-' || p [i] == ':')
{
is_time = p[i] == ':';
break;
}
}
}
if (is_time)
{
if (parse_time(p, end - p, &p, tm))
goto error;
tm->year = tm->month = tm->day = 0;
tm->time_type = MYSQL_TIMESTAMP_TIME;
return 0;
}
if (parse_date(p, end - p, &p, tm))
goto error;
if (p == end || p[0] != ' ')
{
tm->hour = tm->minute = tm->second = tm->second_part = 0;
tm->time_type = MYSQL_TIMESTAMP_DATE;
return 0;
}
/* Skip space. */
p++;
if (parse_time(p, end - p, &p, tm))
goto error;
/* In DATETIME, hours must be < 24.*/
if (tm->hour > 23)
goto error;
tm->time_type = MYSQL_TIMESTAMP_DATETIME;
return 0;
error:
memset(tm, 0, sizeof(*tm));
tm->time_type = MYSQL_TIMESTAMP_ERROR;
return 1;
}
|
O3
|
c
|
str_to_TIME:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r10
testq %rdi, %rdi
je 0x347fa
movq %rsi, %r11
movq %rdi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
movq %r10, -0x40(%rbp)
movq %rsi, %r12
jle 0x346b7
leaq (%r15,%r11), %r14
callq 0x144e0
movq %r12, %r11
movq (%rax), %rax
movq %r15, %rbx
movsbq (%rbx), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x346b7
incq %rbx
cmpq %r14, %rbx
jb 0x346a4
movq %rbx, -0x38(%rbp)
movl $0x1, %eax
subq %r15, %rax
movq %rbx, %rcx
subq %r15, %rcx
movq %rax, %r13
movq %rcx, %r14
leaq (%r15,%r11), %rax
movq %rax, -0x30(%rbp)
cmpq %rax, %rbx
jae 0x346ff
callq 0x144e0
movq %r12, %r11
movq (%rax), %rdx
movsbq -0x1(%r15,%r12), %rsi
decq %r15
leaq 0x1(%r13), %rax
leaq 0x1(%r14), %rcx
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x346c9
movq %r11, %rsi
subq %r14, %rsi
cmpq $0x5, %rsi
movq -0x40(%rbp), %r10
jl 0x347fa
leaq 0x1(%rbx), %rdi
cmpb $0x2d, (%rbx)
jne 0x34764
movb $0x1, 0x20(%r10)
movq %rdi, -0x38(%rbp)
notq %r14
addq %r11, %r14
movq %r14, %rsi
leaq -0x38(%rbp), %rdx
movq %r10, %rcx
callq 0x34a0f
movq -0x40(%rbp), %r10
testl %eax, %eax
jne 0x347fa
movl $0x0, 0x8(%r10)
movq $0x0, (%r10)
movl $0x2, 0x24(%r10)
xorl %eax, %eax
jmp 0x3481b
movb $0x0, 0x20(%r10)
movq -0x30(%rbp), %r14
cmpq %r14, %rdi
jae 0x34788
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x34788
cmpl $0x3a, %eax
je 0x348cf
incq %rdi
jmp 0x3476d
movabsq $0x199999999999999a, %rcx # imm = 0x199999999999999A
xorl %eax, %eax
xorl %edx, %edx
movsbq (%rbx,%rax), %rsi
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
setb %dil
jae 0x347e4
cmpq %rcx, %rdx
jae 0x347e4
leaq (%rdx,%rdx), %rdi
leaq (%rdi,%rdi,4), %rdi
movl $0x2f, %r8d
subq %rsi, %r8
cmpq %r8, %rdi
ja 0x347e1
leaq (%rdi,%rsi), %rdx
addq $-0x30, %rdx
leaq (%rbx,%rax), %rsi
incq %rsi
incq %rax
cmpq %r14, %rsi
jb 0x34796
addq %rbx, %rax
xorl %esi, %esi
jmp 0x347f1
movb $0x1, %dil
testq %rax, %rax
sete %sil
orb %dil, %sil
addq %rbx, %rax
movq %rdx, %rdi
shrq $0x20, %rdi
je 0x3482a
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r10)
movups %xmm0, (%r10)
movq $0x0, 0x20(%r10)
movl $0xffffffff, 0x24(%r10) # imm = 0xFFFFFFFF
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edx, (%r10)
cmpq $0x2710, %rdx # imm = 0x2710
setae %dil
orb %dil, %sil
jne 0x347fa
cmpq %rax, -0x30(%rbp)
je 0x347fa
cmpb $0x2d, (%rax)
jne 0x347fa
movq %rax, %rsi
subq %rbx, %rsi
cmpq $0x2, %rsi
jne 0x3486a
leal 0x7d0(%rdx), %esi
leal 0x76c(%rdx), %edi
cmpq $0x46, %rdx
cmovbl %esi, %edi
movl %edi, (%r10)
movq %r11, %rdx
subq %rax, %rdx
subq %r13, %rdx
testq %rdx, %rdx
jle 0x347fa
incq %rax
xorl %esi, %esi
xorl %edx, %edx
movq -0x30(%rbp), %r14
movsbq (%rax,%rsi), %rdi
leal -0x30(%rdi), %r8d
cmpb $0xa, %r8b
setb %r8b
jae 0x348da
cmpq %rcx, %rdx
jae 0x348da
leaq (%rdx,%rdx), %r8
leaq (%r8,%r8,4), %r8
movl $0x2f, %r9d
subq %rdi, %r9
cmpq %r9, %r8
ja 0x348d7
leaq (%r8,%rdi), %rdx
addq $-0x30, %rdx
leaq (%rax,%rsi), %rdi
incq %rdi
incq %rsi
cmpq %r14, %rdi
jb 0x34883
addq %rsi, %rax
xorl %esi, %esi
jmp 0x348e7
movq %rbx, %rdi
jmp 0x3472e
movb $0x1, %r8b
addq %rsi, %rax
testq %rsi, %rsi
sete %sil
orb %r8b, %sil
movq %rdx, %rdi
shrq $0x20, %rdi
jne 0x347fa
movl %edx, 0x4(%r10)
cmpq $0xd, %rdx
setae %dl
orb %dl, %sil
jne 0x347fa
cmpq %rax, -0x30(%rbp)
je 0x347fa
cmpb $0x2d, (%rax)
jne 0x347fa
movq %r11, %rdx
subq %rax, %rdx
subq %r13, %rdx
testq %rdx, %rdx
jle 0x347fa
incq %rax
xorl %esi, %esi
xorl %edx, %edx
movq -0x30(%rbp), %r14
movsbq (%rax,%rsi), %rdi
leal -0x30(%rdi), %r8d
cmpb $0xa, %r8b
setb %r8b
jae 0x34987
cmpq %rcx, %rdx
jae 0x34987
leaq (%rdx,%rdx), %r8
leaq (%r8,%r8,4), %r8
movl $0x2f, %r9d
subq %rdi, %r9
cmpq %r9, %r8
ja 0x34984
leaq (%r8,%rdi), %rdx
addq $-0x30, %rdx
leaq (%rax,%rsi), %rdi
incq %rdi
incq %rsi
cmpq %r14, %rdi
jb 0x34938
addq %rsi, %rax
xorl %ecx, %ecx
jmp 0x34993
movb $0x1, %r8b
addq %rsi, %rax
testq %rsi, %rsi
sete %cl
orb %r8b, %cl
movl %edx, 0x8(%r10)
movq %rax, -0x38(%rbp)
testb %cl, %cl
jne 0x347fa
cmpq $0x1f, %rdx
ja 0x347fa
cmpq %rax, -0x30(%rbp)
je 0x349f8
cmpb $0x20, (%rax)
jne 0x349f8
leaq 0x1(%rax), %rdi
leaq -0x38(%rbp), %rdx
movq %rdi, (%rdx)
subq %rax, %r11
subq %r13, %r11
movq %r11, %rsi
movq %r10, %rcx
callq 0x34a0f
movq -0x40(%rbp), %r10
testl %eax, %eax
jne 0x347fa
cmpl $0x17, 0xc(%r10)
ja 0x347fa
movl $0x1, 0x24(%r10)
jmp 0x3475d
xorl %eax, %eax
movl %eax, 0x24(%r10)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%r10)
movl %eax, 0x1c(%r10)
jmp 0x3481b
|
str_to_TIME:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r10, rdx
test rdi, rdi
jz loc_347FA
mov r11, rsi
mov r15, rdi
mov rbx, rdi
test rsi, rsi
mov [rbp+var_40], r10
mov r12, rsi
jle short loc_346B7
lea r14, [r15+r11]
call ___ctype_b_loc
mov r11, r12
mov rax, [rax]
mov rbx, r15
loc_346A4:
movsx rcx, byte ptr [rbx]
test byte ptr [rax+rcx*2+1], 20h
jz short loc_346B7
inc rbx
cmp rbx, r14
jb short loc_346A4
loc_346B7:
mov [rbp+var_38], rbx
mov eax, 1
sub rax, r15
mov rcx, rbx
sub rcx, r15
loc_346C9:
mov r13, rax
mov r14, rcx
lea rax, [r15+r11]
mov [rbp+var_30], rax
cmp rbx, rax
jnb short loc_346FF
call ___ctype_b_loc
mov r11, r12
mov rdx, [rax]
movsx rsi, byte ptr [r15+r12-1]
dec r15
lea rax, [r13+1]
lea rcx, [r14+1]
test byte ptr [rdx+rsi*2+1], 20h
jnz short loc_346C9
loc_346FF:
mov rsi, r11
sub rsi, r14
cmp rsi, 5
mov r10, [rbp+var_40]
jl loc_347FA
lea rdi, [rbx+1]
cmp byte ptr [rbx], 2Dh ; '-'
jnz short loc_34764
mov byte ptr [r10+20h], 1
mov [rbp+var_38], rdi
not r14
add r14, r11
mov rsi, r14
loc_3472E:
lea rdx, [rbp+var_38]
mov rcx, r10
call parse_time
mov r10, [rbp+var_40]
test eax, eax
jnz loc_347FA
mov dword ptr [r10+8], 0
mov qword ptr [r10], 0
mov dword ptr [r10+24h], 2
loc_3475D:
xor eax, eax
jmp loc_3481B
loc_34764:
mov byte ptr [r10+20h], 0
mov r14, [rbp+var_30]
loc_3476D:
cmp rdi, r14
jnb short loc_34788
movzx eax, byte ptr [rdi]
cmp eax, 2Dh ; '-'
jz short loc_34788
cmp eax, 3Ah ; ':'
jz loc_348CF
inc rdi
jmp short loc_3476D
loc_34788:
mov rcx, 199999999999999Ah
xor eax, eax
xor edx, edx
loc_34796:
movsx rsi, byte ptr [rbx+rax]
lea edi, [rsi-30h]
cmp dil, 0Ah
setb dil
jnb short loc_347E4
cmp rdx, rcx
jnb short loc_347E4
lea rdi, [rdx+rdx]
lea rdi, [rdi+rdi*4]
mov r8d, 2Fh ; '/'
sub r8, rsi
cmp rdi, r8
ja short loc_347E1
lea rdx, [rdi+rsi]
add rdx, 0FFFFFFFFFFFFFFD0h
lea rsi, [rbx+rax]
inc rsi
inc rax
cmp rsi, r14
jb short loc_34796
add rax, rbx
xor esi, esi
jmp short loc_347F1
loc_347E1:
mov dil, 1
loc_347E4:
test rax, rax
setz sil
or sil, dil
add rax, rbx
loc_347F1:
mov rdi, rdx
shr rdi, 20h
jz short loc_3482A
loc_347FA:
xorps xmm0, xmm0
movups xmmword ptr [r10+10h], xmm0
movups xmmword ptr [r10], xmm0
mov qword ptr [r10+20h], 0
mov dword ptr [r10+24h], 0FFFFFFFFh
mov eax, 1
loc_3481B:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3482A:
mov [r10], edx
cmp rdx, 2710h
setnb dil
or sil, dil
jnz short loc_347FA
cmp [rbp+var_30], rax
jz short loc_347FA
cmp byte ptr [rax], 2Dh ; '-'
jnz short loc_347FA
mov rsi, rax
sub rsi, rbx
cmp rsi, 2
jnz short loc_3486A
lea esi, [rdx+7D0h]
lea edi, [rdx+76Ch]
cmp rdx, 46h ; 'F'
cmovb edi, esi
mov [r10], edi
loc_3486A:
mov rdx, r11
sub rdx, rax
sub rdx, r13
test rdx, rdx
jle short loc_347FA
inc rax
xor esi, esi
xor edx, edx
mov r14, [rbp+var_30]
loc_34883:
movsx rdi, byte ptr [rax+rsi]
lea r8d, [rdi-30h]
cmp r8b, 0Ah
setb r8b
jnb short loc_348DA
cmp rdx, rcx
jnb short loc_348DA
lea r8, [rdx+rdx]
lea r8, [r8+r8*4]
mov r9d, 2Fh ; '/'
sub r9, rdi
cmp r8, r9
ja short loc_348D7
lea rdx, [r8+rdi]
add rdx, 0FFFFFFFFFFFFFFD0h
lea rdi, [rax+rsi]
inc rdi
inc rsi
cmp rdi, r14
jb short loc_34883
add rax, rsi
xor esi, esi
jmp short loc_348E7
loc_348CF:
mov rdi, rbx
jmp loc_3472E
loc_348D7:
mov r8b, 1
loc_348DA:
add rax, rsi
test rsi, rsi
setz sil
or sil, r8b
loc_348E7:
mov rdi, rdx
shr rdi, 20h
jnz loc_347FA
mov [r10+4], edx
cmp rdx, 0Dh
setnb dl
or sil, dl
jnz loc_347FA
cmp [rbp+var_30], rax
jz loc_347FA
cmp byte ptr [rax], 2Dh ; '-'
jnz loc_347FA
mov rdx, r11
sub rdx, rax
sub rdx, r13
test rdx, rdx
jle loc_347FA
inc rax
xor esi, esi
xor edx, edx
mov r14, [rbp+var_30]
loc_34938:
movsx rdi, byte ptr [rax+rsi]
lea r8d, [rdi-30h]
cmp r8b, 0Ah
setb r8b
jnb short loc_34987
cmp rdx, rcx
jnb short loc_34987
lea r8, [rdx+rdx]
lea r8, [r8+r8*4]
mov r9d, 2Fh ; '/'
sub r9, rdi
cmp r8, r9
ja short loc_34984
lea rdx, [r8+rdi]
add rdx, 0FFFFFFFFFFFFFFD0h
lea rdi, [rax+rsi]
inc rdi
inc rsi
cmp rdi, r14
jb short loc_34938
add rax, rsi
xor ecx, ecx
jmp short loc_34993
loc_34984:
mov r8b, 1
loc_34987:
add rax, rsi
test rsi, rsi
setz cl
or cl, r8b
loc_34993:
mov [r10+8], edx
mov [rbp+var_38], rax
test cl, cl
jnz loc_347FA
cmp rdx, 1Fh
ja loc_347FA
cmp [rbp+var_30], rax
jz short loc_349F8
cmp byte ptr [rax], 20h ; ' '
jnz short loc_349F8
lea rdi, [rax+1]
lea rdx, [rbp+var_38]
mov [rdx], rdi
sub r11, rax
sub r11, r13
mov rsi, r11
mov rcx, r10
call parse_time
mov r10, [rbp+var_40]
test eax, eax
jnz loc_347FA
cmp dword ptr [r10+0Ch], 17h
ja loc_347FA
mov dword ptr [r10+24h], 1
jmp loc_3475D
loc_349F8:
xor eax, eax
mov [r10+24h], eax
xorps xmm0, xmm0
movups xmmword ptr [r10+0Ch], xmm0
mov [r10+1Ch], eax
jmp loc_3481B
|
long long str_to_TIME(_BYTE *a1, long long a2, long long a3)
{
long long v3; // r10
long long v4; // r11
_BYTE *v5; // r15
unsigned __int8 *v6; // rbx
long long *v8; // rax
long long v9; // rax
long long v10; // rax
_BYTE *v11; // rcx
long long v12; // r13
signed long long v13; // r14
long long *v14; // rax
long long v15; // rdx
long long v16; // rsi
long long v17; // rsi
unsigned __int8 *v18; // rdi
int v19; // eax
long long result; // rax
int v21; // eax
long long v22; // rax
unsigned long long v23; // rdx
long long v24; // rsi
bool v25; // di
unsigned long long v26; // rsi
unsigned __int8 *v27; // rax
bool v28; // si
int v29; // edi
_BYTE *v30; // rax
long long v31; // rsi
unsigned long long v32; // rdx
long long v33; // rdi
bool v34; // r8
unsigned long long v35; // rdi
unsigned __int8 *v36; // rax
bool v37; // si
_BYTE *v38; // rax
long long v39; // rsi
unsigned long long v40; // rdx
long long v41; // rdi
bool v42; // r8
unsigned long long v43; // rdi
unsigned __int8 *v44; // rax
bool v45; // cl
int v46; // eax
unsigned __int8 *v48; // [rsp+8h] [rbp-38h] BYREF
unsigned __int8 *v49; // [rsp+10h] [rbp-30h]
v3 = a3;
if ( !a1 )
goto LABEL_29;
v4 = a2;
v5 = a1;
v6 = a1;
if ( a2 > 0 )
{
v8 = (long long *)__ctype_b_loc();
v4 = a2;
v9 = *v8;
v6 = a1;
do
{
if ( (*(_BYTE *)(v9 + 2LL * (char)*v6 + 1) & 0x20) == 0 )
break;
++v6;
}
while ( v6 < &a1[a2] );
}
v48 = v6;
v10 = 1LL - (_QWORD)a1;
v11 = (_BYTE *)(v6 - a1);
do
{
v12 = v10;
v13 = (signed long long)v11;
v49 = &v5[v4];
if ( v6 >= &v5[v4] )
break;
v14 = (long long *)__ctype_b_loc();
v4 = a2;
v15 = *v14;
v16 = (char)v5[a2 - 1];
--v5;
v10 = v12 + 1;
v11 = (_BYTE *)(v13 + 1);
}
while ( (*(_BYTE *)(v15 + 2 * v16 + 1) & 0x20) != 0 );
v17 = v4 - v13;
v3 = a3;
if ( v4 - v13 < 5 )
goto LABEL_29;
v18 = v6 + 1;
if ( *v6 == 45 )
{
*(_BYTE *)(a3 + 32) = 1;
v48 = v6 + 1;
v17 = v4 + ~v13;
LABEL_12:
v19 = parse_time(v18, v17, &v48, a3);
v3 = a3;
if ( !v19 )
{
*(_DWORD *)(a3 + 8) = 0;
*(_QWORD *)a3 = 0LL;
*(_DWORD *)(a3 + 36) = 2;
return 0LL;
}
goto LABEL_29;
}
*(_BYTE *)(a3 + 32) = 0;
while ( v18 < v49 )
{
v21 = *v18;
if ( v21 == 45 )
break;
if ( v21 == 58 )
{
v18 = v6;
goto LABEL_12;
}
++v18;
}
v22 = 0LL;
v23 = 0LL;
while ( 1 )
{
v24 = (char)v6[v22];
v25 = (unsigned __int8)(v24 - 48) < 0xAu;
if ( (unsigned __int8)(v24 - 48) >= 0xAu || v23 >= 0x199999999999999ALL )
break;
if ( 10 * v23 > 47 - v24 )
{
v25 = 1;
break;
}
v23 = 10 * v23 + v24 - 48;
v26 = (unsigned long long)&v6[++v22];
if ( v26 >= (unsigned long long)v49 )
{
v27 = &v6[v22];
v28 = 0;
goto LABEL_28;
}
}
v28 = v25 || v22 == 0;
v27 = &v6[v22];
LABEL_28:
if ( HIDWORD(v23) )
goto LABEL_29;
*(_DWORD *)a3 = v23;
if ( v23 >= 0x2710 || v28 || v49 == v27 || *v27 != 45 )
goto LABEL_29;
if ( v27 - v6 == 2 )
{
v29 = v23 + 1900;
if ( v23 < 0x46 )
v29 = v23 + 2000;
*(_DWORD *)a3 = v29;
}
if ( v4 - (long long)v27 - v12 <= 0 )
goto LABEL_29;
v30 = v27 + 1;
v31 = 0LL;
v32 = 0LL;
while ( 1 )
{
v33 = (char)v30[v31];
v34 = (unsigned __int8)(v33 - 48) < 0xAu;
if ( (unsigned __int8)(v33 - 48) >= 0xAu || v32 >= 0x199999999999999ALL )
break;
if ( 10 * v32 > 47 - v33 )
{
v34 = 1;
break;
}
v32 = 10 * v32 + v33 - 48;
v35 = (unsigned long long)&v30[++v31];
if ( v35 >= (unsigned long long)v49 )
{
v36 = &v30[v31];
v37 = 0;
goto LABEL_47;
}
}
v36 = &v30[v31];
v37 = v34 || v31 == 0;
LABEL_47:
if ( HIDWORD(v32) )
goto LABEL_29;
*(_DWORD *)(a3 + 4) = v32;
if ( v32 >= 0xD || v37 || v49 == v36 || *v36 != 45 || v4 - (long long)v36 - v12 <= 0 )
goto LABEL_29;
v38 = v36 + 1;
v39 = 0LL;
v40 = 0LL;
while ( 1 )
{
v41 = (char)v38[v39];
v42 = (unsigned __int8)(v41 - 48) < 0xAu;
if ( (unsigned __int8)(v41 - 48) >= 0xAu || v40 >= 0x199999999999999ALL )
break;
if ( 10 * v40 > 47 - v41 )
{
v42 = 1;
break;
}
v40 = 10 * v40 + v41 - 48;
v43 = (unsigned long long)&v38[++v39];
if ( v43 >= (unsigned long long)v49 )
{
v44 = &v38[v39];
v45 = 0;
goto LABEL_60;
}
}
v44 = &v38[v39];
v45 = v42 || v39 == 0;
LABEL_60:
*(_DWORD *)(a3 + 8) = v40;
v48 = v44;
if ( v45 || v40 > 0x1F )
{
LABEL_29:
*(_OWORD *)(v3 + 16) = 0LL;
*(_OWORD *)v3 = 0LL;
*(_QWORD *)(v3 + 32) = 0LL;
*(_DWORD *)(v3 + 36) = -1;
return 1LL;
}
if ( v49 != v44 && *v44 == 32 )
{
v48 = v44 + 1;
v46 = parse_time(v44 + 1, v4 - (_QWORD)v44 - v12, &v48, a3);
v3 = a3;
if ( !v46 && *(_DWORD *)(a3 + 12) <= 0x17u )
{
*(_DWORD *)(a3 + 36) = 1;
return 0LL;
}
goto LABEL_29;
}
result = 0LL;
*(_DWORD *)(a3 + 36) = 0;
*(_OWORD *)(a3 + 12) = 0LL;
*(_DWORD *)(a3 + 28) = 0;
return result;
}
|
str_to_TIME:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R10,RDX
TEST RDI,RDI
JZ 0x001347fa
MOV R11,RSI
MOV R15,RDI
MOV RBX,RDI
TEST RSI,RSI
MOV qword ptr [RBP + -0x40],R10
MOV R12,RSI
JLE 0x001346b7
LEA R14,[R15 + R11*0x1]
CALL 0x001144e0
MOV R11,R12
MOV RAX,qword ptr [RAX]
MOV RBX,R15
LAB_001346a4:
MOVSX RCX,byte ptr [RBX]
TEST byte ptr [RAX + RCX*0x2 + 0x1],0x20
JZ 0x001346b7
INC RBX
CMP RBX,R14
JC 0x001346a4
LAB_001346b7:
MOV qword ptr [RBP + -0x38],RBX
MOV EAX,0x1
SUB RAX,R15
MOV RCX,RBX
SUB RCX,R15
LAB_001346c9:
MOV R13,RAX
MOV R14,RCX
LEA RAX,[R15 + R11*0x1]
MOV qword ptr [RBP + -0x30],RAX
CMP RBX,RAX
JNC 0x001346ff
CALL 0x001144e0
MOV R11,R12
MOV RDX,qword ptr [RAX]
MOVSX RSI,byte ptr [R15 + R12*0x1 + -0x1]
DEC R15
LEA RAX,[R13 + 0x1]
LEA RCX,[R14 + 0x1]
TEST byte ptr [RDX + RSI*0x2 + 0x1],0x20
JNZ 0x001346c9
LAB_001346ff:
MOV RSI,R11
SUB RSI,R14
CMP RSI,0x5
MOV R10,qword ptr [RBP + -0x40]
JL 0x001347fa
LEA RDI,[RBX + 0x1]
CMP byte ptr [RBX],0x2d
JNZ 0x00134764
MOV byte ptr [R10 + 0x20],0x1
MOV qword ptr [RBP + -0x38],RDI
NOT R14
ADD R14,R11
MOV RSI,R14
LAB_0013472e:
LEA RDX,[RBP + -0x38]
MOV RCX,R10
CALL 0x00134a0f
MOV R10,qword ptr [RBP + -0x40]
TEST EAX,EAX
JNZ 0x001347fa
MOV dword ptr [R10 + 0x8],0x0
MOV qword ptr [R10],0x0
MOV dword ptr [R10 + 0x24],0x2
LAB_0013475d:
XOR EAX,EAX
JMP 0x0013481b
LAB_00134764:
MOV byte ptr [R10 + 0x20],0x0
MOV R14,qword ptr [RBP + -0x30]
LAB_0013476d:
CMP RDI,R14
JNC 0x00134788
MOVZX EAX,byte ptr [RDI]
CMP EAX,0x2d
JZ 0x00134788
CMP EAX,0x3a
JZ 0x001348cf
INC RDI
JMP 0x0013476d
LAB_00134788:
MOV RCX,0x199999999999999a
XOR EAX,EAX
XOR EDX,EDX
LAB_00134796:
MOVSX RSI,byte ptr [RBX + RAX*0x1]
LEA EDI,[RSI + -0x30]
CMP DIL,0xa
SETC DIL
JNC 0x001347e4
CMP RDX,RCX
JNC 0x001347e4
LEA RDI,[RDX + RDX*0x1]
LEA RDI,[RDI + RDI*0x4]
MOV R8D,0x2f
SUB R8,RSI
CMP RDI,R8
JA 0x001347e1
LEA RDX,[RDI + RSI*0x1]
ADD RDX,-0x30
LEA RSI,[RBX + RAX*0x1]
INC RSI
INC RAX
CMP RSI,R14
JC 0x00134796
ADD RAX,RBX
XOR ESI,ESI
JMP 0x001347f1
LAB_001347e1:
MOV DIL,0x1
LAB_001347e4:
TEST RAX,RAX
SETZ SIL
OR SIL,DIL
ADD RAX,RBX
LAB_001347f1:
MOV RDI,RDX
SHR RDI,0x20
JZ 0x0013482a
LAB_001347fa:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R10 + 0x10],XMM0
MOVUPS xmmword ptr [R10],XMM0
MOV qword ptr [R10 + 0x20],0x0
MOV dword ptr [R10 + 0x24],0xffffffff
MOV EAX,0x1
LAB_0013481b:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013482a:
MOV dword ptr [R10],EDX
CMP RDX,0x2710
SETNC DIL
OR SIL,DIL
JNZ 0x001347fa
CMP qword ptr [RBP + -0x30],RAX
JZ 0x001347fa
CMP byte ptr [RAX],0x2d
JNZ 0x001347fa
MOV RSI,RAX
SUB RSI,RBX
CMP RSI,0x2
JNZ 0x0013486a
LEA ESI,[RDX + 0x7d0]
LEA EDI,[RDX + 0x76c]
CMP RDX,0x46
CMOVC EDI,ESI
MOV dword ptr [R10],EDI
LAB_0013486a:
MOV RDX,R11
SUB RDX,RAX
SUB RDX,R13
TEST RDX,RDX
JLE 0x001347fa
INC RAX
XOR ESI,ESI
XOR EDX,EDX
MOV R14,qword ptr [RBP + -0x30]
LAB_00134883:
MOVSX RDI,byte ptr [RAX + RSI*0x1]
LEA R8D,[RDI + -0x30]
CMP R8B,0xa
SETC R8B
JNC 0x001348da
CMP RDX,RCX
JNC 0x001348da
LEA R8,[RDX + RDX*0x1]
LEA R8,[R8 + R8*0x4]
MOV R9D,0x2f
SUB R9,RDI
CMP R8,R9
JA 0x001348d7
LEA RDX,[R8 + RDI*0x1]
ADD RDX,-0x30
LEA RDI,[RAX + RSI*0x1]
INC RDI
INC RSI
CMP RDI,R14
JC 0x00134883
ADD RAX,RSI
XOR ESI,ESI
JMP 0x001348e7
LAB_001348cf:
MOV RDI,RBX
JMP 0x0013472e
LAB_001348d7:
MOV R8B,0x1
LAB_001348da:
ADD RAX,RSI
TEST RSI,RSI
SETZ SIL
OR SIL,R8B
LAB_001348e7:
MOV RDI,RDX
SHR RDI,0x20
JNZ 0x001347fa
MOV dword ptr [R10 + 0x4],EDX
CMP RDX,0xd
SETNC DL
OR SIL,DL
JNZ 0x001347fa
CMP qword ptr [RBP + -0x30],RAX
JZ 0x001347fa
CMP byte ptr [RAX],0x2d
JNZ 0x001347fa
MOV RDX,R11
SUB RDX,RAX
SUB RDX,R13
TEST RDX,RDX
JLE 0x001347fa
INC RAX
XOR ESI,ESI
XOR EDX,EDX
MOV R14,qword ptr [RBP + -0x30]
LAB_00134938:
MOVSX RDI,byte ptr [RAX + RSI*0x1]
LEA R8D,[RDI + -0x30]
CMP R8B,0xa
SETC R8B
JNC 0x00134987
CMP RDX,RCX
JNC 0x00134987
LEA R8,[RDX + RDX*0x1]
LEA R8,[R8 + R8*0x4]
MOV R9D,0x2f
SUB R9,RDI
CMP R8,R9
JA 0x00134984
LEA RDX,[R8 + RDI*0x1]
ADD RDX,-0x30
LEA RDI,[RAX + RSI*0x1]
INC RDI
INC RSI
CMP RDI,R14
JC 0x00134938
ADD RAX,RSI
XOR ECX,ECX
JMP 0x00134993
LAB_00134984:
MOV R8B,0x1
LAB_00134987:
ADD RAX,RSI
TEST RSI,RSI
SETZ CL
OR CL,R8B
LAB_00134993:
MOV dword ptr [R10 + 0x8],EDX
MOV qword ptr [RBP + -0x38],RAX
TEST CL,CL
JNZ 0x001347fa
CMP RDX,0x1f
JA 0x001347fa
CMP qword ptr [RBP + -0x30],RAX
JZ 0x001349f8
CMP byte ptr [RAX],0x20
JNZ 0x001349f8
LEA RDI,[RAX + 0x1]
LEA RDX,[RBP + -0x38]
MOV qword ptr [RDX],RDI
SUB R11,RAX
SUB R11,R13
MOV RSI,R11
MOV RCX,R10
CALL 0x00134a0f
MOV R10,qword ptr [RBP + -0x40]
TEST EAX,EAX
JNZ 0x001347fa
CMP dword ptr [R10 + 0xc],0x17
JA 0x001347fa
MOV dword ptr [R10 + 0x24],0x1
JMP 0x0013475d
LAB_001349f8:
XOR EAX,EAX
MOV dword ptr [R10 + 0x24],EAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R10 + 0xc],XMM0
MOV dword ptr [R10 + 0x1c],EAX
JMP 0x0013481b
|
int8 str_to_TIME(char *param_1,long param_2,int *param_3)
{
char cVar1;
long lVar2;
int iVar3;
ushort **ppuVar4;
long lVar5;
ulong uVar6;
ulong uVar7;
char *pcVar8;
long lVar9;
int iVar10;
char *pcVar11;
bool bVar12;
char *local_40;
char *local_38;
if (param_1 != (char *)0x0) {
pcVar8 = param_1;
if (0 < param_2) {
ppuVar4 = __ctype_b_loc();
do {
if ((*(byte *)((long)*ppuVar4 + (long)*pcVar8 * 2 + 1) & 0x20) == 0) break;
pcVar8 = pcVar8 + 1;
} while (pcVar8 < param_1 + param_2);
}
lVar5 = -(long)param_1;
uVar7 = (long)pcVar8 - (long)param_1;
local_40 = pcVar8;
do {
uVar6 = uVar7;
lVar5 = lVar5 + 1;
local_38 = param_1 + param_2;
if (local_38 <= pcVar8) break;
ppuVar4 = __ctype_b_loc();
pcVar11 = param_1 + param_2 + -1;
param_1 = param_1 + -1;
uVar7 = uVar6 + 1;
} while ((*(byte *)((long)*ppuVar4 + (long)*pcVar11 * 2 + 1) & 0x20) != 0);
lVar9 = param_2 - uVar6;
if (4 < lVar9) {
pcVar11 = pcVar8 + 1;
if (*pcVar8 == '-') {
*(int1 *)(param_3 + 8) = 1;
lVar9 = ~uVar6 + param_2;
pcVar8 = pcVar11;
local_40 = pcVar11;
LAB_0013472e:
iVar3 = parse_time(pcVar8,lVar9,&local_40,param_3);
if (iVar3 == 0) {
param_3[2] = 0;
param_3[0] = 0;
param_3[1] = 0;
param_3[9] = 2;
return 0;
}
}
else {
*(int1 *)(param_3 + 8) = 0;
for (; (pcVar11 < local_38 && (*pcVar11 != '-')); pcVar11 = pcVar11 + 1) {
if (*pcVar11 == ':') goto LAB_0013472e;
}
lVar9 = 0;
uVar7 = 0;
do {
cVar1 = pcVar8[lVar9];
bVar12 = (byte)(cVar1 - 0x30U) < 10;
if ((!bVar12) || (0x1999999999999999 < uVar7)) {
LAB_001347e4:
bVar12 = (bool)(lVar9 == 0 | bVar12);
goto LAB_001347f1;
}
if (0x2fU - (long)cVar1 < uVar7 * 10) {
bVar12 = true;
goto LAB_001347e4;
}
uVar7 = (uVar7 * 10 + (long)cVar1) - 0x30;
lVar2 = lVar9 + 1;
lVar9 = lVar9 + 1;
} while (pcVar8 + lVar2 < local_38);
bVar12 = false;
LAB_001347f1:
pcVar11 = pcVar8 + lVar9;
if (uVar7 >> 0x20 == 0) {
iVar3 = (int)uVar7;
*param_3 = iVar3;
if (((!bVar12 && uVar7 < 10000) && (local_38 != pcVar11)) && (*pcVar11 == '-')) {
if ((long)pcVar11 - (long)pcVar8 == 2) {
iVar10 = iVar3 + 0x76c;
if (uVar7 < 0x46) {
iVar10 = iVar3 + 2000;
}
*param_3 = iVar10;
}
if (param_2 - (long)pcVar11 != lVar5 && -1 < (param_2 - (long)pcVar11) - lVar5) {
lVar9 = 0;
uVar7 = 0;
do {
cVar1 = pcVar11[lVar9 + 1];
bVar12 = (byte)(cVar1 - 0x30U) < 10;
if ((!bVar12) || (0x1999999999999999 < uVar7)) {
LAB_001348da:
bVar12 = (bool)(lVar9 == 0 | bVar12);
goto LAB_001348e7;
}
if (0x2fU - (long)cVar1 < uVar7 * 10) {
bVar12 = true;
goto LAB_001348da;
}
uVar7 = (uVar7 * 10 + (long)cVar1) - 0x30;
lVar2 = lVar9 + 2;
lVar9 = lVar9 + 1;
} while (pcVar11 + lVar2 < local_38);
bVar12 = false;
LAB_001348e7:
pcVar11 = pcVar11 + lVar9 + 1;
if (((uVar7 >> 0x20 == 0) && (param_3[1] = (int)uVar7, !bVar12 && uVar7 < 0xd)) &&
((local_38 != pcVar11 &&
((*pcVar11 == '-' &&
(param_2 - (long)pcVar11 != lVar5 && -1 < (param_2 - (long)pcVar11) - lVar5))))))
{
lVar9 = 0;
uVar7 = 0;
do {
cVar1 = pcVar11[lVar9 + 1];
bVar12 = (byte)(cVar1 - 0x30U) < 10;
if ((!bVar12) || (0x1999999999999999 < uVar7)) {
LAB_00134987:
bVar12 = (bool)(lVar9 == 0 | bVar12);
goto LAB_00134993;
}
if (0x2fU - (long)cVar1 < uVar7 * 10) {
bVar12 = true;
goto LAB_00134987;
}
uVar7 = (uVar7 * 10 + (long)cVar1) - 0x30;
lVar2 = lVar9 + 2;
lVar9 = lVar9 + 1;
} while (pcVar11 + lVar2 < local_38);
bVar12 = false;
LAB_00134993:
pcVar11 = pcVar11 + lVar9 + 1;
param_3[2] = (int)uVar7;
if ((!bVar12) && (uVar7 < 0x20)) {
if ((local_38 == pcVar11) || (*pcVar11 != ' ')) {
param_3[9] = 0;
param_3[3] = 0;
param_3[4] = 0;
param_3[5] = 0;
param_3[6] = 0;
param_3[7] = 0;
return 0;
}
local_40 = pcVar11 + 1;
iVar3 = parse_time(local_40,(param_2 - (long)pcVar11) - lVar5,&local_40,param_3);
if ((iVar3 == 0) && ((uint)param_3[3] < 0x18)) {
param_3[9] = 1;
return 0;
}
}
}
}
}
}
}
}
}
param_3[4] = 0;
param_3[5] = 0;
param_3[6] = 0;
param_3[7] = 0;
param_3[0] = 0;
param_3[1] = 0;
param_3[2] = 0;
param_3[3] = 0;
param_3[8] = 0;
param_3[9] = 0;
param_3[9] = -1;
return 1;
}
|
|
10,888 |
my_uca_alloc_contractions
|
eloqsql/strings/ctype-uca.c
|
static my_bool
my_uca_alloc_contractions(MY_CONTRACTIONS *contractions,
MY_CHARSET_LOADER *loader, size_t n)
{
size_t size= n * sizeof(MY_CONTRACTION);
if (!(contractions->item= (loader->once_alloc)(size)) ||
!(contractions->flags= (char *) (loader->once_alloc)(MY_UCA_CNT_FLAG_SIZE)))
return 1;
memset(contractions->item, 0, size);
memset(contractions->flags, 0, MY_UCA_CNT_FLAG_SIZE);
return 0;
}
|
O0
|
c
|
my_uca_alloc_contractions:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
imulq $0x58, -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
je 0xa36b9
movq -0x18(%rbp), %rax
movl $0x1000, %edi # imm = 0x1000
callq *0x80(%rax)
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0xa36bf
movb $0x1, -0x1(%rbp)
jmp 0xa36ea
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rdx
xorl %esi, %esi
callq 0x37300
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
movl $0x1000, %edx # imm = 0x1000
callq 0x37300
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_uca_alloc_contractions:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
imul rax, [rbp+var_20], 58h ; 'X'
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rax, [rax+80h]
mov rdi, [rbp+var_28]
call rax
mov rcx, [rbp+var_10]
mov [rcx+8], rax
cmp rax, 0
jz short loc_A36B9
mov rax, [rbp+var_18]
mov edi, 1000h
call qword ptr [rax+80h]
mov rcx, [rbp+var_10]
mov [rcx+10h], rax
cmp rax, 0
jnz short loc_A36BF
loc_A36B9:
mov [rbp+var_1], 1
jmp short loc_A36EA
loc_A36BF:
mov rax, [rbp+var_10]
mov rdi, [rax+8]
mov rdx, [rbp+var_28]
xor esi, esi
call _memset
mov rax, [rbp+var_10]
mov rdi, [rax+10h]
xor esi, esi
mov edx, 1000h
call _memset
mov [rbp+var_1], 0
loc_A36EA:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char my_uca_alloc_contractions(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rax
long long v6; // [rsp+8h] [rbp-28h]
v6 = 88 * a3;
v3 = (*(long long ( **)(long long))(a2 + 128))(88 * a3);
*(_QWORD *)(a1 + 8) = v3;
if ( !v3 )
return 1;
v4 = (*(long long ( **)(long long))(a2 + 128))(4096LL);
*(_QWORD *)(a1 + 16) = v4;
if ( !v4 )
return 1;
memset(*(_QWORD *)(a1 + 8), 0LL, v6);
memset(*(_QWORD *)(a1 + 16), 0LL, 4096LL);
return 0;
}
|
my_uca_alloc_contractions:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
IMUL RAX,qword ptr [RBP + -0x20],0x58
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x80]
MOV RDI,qword ptr [RBP + -0x28]
CALL RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x8],RAX
CMP RAX,0x0
JZ 0x001a36b9
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,0x1000
CALL qword ptr [RAX + 0x80]
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JNZ 0x001a36bf
LAB_001a36b9:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001a36ea
LAB_001a36bf:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0x28]
XOR ESI,ESI
CALL 0x00137300
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x10]
XOR ESI,ESI
MOV EDX,0x1000
CALL 0x00137300
MOV byte ptr [RBP + -0x1],0x0
LAB_001a36ea:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 my_uca_alloc_contractions(long param_1,long param_2,long param_3)
{
long lVar1;
lVar1 = (**(code **)(param_2 + 0x80))(param_3 * 0x58);
*(long *)(param_1 + 8) = lVar1;
if (lVar1 != 0) {
lVar1 = (**(code **)(param_2 + 0x80))(0x1000);
*(long *)(param_1 + 0x10) = lVar1;
if (lVar1 != 0) {
memset(*(void **)(param_1 + 8),0,param_3 * 0x58);
memset(*(void **)(param_1 + 0x10),0,0x1000);
return 0;
}
}
return 1;
}
|
|
10,889 |
my_hash_first
|
eloqsql/mysys/hash.c
|
uchar* my_hash_first(const HASH *hash, const uchar *key, size_t length,
HASH_SEARCH_STATE *current_record)
{
uchar *res;
DBUG_ASSERT(my_hash_inited(hash));
res= my_hash_first_from_hash_value(hash,
hash->hash_function(hash->charset, key,
length ? length :
hash->key_length),
key, length, current_record);
return res;
}
|
O0
|
c
|
my_hash_first:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x740ea
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x74123
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x7412f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
callq *%rax
movq -0x48(%rbp), %rdi
movl %eax, %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x741b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_first:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
jmp short $+2
loc_740EA:
mov rax, [rbp+var_8]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+58h]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+68h]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
cmp [rbp+var_18], 0
jz short loc_74123
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
jmp short loc_7412F
loc_74123:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_50], rax
loc_7412F:
mov rax, [rbp+var_40]
mov rsi, [rbp+var_30]
mov rdi, [rbp+var_38]
mov rdx, [rbp+var_50]
call rax
mov rdi, [rbp+var_48]
mov esi, eax
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
call my_hash_first_from_hash_value
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 50h
pop rbp
retn
|
long long my_hash_first(_QWORD *a1, long long a2, long long a3, long long a4)
{
unsigned int v4; // eax
long long ( *v6)(long long, long long, long long); // [rsp+10h] [rbp-40h]
long long v7; // [rsp+18h] [rbp-38h]
v6 = (long long ( *)(long long, long long, long long))a1[11];
v7 = a1[13];
if ( a3 )
v4 = v6(v7, a2, a3);
else
v4 = v6(v7, a2, a1[1]);
return my_hash_first_from_hash_value(a1, v4, a2, a3, a4);
}
|
my_hash_first:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
JMP 0x001740ea
LAB_001740ea:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00174123
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0017412f
LAB_00174123:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x50],RAX
LAB_0017412f:
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x50]
CALL RAX
MOV RDI,qword ptr [RBP + -0x48]
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
CALL 0x001741b0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x50
POP RBP
RET
|
int8 my_hash_first(long param_1,int8 param_2,long param_3,int8 param_4)
{
int4 uVar1;
int8 uVar2;
int8 local_58;
local_58 = param_3;
if (param_3 == 0) {
local_58 = *(long *)(param_1 + 8);
}
uVar1 = (**(code **)(param_1 + 0x58))(*(int8 *)(param_1 + 0x68),param_2,local_58);
uVar2 = my_hash_first_from_hash_value(param_1,uVar1,param_2,param_3,param_4);
return uVar2;
}
|
|
10,890 |
testing::TestPartResult::TestPartResult(testing::TestPartResult&&)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-test-part.h
|
class GTEST_API_ TestPartResult {
public:
// The possible outcomes of a test part (i.e. an assertion or an
// explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
enum Type {
kSuccess, // Succeeded.
kNonFatalFailure, // Failed but the test can continue.
kFatalFailure, // Failed and the test should be terminated.
kSkip // Skipped.
};
// C'tor. TestPartResult does NOT have a default constructor.
// Always use this constructor (with parameters) to create a
// TestPartResult object.
TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {}
// Gets the outcome of the test part.
Type type() const { return type_; }
// Gets the name of the source file where the test part took place, or
// NULL if it's unknown.
const char* file_name() const {
return file_name_.empty() ? nullptr : file_name_.c_str();
}
// Gets the line in the source file where the test part took place,
// or -1 if it's unknown.
int line_number() const { return line_number_; }
// Gets the summary of the failure message.
const char* summary() const { return summary_.c_str(); }
// Gets the message associated with the test part.
const char* message() const { return message_.c_str(); }
// Returns true if and only if the test part was skipped.
bool skipped() const { return type_ == kSkip; }
// Returns true if and only if the test part passed.
bool passed() const { return type_ == kSuccess; }
// Returns true if and only if the test part non-fatally failed.
bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
// Returns true if and only if the test part fatally failed.
bool fatally_failed() const { return type_ == kFatalFailure; }
// Returns true if and only if the test part failed.
bool failed() const { return fatally_failed() || nonfatally_failed(); }
private:
Type type_;
// Gets the summary of the failure message by omitting the stack
// trace in it.
static std::string ExtractSummary(const char* message);
// The name of the source file where the test part took place, or
// "" if the source file is unknown.
std::string file_name_;
// The line in the source file where the test part took place, or -1
// if the line number is unknown.
int line_number_;
std::string summary_; // The test failure summary.
std::string message_; // The test failure message.
}
|
O0
|
c
|
testing::TestPartResult::TestPartResult(testing::TestPartResult&&):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x1f0f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x28(%rdi)
addq $0x30, %rdi
movq 0x8(%rsp), %rsi
addq $0x30, %rsi
callq 0x1f0f0
movq (%rsp), %rdi
addq $0x50, %rdi
movq 0x8(%rsp), %rsi
addq $0x50, %rsi
callq 0x1f0f0
addq $0x18, %rsp
retq
nop
|
_ZN7testing14TestPartResultC2EOS0_:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rdi, [rsp+18h+var_8]
mov [rsp+18h+var_18], rdi
mov rax, [rsp+18h+var_10]
mov eax, [rax]
mov [rdi], eax
add rdi, 8
mov rsi, [rsp+18h+var_10]
add rsi, 8
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
mov rdi, [rsp+18h+var_18]
mov rax, [rsp+18h+var_10]
mov eax, [rax+28h]
mov [rdi+28h], eax
add rdi, 30h ; '0'
mov rsi, [rsp+18h+var_10]
add rsi, 30h ; '0'
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
mov rdi, [rsp+18h+var_18]
add rdi, 50h ; 'P'
mov rsi, [rsp+18h+var_10]
add rsi, 50h ; 'P'
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
add rsp, 18h
retn
|
long long testing::TestPartResult::TestPartResult(_DWORD *a1, _DWORD *a2)
{
*a1 = *a2;
std::string::basic_string((long long)(a1 + 2), (long long)(a2 + 2));
a1[10] = a2[10];
std::string::basic_string((long long)(a1 + 12), (long long)(a2 + 12));
return std::string::basic_string((long long)(a1 + 20), (long long)(a2 + 20));
}
|
_M_init_functor<std::__future_base::_Task_setter<std::unique_ptr<std::__future_base::_Result<void>,std::__future_base::_Result_base::_Deleter>,std::__future_base::_Task_state<std::_Bind<alaya::HNSWBuilder<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>>::build_graph(unsigned_int)::{lambda()#1}()>,std::allocator<int>,void()>::_M_run()::{lambda()#1},void>const&>:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
LAB_0013df38:
CALL 0x0013df70
JMP 0x0013df3f
LAB_0013df3f:
ADD RSP,0x18
RET
|
/* void
std::_Function_base::_Base_manager<std::__future_base::_Task_setter<std::unique_ptr<std::__future_base::_Result<void>,
std::__future_base::_Result_base::_Deleter>,
std::__future_base::_Task_state<std::_Bind<alaya::HNSWBuilder<alaya::RawSpace<float, float,
unsigned int, alaya::SequentialStorage<float, unsigned int> > >::build_graph(unsigned
int)::{lambda()#1} ()>, std::allocator<int>, void ()>::_M_run()::{lambda()#1}, void>
>::_M_init_functor<std::__future_base::_Task_setter<std::unique_ptr<std::__future_base::_Result<void>,
std::__future_base::_Result_base::_Deleter>,
std::__future_base::_Task_state<std::_Bind<alaya::HNSWBuilder<alaya::RawSpace<float, float,
unsigned int, alaya::SequentialStorage<float, unsigned int> > >::build_graph(unsigned
int)::{lambda()#1} ()>, std::allocator<int>, void ()>::_M_run()::{lambda()#1}, void>
const&>(std::_Any_data&,
std::__future_base::_Task_setter<std::unique_ptr<std::__future_base::_Result<void>,
std::__future_base::_Result_base::_Deleter>,
std::__future_base::_Task_state<std::_Bind<alaya::HNSWBuilder<alaya::RawSpace<float, float,
unsigned int, alaya::SequentialStorage<float, unsigned int> > >::build_graph(unsigned
int)::{lambda()#1} ()>, std::allocator<int>, void ()>::_M_run()::{lambda()#1}, void> const&) */
void std::_Function_base::
_Base_manager<std::__future_base::_Task_setter<std::unique_ptr<std::__future_base::_Result<void>,std::__future_base::_Result_base::_Deleter>,std::__future_base::_Task_state<std::_Bind<alaya::HNSWBuilder<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>>::build_graph(unsigned_int)::{lambda()#1}()>,std::allocator<int>,void()>::_M_run()::{lambda()#1},void>>
::
_M_init_functor<std::__future_base::_Task_setter<std::unique_ptr<std::__future_base::_Result<void>,std::__future_base::_Result_base::_Deleter>,std::__future_base::_Task_state<std::_Bind<alaya::HNSWBuilder<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>>::build_graph(unsigned_int)::_lambda()_1_()>,std::allocator<int>,void()>::_M_run()::_lambda()_1_,void>const&>
(_Any_data *param_1,_Task_setter *param_2)
{
/* try { // try from 0013df38 to 0013df3c has its CatchHandler @ 0013df44 */
_M_create<std::__future_base::_Task_setter<std::unique_ptr<std::__future_base::_Result<void>,std::__future_base::_Result_base::_Deleter>,std::__future_base::_Task_state<std::_Bind<alaya::HNSWBuilder<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>>::build_graph(unsigned_int)::_lambda()_1_()>,std::allocator<int>,void()>::_M_run()::_lambda()_1_,void>const&>
(param_1,param_2);
return;
}
|
|
10,891 |
minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/./minja.hpp
|
Value get_named(const std::string & name) {
for (const auto & [key, value] : kwargs) {
if (key == name) return value;
}
return Value();
}
|
O3
|
cpp
|
minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %r13
cmpq %r13, %r14
je 0x726f6
movq (%rdx), %r15
movq 0x8(%rdx), %r12
cmpq %r12, 0x8(%r14)
jne 0x726ed
testq %r12, %r12
je 0x72734
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x186e0
testl %eax, %eax
je 0x72734
addq $0x70, %r14
cmpq %r13, %r14
jne 0x726d0
leaq 0x40(%rbx), %r14
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d970
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d970
jmp 0x72743
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ed98
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
_ZN5minja14ArgumentsValue9get_namedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdi
mov r14, [rsi+18h]
mov r13, [rsi+20h]
cmp r14, r13
jz short loc_726F6
mov r15, [rdx]
mov r12, [rdx+8]
loc_726D0:
cmp [r14+8], r12
jnz short loc_726ED
test r12, r12
jz short loc_72734
mov rdi, [r14]
mov rsi, r15
mov rdx, r12
call _bcmp
test eax, eax
jz short loc_72734
loc_726ED:
add r14, 70h ; 'p'
cmp r14, r13
jnz short loc_726D0
loc_726F6:
lea r14, [rbx+40h]
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_72743
loc_72734:
add r14, 20h ; ' '
mov rdi, rbx; this
mov rsi, r14; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
loc_72743:
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
minja::Value * minja::ArgumentsValue::get_named(minja::Value *this, long long a2, long long *a3)
{
_QWORD *v3; // r14
_QWORD *v4; // r13
long long v5; // r15
long long v6; // r12
v3 = *(_QWORD **)(a2 + 24);
v4 = *(_QWORD **)(a2 + 32);
if ( v3 == v4 )
{
LABEL_7:
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
}
else
{
v5 = *a3;
v6 = a3[1];
while ( v3[1] != v6 || v6 && (unsigned int)bcmp(*v3, v5) )
{
v3 += 14;
if ( v3 == v4 )
goto LABEL_7;
}
minja::Value::Value(this, (const minja::Value *)(v3 + 4));
}
return this;
}
|
get_named:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RSI + 0x18]
MOV R13,qword ptr [RSI + 0x20]
CMP R14,R13
JZ 0x001726f6
MOV R15,qword ptr [RDX]
MOV R12,qword ptr [RDX + 0x8]
LAB_001726d0:
CMP qword ptr [R14 + 0x8],R12
JNZ 0x001726ed
TEST R12,R12
JZ 0x00172734
MOV RDI,qword ptr [R14]
MOV RSI,R15
MOV RDX,R12
CALL 0x001186e0
TEST EAX,EAX
JZ 0x00172734
LAB_001726ed:
ADD R14,0x70
CMP R14,R13
JNZ 0x001726d0
LAB_001726f6:
LEA R14,[RBX + 0x40]
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d970
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d970
JMP 0x00172743
LAB_00172734:
ADD R14,0x20
MOV RDI,RBX
MOV RSI,R14
CALL 0x0014ed98
LAB_00172743:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* minja::ArgumentsValue::get_named(std::__cxx11::string const&) */
string * minja::ArgumentsValue::get_named(string *param_1)
{
int8 *puVar1;
void *__s2;
size_t __n;
int iVar2;
int8 *in_RDX;
long in_RSI;
bool bVar3;
int8 *puVar4;
puVar4 = *(int8 **)(in_RSI + 0x18);
puVar1 = *(int8 **)(in_RSI + 0x20);
if (puVar4 != puVar1) {
__s2 = (void *)*in_RDX;
__n = in_RDX[1];
do {
if ((puVar4[1] == __n) && ((__n == 0 || (iVar2 = bcmp((void *)*puVar4,__s2,__n), iVar2 == 0)))
) {
minja::Value::Value((Value *)param_1,(Value *)(puVar4 + 4));
return param_1;
}
puVar4 = puVar4 + 0xe;
} while (puVar4 != puVar1);
}
bVar3 = (bool)((char)param_1 + '@');
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (string)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar3);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar3);
return param_1;
}
|
|
10,892 |
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;
}
|
O3
|
c
|
my_strxfrm_pad_nweights_unicode:
cmpq %rsi, %rdi
setae %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movq %rdi, %rax
jne 0xcc579
pushq %rbp
movq %rsp, %rbp
decq %rdx
movq %rdi, %rcx
leaq 0x1(%rcx), %rax
movb $0x0, (%rcx)
cmpq %rsi, %rax
jae 0xcc563
movb $0x20, 0x1(%rcx)
addq $0x2, %rcx
movq %rcx, %rax
addq $-0x1, %rdx
setb %r8b
cmpq %rsi, %rax
jae 0xcc578
movq %rax, %rcx
testb %r8b, %r8b
jne 0xcc54c
popq %rbp
subq %rdi, %rax
retq
|
my_strxfrm_pad_nweights_unicode:
cmp rdi, rsi
setnb al
test rdx, rdx
setz cl
or cl, al
mov rax, rdi
jnz short loc_CC579
push rbp
mov rbp, rsp
dec rdx
mov rcx, rdi
loc_CC54C:
lea rax, [rcx+1]
mov byte ptr [rcx], 0
cmp rax, rsi
jnb short loc_CC563
mov byte ptr [rcx+1], 20h ; ' '
add rcx, 2
mov rax, rcx
loc_CC563:
add rdx, 0FFFFFFFFFFFFFFFFh
setb r8b
cmp rax, rsi
jnb short loc_CC578
mov rcx, rax
test r8b, r8b
jnz short loc_CC54C
loc_CC578:
pop rbp
loc_CC579:
sub rax, rdi
retn
|
long long my_strxfrm_pad_nweights_unicode(_BYTE *a1, unsigned long long a2, long long a3)
{
_BYTE *v3; // rax
long long v4; // rdx
_BYTE *v5; // rcx
bool v6; // cf
v3 = a1;
if ( (unsigned long long)a1 < a2 && a3 != 0 )
{
v4 = a3 - 1;
v5 = a1;
do
{
v3 = v5 + 1;
*v5 = 0;
if ( (unsigned long long)(v5 + 1) < a2 )
{
v5[1] = 32;
v3 = v5 + 2;
}
v6 = v4-- != 0;
if ( (unsigned long long)v3 >= a2 )
break;
v5 = v3;
}
while ( v6 );
}
return v3 - a1;
}
|
my_strxfrm_pad_nweights_unicode:
CMP RDI,RSI
SETNC AL
TEST RDX,RDX
SETZ CL
OR CL,AL
MOV RAX,RDI
JNZ 0x001cc579
PUSH RBP
MOV RBP,RSP
DEC RDX
MOV RCX,RDI
LAB_001cc54c:
LEA RAX,[RCX + 0x1]
MOV byte ptr [RCX],0x0
CMP RAX,RSI
JNC 0x001cc563
MOV byte ptr [RCX + 0x1],0x20
ADD RCX,0x2
MOV RAX,RCX
LAB_001cc563:
ADD RDX,-0x1
SETC R8B
CMP RAX,RSI
JNC 0x001cc578
MOV RCX,RAX
TEST R8B,R8B
JNZ 0x001cc54c
LAB_001cc578:
POP RBP
LAB_001cc579:
SUB RAX,RDI
RET
|
long my_strxfrm_pad_nweights_unicode(int1 *param_1,int1 *param_2,long param_3)
{
int1 *puVar1;
int1 *puVar2;
bool bVar3;
puVar2 = param_1;
if (param_3 != 0 && param_1 < param_2) {
param_3 = param_3 + -1;
puVar1 = param_1;
do {
puVar2 = puVar1 + 1;
*puVar1 = 0;
if (puVar2 < param_2) {
puVar1[1] = 0x20;
puVar2 = puVar1 + 2;
}
bVar3 = param_3 != 0;
param_3 = param_3 + -1;
} while ((puVar2 < param_2) && (puVar1 = puVar2, bVar3));
}
return (long)puVar2 - (long)param_1;
}
|
|
10,893 |
my_hash_init2
|
eloqsql/mysys/hash.c
|
my_bool
my_hash_init2(PSI_memory_key psi_key, HASH *hash, uint growth_size,
CHARSET_INFO *charset, ulong size, size_t key_offset,
size_t key_length, my_hash_get_key get_key,
my_hash_function hash_function,
void (*free_element)(void*), uint flags)
{
my_bool res;
DBUG_ENTER("my_hash_init2");
DBUG_PRINT("enter",("hash:%p size: %u", hash, (uint) size));
hash->records=0;
hash->key_offset=key_offset;
hash->key_length=key_length;
hash->blength=1;
hash->get_key=get_key;
hash->hash_function= hash_function ? hash_function : my_hash_sort;
hash->free=free_element;
hash->flags=flags;
hash->charset=charset;
res= init_dynamic_array2(psi_key, &hash->array, sizeof(HASH_LINK), NULL, size,
growth_size, MYF((flags & HASH_THREAD_SPECIFIC ?
MY_THREAD_SPECIFIC : 0)));
DBUG_RETURN(res);
}
|
O3
|
c
|
my_hash_init2:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %eax
movl 0x30(%rbp), %edx
movq 0x28(%rbp), %r10
movq 0x20(%rbp), %r11
movq 0x18(%rbp), %rbx
movq 0x10(%rbp), %r14
movq $0x0, 0x18(%rsi)
movq %r9, (%rsi)
movq %r14, 0x8(%rsi)
movq $0x1, 0x10(%rsi)
movq %rbx, 0x50(%rsi)
testq %r11, %r11
jne 0x297c0
leaq -0x7c(%rip), %r11 # 0x29744
movq %r11, 0x58(%rsi)
movq %r10, 0x60(%rsi)
movl %edx, 0x20(%rsi)
movq %rcx, 0x68(%rsi)
addq $0x28, %rsi
andl $0x2, %edx
shll $0xf, %edx
movq %rdx, (%rsp)
movl $0x10, %edx
xorl %ecx, %ecx
movl %eax, %r9d
callq 0x2c424
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
my_hash_init2:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov eax, edx
mov edx, [rbp+arg_20]
mov r10, [rbp+arg_18]
mov r11, [rbp+arg_10]
mov rbx, [rbp+arg_8]
mov r14, [rbp+arg_0]
mov qword ptr [rsi+18h], 0
mov [rsi], r9
mov [rsi+8], r14
mov qword ptr [rsi+10h], 1
mov [rsi+50h], rbx
test r11, r11
jnz short loc_297C0
lea r11, my_hash_sort
loc_297C0:
mov [rsi+58h], r11
mov [rsi+60h], r10
mov [rsi+20h], edx
mov [rsi+68h], rcx
add rsi, 28h ; '('
and edx, 2
shl edx, 0Fh
mov [rsp+20h+var_20], rdx
mov edx, 10h
xor ecx, ecx
mov r9d, eax
call init_dynamic_array2
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
|
long long my_hash_init2(
int a1,
long long a2,
int a3,
long long a4,
int a5,
long long a6,
long long a7,
long long a8,
long long ( *a9)(long long a1, long long a2, long long a3),
long long a10,
int a11)
{
long long ( *v11)(long long, long long, long long); // r11
v11 = a9;
*(_QWORD *)(a2 + 24) = 0LL;
*(_QWORD *)a2 = a6;
*(_QWORD *)(a2 + 8) = a7;
*(_QWORD *)(a2 + 16) = 1LL;
*(_QWORD *)(a2 + 80) = a8;
if ( !a9 )
v11 = my_hash_sort;
*(_QWORD *)(a2 + 88) = v11;
*(_QWORD *)(a2 + 96) = a10;
*(_DWORD *)(a2 + 32) = a11;
*(_QWORD *)(a2 + 104) = a4;
return init_dynamic_array2(a1, (int)a2 + 40, 16, 0, a5, a3, (unsigned __int8)(a11 & 2) << 15);
}
|
my_hash_init2:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EAX,EDX
MOV EDX,dword ptr [RBP + 0x30]
MOV R10,qword ptr [RBP + 0x28]
MOV R11,qword ptr [RBP + 0x20]
MOV RBX,qword ptr [RBP + 0x18]
MOV R14,qword ptr [RBP + 0x10]
MOV qword ptr [RSI + 0x18],0x0
MOV qword ptr [RSI],R9
MOV qword ptr [RSI + 0x8],R14
MOV qword ptr [RSI + 0x10],0x1
MOV qword ptr [RSI + 0x50],RBX
TEST R11,R11
JNZ 0x001297c0
LEA R11,[0x129744]
LAB_001297c0:
MOV qword ptr [RSI + 0x58],R11
MOV qword ptr [RSI + 0x60],R10
MOV dword ptr [RSI + 0x20],EDX
MOV qword ptr [RSI + 0x68],RCX
ADD RSI,0x28
AND EDX,0x2
SHL EDX,0xf
MOV qword ptr [RSP],RDX
MOV EDX,0x10
XOR ECX,ECX
MOV R9D,EAX
CALL 0x0012c424
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
void my_hash_init2(int8 param_1,int8 *param_2,int4 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
code *param_9,int8 param_10,uint param_11)
{
param_2[3] = 0;
*param_2 = param_6;
param_2[1] = param_7;
param_2[2] = 1;
param_2[10] = param_8;
if (param_9 == (code *)0x0) {
param_9 = my_hash_sort;
}
param_2[0xb] = param_9;
param_2[0xc] = param_10;
*(uint *)(param_2 + 4) = param_11;
param_2[0xd] = param_4;
init_dynamic_array2(param_1,param_2 + 5,0x10,0,param_5,param_3,(param_11 & 2) << 0xf);
return;
}
|
|
10,894 |
my_string_repertoire
|
eloqsql/strings/ctype.c
|
my_repertoire_t
my_string_repertoire(CHARSET_INFO *cs, const char *str, size_t length)
{
if (cs->mbminlen == 1 && !(cs->state & MY_CS_NONASCII))
{
return my_string_repertoire_8bit(cs, str, length);
}
else
{
const char *strend= str + length;
my_wc_t wc;
int chlen;
for (;
(chlen= my_ci_mb_wc(cs, &wc, (uchar*) str, (uchar*) strend)) > 0;
str+= chlen)
{
if (wc > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
}
return MY_REPERTOIRE_ASCII;
}
|
O3
|
c
|
my_string_repertoire:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x1, 0x98(%rdi)
jne 0x54d3f
testb $0x20, 0xd(%r15)
jne 0x54d3f
movl $0x1, %eax
testq %rbx, %rbx
jle 0x54da5
addq %r14, %rbx
cmpb $0x0, (%r14)
js 0x54db2
incq %r14
cmpq %rbx, %r14
jb 0x54d2f
jmp 0x54da5
addq %r14, %rbx
movq 0xb8(%r15), %rax
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
testl %eax, %eax
setg %cl
jle 0x54d9b
cmpq $0x7f, -0x28(%rbp)
ja 0x54d9b
leaq -0x28(%rbp), %r12
movq %r14, %rcx
movl %eax, %r14d
addq %rcx, %r14
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
testl %eax, %eax
setg %cl
jle 0x54d9b
cmpq $0x80, -0x28(%rbp)
jb 0x54d6b
movzbl %cl, %eax
leal 0x1(,%rax,2), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x3, %eax
jmp 0x54da5
|
my_string_repertoire:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
cmp dword ptr [rdi+98h], 1
jnz short loc_54D3F
test byte ptr [r15+0Dh], 20h
jnz short loc_54D3F
mov eax, 1
test rbx, rbx
jle short loc_54DA5
add rbx, r14
loc_54D2F:
cmp byte ptr [r14], 0
js short loc_54DB2
inc r14
cmp r14, rbx
jb short loc_54D2F
jmp short loc_54DA5
loc_54D3F:
add rbx, r14
mov rax, [r15+0B8h]
lea rsi, [rbp+var_28]
mov rdi, r15
mov rdx, r14
mov rcx, rbx
call qword ptr [rax+28h]
test eax, eax
setnle cl
jle short loc_54D9B
cmp [rbp+var_28], 7Fh
ja short loc_54D9B
lea r12, [rbp+var_28]
loc_54D6B:
mov rcx, r14
mov r14d, eax
add r14, rcx
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r12
mov rdx, r14
mov rcx, rbx
call qword ptr [rax+28h]
test eax, eax
setnle cl
jle short loc_54D9B
cmp [rbp+var_28], 80h
jb short loc_54D6B
loc_54D9B:
movzx eax, cl
lea eax, ds:1[rax*2]
loc_54DA5:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_54DB2:
mov eax, 3
jmp short loc_54DA5
|
long long my_string_repertoire(long long a1, char *a2, long long a3)
{
char *v3; // r14
long long result; // rax
char *v5; // rbx
int v6; // eax
bool v7; // cl
_QWORD v8[5]; // [rsp+8h] [rbp-28h] BYREF
v3 = a2;
if ( *(_DWORD *)(a1 + 152) != 1 || (*(_BYTE *)(a1 + 13) & 0x20) != 0 )
{
v5 = &a2[a3];
v6 = (*(long long ( **)(long long, _QWORD *, char *, char *))(*(_QWORD *)(a1 + 184) + 40LL))(
a1,
v8,
a2,
&a2[a3]);
v7 = v6 > 0;
if ( v6 > 0 && v8[0] <= 0x7FuLL )
{
do
{
v3 += (unsigned int)v6;
v6 = (*(long long ( **)(long long, _QWORD *, char *, char *))(*(_QWORD *)(a1 + 184) + 40LL))(
a1,
v8,
v3,
v5);
v7 = v6 > 0;
}
while ( v6 > 0 && v8[0] < 0x80uLL );
}
return 2 * (unsigned int)v7 + 1;
}
else
{
result = 1LL;
if ( a3 > 0 )
{
while ( *v3 >= 0 )
{
if ( ++v3 >= &a2[a3] )
return result;
}
return 3LL;
}
}
return result;
}
|
my_string_repertoire:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
CMP dword ptr [RDI + 0x98],0x1
JNZ 0x00154d3f
TEST byte ptr [R15 + 0xd],0x20
JNZ 0x00154d3f
MOV EAX,0x1
TEST RBX,RBX
JLE 0x00154da5
ADD RBX,R14
LAB_00154d2f:
CMP byte ptr [R14],0x0
JS 0x00154db2
INC R14
CMP R14,RBX
JC 0x00154d2f
JMP 0x00154da5
LAB_00154d3f:
ADD RBX,R14
MOV RAX,qword ptr [R15 + 0xb8]
LEA RSI,[RBP + -0x28]
MOV RDI,R15
MOV RDX,R14
MOV RCX,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
SETG CL
JLE 0x00154d9b
CMP qword ptr [RBP + -0x28],0x7f
JA 0x00154d9b
LEA R12,[RBP + -0x28]
LAB_00154d6b:
MOV RCX,R14
MOV R14D,EAX
ADD R14,RCX
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
MOV RCX,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
SETG CL
JLE 0x00154d9b
CMP qword ptr [RBP + -0x28],0x80
JC 0x00154d6b
LAB_00154d9b:
MOVZX EAX,CL
LEA EAX,[0x1 + RAX*0x2]
LAB_00154da5:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00154db2:
MOV EAX,0x3
JMP 0x00154da5
|
char my_string_repertoire(long param_1,char *param_2,long param_3)
{
char cVar1;
uint uVar2;
bool bVar3;
char *pcVar4;
ulong local_30;
if ((*(int *)(param_1 + 0x98) == 1) && ((*(byte *)(param_1 + 0xd) & 0x20) == 0)) {
cVar1 = '\x01';
if (0 < param_3) {
pcVar4 = param_2 + param_3;
do {
if (*param_2 < '\0') {
return '\x03';
}
param_2 = param_2 + 1;
} while (param_2 < pcVar4);
}
}
else {
pcVar4 = param_2 + param_3;
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x28))(param_1,&local_30,param_2,pcVar4);
bVar3 = 0 < (int)uVar2;
if ((0 < (int)uVar2) && (local_30 < 0x80)) {
do {
param_2 = param_2 + uVar2;
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x28))(param_1,&local_30,param_2,pcVar4);
bVar3 = 0 < (int)uVar2;
if ((int)uVar2 < 1) break;
} while (local_30 < 0x80);
}
cVar1 = bVar3 * '\x02' + '\x01';
}
return cVar1;
}
|
|
10,895 |
thr_lock_delete
|
eloqsql/mysys/thr_lock.c
|
void thr_lock_delete(THR_LOCK *lock)
{
DBUG_ENTER("thr_lock_delete");
mysql_mutex_lock(&THR_LOCK_lock);
thr_lock_thread_list=list_delete(thr_lock_thread_list,&lock->list);
mysql_mutex_unlock(&THR_LOCK_lock);
mysql_mutex_destroy(&lock->mutex);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
thr_lock_delete:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb66831(%rip), %r14 # 0xc0a2b8
cmpq $0x0, 0x40(%r14)
jne 0xa3af8
leaq 0xb66823(%rip), %rdi # 0xc0a2b8
callq 0x29200
leaq 0xb66ac7(%rip), %r15 # 0xc0a568
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x95a48
movq %rax, (%r15)
movq 0x40(%r14), %rdi
testq %rdi, %rdi
jne 0xa3aff
leaq 0xb667f9(%rip), %rdi # 0xc0a2b8
callq 0x291c0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xa3ae2
leaq 0x2e453c(%rip), %rax # 0x388010
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x58(%rbx)
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x290c0
callq 0x2f1db
jmp 0xa3a9a
leaq 0x2e450a(%rip), %rax # 0x388010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0xa3ab8
|
thr_lock_delete:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
lea r14, THR_LOCK_lock
cmp qword ptr [r14+40h], 0
jnz short loc_A3AF8
lea rdi, THR_LOCK_lock
call _pthread_mutex_lock
loc_A3A9A:
lea r15, thr_lock_thread_list
mov rdi, [r15]
mov rsi, rbx
call list_delete
mov [r15], rax
mov rdi, [r14+40h]
test rdi, rdi
jnz short loc_A3AFF
loc_A3AB8:
lea rdi, THR_LOCK_lock
call _pthread_mutex_unlock
mov rdi, [rbx+58h]
test rdi, rdi
jz short loc_A3AE2
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+58h], 0
loc_A3AE2:
add rbx, 18h
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _pthread_mutex_destroy
loc_A3AF8:
call thr_lock_delete_cold_1
jmp short loc_A3A9A
loc_A3AFF:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_A3AB8
|
long long thr_lock_delete(_QWORD *a1)
{
long long v2; // rdi
long long v3; // rdi
if ( THR_LOCK_lock[8] )
thr_lock_delete_cold_1(a1);
else
pthread_mutex_lock(THR_LOCK_lock);
thr_lock_thread_list = list_delete(thr_lock_thread_list, a1);
v2 = THR_LOCK_lock[8];
if ( v2 )
((void ( *)(long long))PSI_server[44])(v2);
pthread_mutex_unlock(THR_LOCK_lock);
v3 = a1[11];
if ( v3 )
{
((void ( *)(long long))PSI_server[9])(v3);
a1[11] = 0LL;
}
return pthread_mutex_destroy(a1 + 3);
}
|
thr_lock_delete:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R14,[0xd0a2b8]
CMP qword ptr [R14 + 0x40],0x0
JNZ 0x001a3af8
LEA RDI,[0xd0a2b8]
CALL 0x00129200
LAB_001a3a9a:
LEA R15,[0xd0a568]
MOV RDI,qword ptr [R15]
MOV RSI,RBX
CALL 0x00195a48
MOV qword ptr [R15],RAX
MOV RDI,qword ptr [R14 + 0x40]
TEST RDI,RDI
JNZ 0x001a3aff
LAB_001a3ab8:
LEA RDI,[0xd0a2b8]
CALL 0x001291c0
MOV RDI,qword ptr [RBX + 0x58]
TEST RDI,RDI
JZ 0x001a3ae2
LEA RAX,[0x488010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x58],0x0
LAB_001a3ae2:
ADD RBX,0x18
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001290c0
LAB_001a3af8:
CALL 0x0012f1db
JMP 0x001a3a9a
LAB_001a3aff:
LEA RAX,[0x488010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001a3ab8
|
void thr_lock_delete(long param_1)
{
if (THR_LOCK_lock._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_lock);
}
else {
thr_lock_delete_cold_1();
}
thr_lock_thread_list = list_delete(thr_lock_thread_list,param_1);
if (THR_LOCK_lock._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_lock);
if (*(long *)(param_1 + 0x58) != 0) {
(**(code **)(PSI_server + 0x48))();
*(int8 *)(param_1 + 0x58) = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x18));
return;
}
|
|
10,896 |
Gtid_log_event::Gtid_log_event(unsigned char const*, unsigned int, Format_description_log_event const*)
|
eloqsql/sql/log_event.cc
|
Gtid_log_event::Gtid_log_event(const uchar *buf, uint event_len,
const Format_description_log_event
*description_event)
: Log_event(buf, description_event), seq_no(0), commit_id(0),
flags_extra(0), extra_engines(0)
{
uint8 header_size= description_event->common_header_len;
uint8 post_header_len= description_event->post_header_len[GTID_EVENT-1];
const uchar *buf_0= buf;
if (event_len < (uint) header_size + (uint) post_header_len ||
post_header_len < GTID_HEADER_LEN)
return;
buf+= header_size;
seq_no= uint8korr(buf);
buf+= 8;
domain_id= uint4korr(buf);
buf+= 4;
flags2= *(buf++);
if (flags2 & FL_GROUP_COMMIT_ID)
{
if (event_len < (uint)header_size + GTID_HEADER_LEN + 2)
{
seq_no= 0; // So is_valid() returns false
return;
}
commit_id= uint8korr(buf);
buf+= 8;
}
if (flags2 & (FL_PREPARED_XA | FL_COMPLETED_XA))
{
xid.formatID= uint4korr(buf);
buf+= 4;
xid.gtrid_length= (long) buf[0];
xid.bqual_length= (long) buf[1];
buf+= 2;
long data_length= xid.bqual_length + xid.gtrid_length;
memcpy(xid.data, buf, data_length);
buf+= data_length;
}
/* the extra flags check and actions */
if (static_cast<uint>(buf - buf_0) < event_len)
{
flags_extra= *buf++;
/*
extra engines flags presence is identifed by non-zero byte value
at this point
*/
if (flags_extra & FL_EXTRA_MULTI_ENGINE)
{
DBUG_ASSERT(static_cast<uint>(buf - buf_0) < event_len);
extra_engines= *buf++;
DBUG_ASSERT(extra_engines > 0);
}
}
/*
the strict '<' part of the assert corresponds to extra zero-padded
trailing bytes,
*/
DBUG_ASSERT(static_cast<uint>(buf - buf_0) <= event_len);
/* and the last of them is tested. */
#ifdef MYSQL_SERVER
#ifdef WITH_WSREP
if (!WSREP_ON)
#endif
#endif
DBUG_ASSERT(static_cast<uint>(buf - buf_0) == event_len ||
buf_0[event_len - 1] == 0);
}
|
O0
|
cpp
|
Gtid_log_event::Gtid_log_event(unsigned char const*, unsigned int, Format_description_log_event const*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4b9e0
movq -0x40(%rbp), %rax
leaq 0x22a9a9(%rip), %rcx # 0x2799e0
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x90(%rax)
movq $0x0, 0x98(%rax)
movl $0x0, 0x274(%rax)
movb $0x0, 0x278(%rax)
movq -0x20(%rbp), %rax
movb 0xcd(%rax), %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq 0xd0(%rax), %rax
movb 0xa1(%rax), %al
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movzbl -0x21(%rbp), %ecx
movzbl -0x22(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jb 0x4f0a8
movzbl -0x22(%rbp), %eax
cmpl $0x13, %eax
jge 0x4f0ad
jmp 0x4f25e
movq -0x40(%rbp), %rax
movzbl -0x21(%rbp), %edx
movq -0x10(%rbp), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0xa0(%rax)
movq -0x10(%rbp), %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb (%rcx), %cl
movb %cl, 0x270(%rax)
movzbl 0x270(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4f15e
movl -0x14(%rbp), %eax
movzbl -0x21(%rbp), %ecx
addl $0x13, %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jae 0x4f140
movq -0x40(%rbp), %rax
movq $0x0, 0x90(%rax)
jmp 0x4f25e
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movzbl 0x270(%rax), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x4f1ef
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, 0xa8(%rdi)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, 0xb0(%rdi)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movq %rax, 0xb8(%rdi)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq 0xb8(%rdi), %rax
addq 0xb0(%rdi), %rax
movq %rax, -0x38(%rbp)
addq $0xa8, %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x3b0c0
movq -0x38(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
cmpl -0x14(%rbp), %eax
jae 0x4f252
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movzbl (%rcx), %ecx
movl %ecx, 0x274(%rax)
movl 0x274(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4f250
jmp 0x4f22b
jmp 0x4f22d
jmp 0x4f22f
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb (%rcx), %cl
movb %cl, 0x278(%rax)
jmp 0x4f24c
jmp 0x4f24e
jmp 0x4f250
jmp 0x4f252
jmp 0x4f254
jmp 0x4f256
jmp 0x4f258
jmp 0x4f25a
jmp 0x4f25c
jmp 0x4f25e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN14Gtid_log_eventC2EPKhjPK28Format_description_log_event:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov rdi, [rbp+var_8]; this
mov [rbp+var_40], rdi
mov rsi, [rbp+var_10]; unsigned __int8 *
mov rdx, [rbp+var_20]; Format_description_log_event *
call _ZN9Log_eventC2EPKhPK28Format_description_log_event; Log_event::Log_event(uchar const*,Format_description_log_event const*)
mov rax, [rbp+var_40]
lea rcx, _ZTV14Gtid_log_event; `vtable for'Gtid_log_event
add rcx, 10h
mov [rax], rcx
mov qword ptr [rax+90h], 0
mov qword ptr [rax+98h], 0
mov dword ptr [rax+274h], 0
mov byte ptr [rax+278h], 0
mov rax, [rbp+var_20]
mov al, [rax+0CDh]
mov [rbp+var_21], al
mov rax, [rbp+var_20]
mov rax, [rax+0D0h]
mov al, [rax+0A1h]
mov [rbp+var_22], al
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
mov eax, [rbp+var_14]
movzx ecx, [rbp+var_21]
movzx edx, [rbp+var_22]
add ecx, edx
cmp eax, ecx
jb short loc_4F0A8
movzx eax, [rbp+var_22]
cmp eax, 13h
jge short loc_4F0AD
loc_4F0A8:
jmp loc_4F25E
loc_4F0AD:
mov rax, [rbp+var_40]
movzx edx, [rbp+var_21]
mov rcx, [rbp+var_10]
movsxd rdx, edx
add rcx, rdx
mov [rbp+var_10], rcx
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov [rax+90h], rcx
mov rcx, [rbp+var_10]
add rcx, 8
mov [rbp+var_10], rcx
mov rcx, [rbp+var_10]
mov ecx, [rcx]
mov [rax+0A0h], ecx
mov rcx, [rbp+var_10]
add rcx, 4
mov [rbp+var_10], rcx
mov rcx, [rbp+var_10]
mov rdx, rcx
add rdx, 1
mov [rbp+var_10], rdx
mov cl, [rcx]
mov [rax+270h], cl
movzx eax, byte ptr [rax+270h]
and eax, 2
cmp eax, 0
jz short loc_4F15E
mov eax, [rbp+var_14]
movzx ecx, [rbp+var_21]
add ecx, 13h
add ecx, 2
cmp eax, ecx
jnb short loc_4F140
mov rax, [rbp+var_40]
mov qword ptr [rax+90h], 0
jmp loc_4F25E
loc_4F140:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov [rax+98h], rcx
mov rax, [rbp+var_10]
add rax, 8
mov [rbp+var_10], rax
loc_4F15E:
mov rax, [rbp+var_40]
movzx eax, byte ptr [rax+270h]
and eax, 0C0h
cmp eax, 0
jz short loc_4F1EF
mov rdi, [rbp+var_40]
mov rax, [rbp+var_10]
mov eax, [rax]
mov [rdi+0A8h], rax
mov rax, [rbp+var_10]
add rax, 4
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
mov [rdi+0B0h], rax
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
mov [rdi+0B8h], rax
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
mov rax, [rdi+0B8h]
add rax, [rdi+0B0h]
mov [rbp+var_38], rax
add rdi, 0A8h
add rdi, 18h
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_38]
call _memcpy
mov rax, [rbp+var_38]
add rax, [rbp+var_10]
mov [rbp+var_10], rax
loc_4F1EF:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_30]
sub rax, rcx
cmp eax, [rbp+var_14]
jnb short loc_4F252
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rdx, rcx
add rdx, 1
mov [rbp+var_10], rdx
movzx ecx, byte ptr [rcx]
mov [rax+274h], ecx
mov eax, [rax+274h]
and eax, 1
cmp eax, 0
jz short loc_4F250
jmp short $+2
loc_4F22B:
jmp short $+2
loc_4F22D:
jmp short $+2
loc_4F22F:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rdx, rcx
add rdx, 1
mov [rbp+var_10], rdx
mov cl, [rcx]
mov [rax+278h], cl
jmp short $+2
loc_4F24C:
jmp short $+2
loc_4F24E:
jmp short $+2
loc_4F250:
jmp short $+2
loc_4F252:
jmp short $+2
loc_4F254:
jmp short $+2
loc_4F256:
jmp short $+2
loc_4F258:
jmp short $+2
loc_4F25A:
jmp short $+2
loc_4F25C:
jmp short $+2
loc_4F25E:
add rsp, 40h
pop rbp
retn
|
void Gtid_log_event::Gtid_log_event(
Gtid_log_event *this,
const unsigned __int8 *a2,
unsigned int a3,
const Format_description_log_event *a4)
{
_BYTE *v4; // rcx
unsigned __int8 *v5; // rcx
long long v6; // [rsp+8h] [rbp-38h]
unsigned __int8 v7; // [rsp+1Eh] [rbp-22h]
unsigned __int8 v8; // [rsp+1Fh] [rbp-21h]
unsigned __int8 *v11; // [rsp+30h] [rbp-10h]
unsigned __int8 *v12; // [rsp+30h] [rbp-10h]
unsigned __int8 *v13; // [rsp+30h] [rbp-10h]
unsigned __int8 *v14; // [rsp+30h] [rbp-10h]
Log_event::Log_event(this, a2, a4);
*(_QWORD *)this = &`vtable for'Gtid_log_event + 2;
*((_QWORD *)this + 18) = 0LL;
*((_QWORD *)this + 19) = 0LL;
*((_DWORD *)this + 157) = 0;
*((_BYTE *)this + 632) = 0;
v8 = *((_BYTE *)a4 + 205);
v7 = *(_BYTE *)(*((_QWORD *)a4 + 26) + 161LL);
if ( a3 >= v7 + (unsigned int)v8 && v7 >= 0x13u )
{
v11 = (unsigned __int8 *)&a2[v8];
*((_QWORD *)this + 18) = *(_QWORD *)v11;
v11 += 8;
*((_DWORD *)this + 40) = *(_DWORD *)v11;
v4 = v11 + 4;
v12 = v11 + 5;
*((_BYTE *)this + 624) = *v4;
if ( (*((_BYTE *)this + 624) & 2) != 0 )
{
if ( a3 < (unsigned int)v8 + 21 )
{
*((_QWORD *)this + 18) = 0LL;
return;
}
*((_QWORD *)this + 19) = *(_QWORD *)v12;
v12 += 8;
}
if ( (*((_BYTE *)this + 624) & 0xC0) != 0 )
{
*((_QWORD *)this + 21) = *(unsigned int *)v12;
v13 = v12 + 4;
*((_QWORD *)this + 22) = *v13;
*((_QWORD *)this + 23) = v13[1];
v13 += 2;
v6 = *((_QWORD *)this + 22) + *((_QWORD *)this + 23);
memcpy((char *)this + 192, v13, v6);
v12 = &v13[v6];
}
if ( (int)v12 - (int)a2 < a3 )
{
v5 = v12;
v14 = v12 + 1;
*((_DWORD *)this + 157) = *v5;
if ( (*((_DWORD *)this + 157) & 1) != 0 )
*((_BYTE *)this + 632) = *v14;
}
}
}
|
Gtid_log_event:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x40],RDI
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0014b9e0
MOV RAX,qword ptr [RBP + -0x40]
LEA RCX,[0x3799e0]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x90],0x0
MOV qword ptr [RAX + 0x98],0x0
MOV dword ptr [RAX + 0x274],0x0
MOV byte ptr [RAX + 0x278],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV AL,byte ptr [RAX + 0xcd]
MOV byte ptr [RBP + -0x21],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xd0]
MOV AL,byte ptr [RAX + 0xa1]
MOV byte ptr [RBP + -0x22],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOVZX ECX,byte ptr [RBP + -0x21]
MOVZX EDX,byte ptr [RBP + -0x22]
ADD ECX,EDX
CMP EAX,ECX
JC 0x0014f0a8
MOVZX EAX,byte ptr [RBP + -0x22]
CMP EAX,0x13
JGE 0x0014f0ad
LAB_0014f0a8:
JMP 0x0014f25e
LAB_0014f0ad:
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EDX,byte ptr [RBP + -0x21]
MOV RCX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
ADD RCX,RDX
MOV qword ptr [RBP + -0x10],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RAX + 0x90],RCX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x8
MOV qword ptr [RBP + -0x10],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RAX + 0xa0],ECX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x4
MOV qword ptr [RBP + -0x10],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV CL,byte ptr [RCX]
MOV byte ptr [RAX + 0x270],CL
MOVZX EAX,byte ptr [RAX + 0x270]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0014f15e
MOV EAX,dword ptr [RBP + -0x14]
MOVZX ECX,byte ptr [RBP + -0x21]
ADD ECX,0x13
ADD ECX,0x2
CMP EAX,ECX
JNC 0x0014f140
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x90],0x0
JMP 0x0014f25e
LAB_0014f140:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x8
MOV qword ptr [RBP + -0x10],RAX
LAB_0014f15e:
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,byte ptr [RAX + 0x270]
AND EAX,0xc0
CMP EAX,0x0
JZ 0x0014f1ef
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RDI + 0xa8],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x4
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RDI + 0xb0],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
MOV qword ptr [RDI + 0xb8],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RDI + 0xb8]
ADD RAX,qword ptr [RDI + 0xb0]
MOV qword ptr [RBP + -0x38],RAX
ADD RDI,0xa8
ADD RDI,0x18
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x0013b0c0
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
LAB_0014f1ef:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
CMP EAX,dword ptr [RBP + -0x14]
JNC 0x0014f252
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOVZX ECX,byte ptr [RCX]
MOV dword ptr [RAX + 0x274],ECX
MOV EAX,dword ptr [RAX + 0x274]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0014f250
JMP 0x0014f22b
LAB_0014f22b:
JMP 0x0014f22d
LAB_0014f22d:
JMP 0x0014f22f
LAB_0014f22f:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV CL,byte ptr [RCX]
MOV byte ptr [RAX + 0x278],CL
JMP 0x0014f24c
LAB_0014f24c:
JMP 0x0014f24e
LAB_0014f24e:
JMP 0x0014f250
LAB_0014f250:
JMP 0x0014f252
LAB_0014f252:
JMP 0x0014f254
LAB_0014f254:
JMP 0x0014f256
LAB_0014f256:
JMP 0x0014f258
LAB_0014f258:
JMP 0x0014f25a
LAB_0014f25a:
JMP 0x0014f25c
LAB_0014f25c:
JMP 0x0014f25e
LAB_0014f25e:
ADD RSP,0x40
POP RBP
RET
|
/* Gtid_log_event::Gtid_log_event(unsigned char const*, unsigned int, Format_description_log_event
const*) */
void __thiscall
Gtid_log_event::Gtid_log_event
(Gtid_log_event *this,uchar *param_1,uint param_2,Format_description_log_event *param_3)
{
Format_description_log_event FVar1;
long lVar2;
long lVar3;
uchar *puVar4;
uint *local_18;
Log_event::Log_event((Log_event *)this,param_1,param_3);
*(int ***)this = &PTR_print_003799f0;
*(int8 *)(this + 0x90) = 0;
*(int8 *)(this + 0x98) = 0;
*(int4 *)(this + 0x274) = 0;
this[0x278] = (Gtid_log_event)0x0;
FVar1 = param_3[0xcd];
if (((uint)(byte)FVar1 + (uint)*(byte *)(*(long *)(param_3 + 0xd0) + 0xa1) <= param_2) &&
(0x12 < *(byte *)(*(long *)(param_3 + 0xd0) + 0xa1))) {
puVar4 = param_1 + (int)(uint)(byte)FVar1;
*(int8 *)(this + 0x90) = *(int8 *)puVar4;
*(int4 *)(this + 0xa0) = *(int4 *)(puVar4 + 8);
local_18 = (uint *)(puVar4 + 0xd);
this[0x270] = *(Gtid_log_event *)(puVar4 + 0xc);
if (((byte)this[0x270] & 2) != 0) {
if (param_2 < (byte)FVar1 + 0x15) {
*(int8 *)(this + 0x90) = 0;
return;
}
*(int8 *)(this + 0x98) = *(int8 *)local_18;
local_18 = (uint *)(puVar4 + 0x15);
}
if (((byte)this[0x270] & 0xc0) != 0) {
*(ulong *)(this + 0xa8) = (ulong)*local_18;
*(ulong *)(this + 0xb0) = (ulong)(byte)local_18[1];
*(ulong *)(this + 0xb8) = (ulong)*(byte *)((long)local_18 + 5);
lVar2 = *(long *)(this + 0xb8);
lVar3 = *(long *)(this + 0xb0);
memcpy(this + 0xc0,(byte *)((long)local_18 + 6),lVar2 + lVar3);
local_18 = (uint *)((byte *)((long)local_18 + 6) + lVar2 + lVar3);
}
if ((uint)((int)local_18 - (int)param_1) < param_2) {
*(uint *)(this + 0x274) = (uint)(byte)*local_18;
if ((*(uint *)(this + 0x274) & 1) != 0) {
this[0x278] = *(Gtid_log_event *)((long)local_18 + 1);
}
}
}
return;
}
|
|
10,897 |
Gtid_log_event::Gtid_log_event(unsigned char const*, unsigned int, Format_description_log_event const*)
|
eloqsql/sql/log_event.cc
|
Gtid_log_event::Gtid_log_event(const uchar *buf, uint event_len,
const Format_description_log_event
*description_event)
: Log_event(buf, description_event), seq_no(0), commit_id(0),
flags_extra(0), extra_engines(0)
{
uint8 header_size= description_event->common_header_len;
uint8 post_header_len= description_event->post_header_len[GTID_EVENT-1];
const uchar *buf_0= buf;
if (event_len < (uint) header_size + (uint) post_header_len ||
post_header_len < GTID_HEADER_LEN)
return;
buf+= header_size;
seq_no= uint8korr(buf);
buf+= 8;
domain_id= uint4korr(buf);
buf+= 4;
flags2= *(buf++);
if (flags2 & FL_GROUP_COMMIT_ID)
{
if (event_len < (uint)header_size + GTID_HEADER_LEN + 2)
{
seq_no= 0; // So is_valid() returns false
return;
}
commit_id= uint8korr(buf);
buf+= 8;
}
if (flags2 & (FL_PREPARED_XA | FL_COMPLETED_XA))
{
xid.formatID= uint4korr(buf);
buf+= 4;
xid.gtrid_length= (long) buf[0];
xid.bqual_length= (long) buf[1];
buf+= 2;
long data_length= xid.bqual_length + xid.gtrid_length;
memcpy(xid.data, buf, data_length);
buf+= data_length;
}
/* the extra flags check and actions */
if (static_cast<uint>(buf - buf_0) < event_len)
{
flags_extra= *buf++;
/*
extra engines flags presence is identifed by non-zero byte value
at this point
*/
if (flags_extra & FL_EXTRA_MULTI_ENGINE)
{
DBUG_ASSERT(static_cast<uint>(buf - buf_0) < event_len);
extra_engines= *buf++;
DBUG_ASSERT(extra_engines > 0);
}
}
/*
the strict '<' part of the assert corresponds to extra zero-padded
trailing bytes,
*/
DBUG_ASSERT(static_cast<uint>(buf - buf_0) <= event_len);
/* and the last of them is tested. */
#ifdef MYSQL_SERVER
#ifdef WITH_WSREP
if (!WSREP_ON)
#endif
#endif
DBUG_ASSERT(static_cast<uint>(buf - buf_0) == event_len ||
buf_0[event_len - 1] == 0);
}
|
O3
|
cpp
|
Gtid_log_event::Gtid_log_event(unsigned char const*, unsigned int, Format_description_log_event const*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rdx
callq 0x47c04
leaq 0x311b1b(%rip), %rax # 0x35b6a0
movq %rax, (%rbx)
movl $0x0, 0x274(%rbx)
movb $0x0, 0x278(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movzbl 0xcd(%r12), %eax
movq 0xd0(%r12), %rcx
movzbl 0xa1(%rcx), %ecx
cmpl $0x13, %ecx
setb %dl
addl %eax, %ecx
cmpl %r14d, %ecx
seta %cl
orb %dl, %cl
jne 0x49c96
movl %eax, %r13d
movq (%r15,%r13), %rcx
movq %rcx, 0x90(%rbx)
movl 0x8(%r15,%r13), %ecx
movl %ecx, 0xa0(%rbx)
movb 0xc(%r15,%r13), %cl
movb %cl, 0x270(%rbx)
testb $0x2, %cl
jne 0x49c03
addq %r15, %r13
addq $0xd, %r13
jmp 0x49c2d
addl $0x15, %eax
cmpl %r14d, %eax
jbe 0x49c1b
addq $0x90, %rbx
movq $0x0, (%rbx)
jmp 0x49c96
addq %r15, %r13
movq 0xd(%r13), %rax
movq %rax, 0x98(%rbx)
addq $0x15, %r13
cmpb $0x40, %cl
jb 0x49c72
movl (%r13), %eax
movq %rax, 0xa8(%rbx)
movzbl 0x4(%r13), %eax
movq %rax, 0xb0(%rbx)
movzbl 0x5(%r13), %r12d
movq %r12, 0xb8(%rbx)
leaq 0x6(%r13), %rsi
addq %rax, %r12
leaq 0xc0(%rbx), %rdi
movq %r12, %rdx
callq 0x3a0c0
addq %r12, %r13
addq $0x6, %r13
movl %r13d, %eax
subl %r15d, %eax
cmpl %r14d, %eax
jae 0x49c96
movzbl (%r13), %eax
movl %eax, 0x274(%rbx)
testb $0x1, %al
je 0x49c96
movb 0x1(%r13), %al
movb %al, 0x278(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN14Gtid_log_eventC2EPKhjPK28Format_description_log_event:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rcx
mov r14d, edx
mov r15, rsi
mov rbx, rdi
mov rdx, rcx
call _ZN9Log_eventC2EPKhPK28Format_description_log_event; Log_event::Log_event(uchar const*,Format_description_log_event const*)
lea rax, off_35B6A0
mov [rbx], rax
mov dword ptr [rbx+274h], 0
mov byte ptr [rbx+278h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx+90h], xmm0
movzx eax, byte ptr [r12+0CDh]
mov rcx, [r12+0D0h]
movzx ecx, byte ptr [rcx+0A1h]
cmp ecx, 13h
setb dl
add ecx, eax
cmp ecx, r14d
setnbe cl
or cl, dl
jnz loc_49C96
mov r13d, eax
mov rcx, [r15+r13]
mov [rbx+90h], rcx
mov ecx, [r15+r13+8]
mov [rbx+0A0h], ecx
mov cl, [r15+r13+0Ch]
mov [rbx+270h], cl
test cl, 2
jnz short loc_49C03
add r13, r15
add r13, 0Dh
jmp short loc_49C2D
loc_49C03:
add eax, 15h
cmp eax, r14d
jbe short loc_49C1B
add rbx, 90h
mov qword ptr [rbx], 0
jmp short loc_49C96
loc_49C1B:
add r13, r15
mov rax, [r13+0Dh]
mov [rbx+98h], rax
add r13, 15h
loc_49C2D:
cmp cl, 40h ; '@'
jb short loc_49C72
mov eax, [r13+0]
mov [rbx+0A8h], rax
movzx eax, byte ptr [r13+4]
mov [rbx+0B0h], rax
movzx r12d, byte ptr [r13+5]
mov [rbx+0B8h], r12
lea rsi, [r13+6]
add r12, rax
lea rdi, [rbx+0C0h]
mov rdx, r12
call _memcpy
add r13, r12
add r13, 6
loc_49C72:
mov eax, r13d
sub eax, r15d
cmp eax, r14d
jnb short loc_49C96
movzx eax, byte ptr [r13+0]
mov [rbx+274h], eax
test al, 1
jz short loc_49C96
mov al, [r13+1]
mov [rbx+278h], al
loc_49C96:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
void Gtid_log_event::Gtid_log_event(
Gtid_log_event *this,
const unsigned __int8 *a2,
unsigned int a3,
const Format_description_log_event *a4)
{
long long v6; // r8
long long v7; // r9
int v8; // eax
unsigned int v9; // ecx
long long v10; // rcx
const unsigned __int8 *v11; // r13
const unsigned __int8 *v12; // r13
long long v13; // rax
long long v14; // r12
long long v15; // r12
int v16; // eax
Log_event::Log_event(this, a2, a4);
*(_QWORD *)this = &off_35B6A0;
*((_DWORD *)this + 157) = 0;
*((_BYTE *)this + 632) = 0;
*((_OWORD *)this + 9) = 0LL;
v8 = *((unsigned __int8 *)a4 + 205);
v9 = *(unsigned __int8 *)(*((_QWORD *)a4 + 26) + 161LL);
if ( v9 >= 0x13 && v8 + v9 <= a3 )
{
*((_QWORD *)this + 18) = *(_QWORD *)&a2[*((unsigned __int8 *)a4 + 205)];
v10 = *(unsigned int *)&a2[v8 + 8];
*((_DWORD *)this + 40) = v10;
LOBYTE(v10) = a2[v8 + 12];
*((_BYTE *)this + 624) = v10;
if ( (v10 & 2) != 0 )
{
if ( v8 + 21 > a3 )
{
*((_QWORD *)this + 18) = 0LL;
return;
}
v12 = &a2[v8];
*((_QWORD *)this + 19) = *(_QWORD *)(v12 + 13);
v11 = v12 + 21;
}
else
{
v11 = &a2[v8 + 13];
}
if ( (unsigned __int8)v10 >= 0x40u )
{
*((_QWORD *)this + 21) = *(unsigned int *)v11;
v13 = v11[4];
*((_QWORD *)this + 22) = v13;
v14 = v11[5];
*((_QWORD *)this + 23) = v14;
v15 = v13 + v14;
memcpy((char *)this + 192, v11 + 6, v15, v10, v6, v7);
v11 += v15 + 6;
}
if ( (int)v11 - (int)a2 < a3 )
{
v16 = *v11;
*((_DWORD *)this + 157) = v16;
if ( (v16 & 1) != 0 )
*((_BYTE *)this + 632) = v11[1];
}
}
}
|
Gtid_log_event:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RCX
MOV R14D,EDX
MOV R15,RSI
MOV RBX,RDI
MOV RDX,RCX
CALL 0x00147c04
LEA RAX,[0x45b6a0]
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x274],0x0
MOV byte ptr [RBX + 0x278],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x90],XMM0
MOVZX EAX,byte ptr [R12 + 0xcd]
MOV RCX,qword ptr [R12 + 0xd0]
MOVZX ECX,byte ptr [RCX + 0xa1]
CMP ECX,0x13
SETC DL
ADD ECX,EAX
CMP ECX,R14D
SETA CL
OR CL,DL
JNZ 0x00149c96
MOV R13D,EAX
MOV RCX,qword ptr [R15 + R13*0x1]
MOV qword ptr [RBX + 0x90],RCX
MOV ECX,dword ptr [R15 + R13*0x1 + 0x8]
MOV dword ptr [RBX + 0xa0],ECX
MOV CL,byte ptr [R15 + R13*0x1 + 0xc]
MOV byte ptr [RBX + 0x270],CL
TEST CL,0x2
JNZ 0x00149c03
ADD R13,R15
ADD R13,0xd
JMP 0x00149c2d
LAB_00149c03:
ADD EAX,0x15
CMP EAX,R14D
JBE 0x00149c1b
ADD RBX,0x90
MOV qword ptr [RBX],0x0
JMP 0x00149c96
LAB_00149c1b:
ADD R13,R15
MOV RAX,qword ptr [R13 + 0xd]
MOV qword ptr [RBX + 0x98],RAX
ADD R13,0x15
LAB_00149c2d:
CMP CL,0x40
JC 0x00149c72
MOV EAX,dword ptr [R13]
MOV qword ptr [RBX + 0xa8],RAX
MOVZX EAX,byte ptr [R13 + 0x4]
MOV qword ptr [RBX + 0xb0],RAX
MOVZX R12D,byte ptr [R13 + 0x5]
MOV qword ptr [RBX + 0xb8],R12
LEA RSI,[R13 + 0x6]
ADD R12,RAX
LEA RDI,[RBX + 0xc0]
MOV RDX,R12
CALL 0x0013a0c0
ADD R13,R12
ADD R13,0x6
LAB_00149c72:
MOV EAX,R13D
SUB EAX,R15D
CMP EAX,R14D
JNC 0x00149c96
MOVZX EAX,byte ptr [R13]
MOV dword ptr [RBX + 0x274],EAX
TEST AL,0x1
JZ 0x00149c96
MOV AL,byte ptr [R13 + 0x1]
MOV byte ptr [RBX + 0x278],AL
LAB_00149c96:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Gtid_log_event::Gtid_log_event(unsigned char const*, unsigned int, Format_description_log_event
const*) */
void __thiscall
Gtid_log_event::Gtid_log_event
(Gtid_log_event *this,uchar *param_1,uint param_2,Format_description_log_event *param_3)
{
Gtid_log_event GVar1;
Format_description_log_event FVar2;
byte bVar3;
long lVar4;
uint uVar5;
size_t __n;
ulong uVar6;
uint *puVar7;
Log_event::Log_event((Log_event *)this,param_1,param_3);
*(int ***)this = &PTR_print_0045b6a0;
*(int4 *)(this + 0x274) = 0;
this[0x278] = (Gtid_log_event)0x0;
*(int8 *)(this + 0x90) = 0;
*(int8 *)(this + 0x98) = 0;
FVar2 = param_3[0xcd];
if ((uint)*(byte *)(*(long *)(param_3 + 0xd0) + 0xa1) + (uint)(byte)FVar2 <= param_2 &&
0x12 < *(byte *)(*(long *)(param_3 + 0xd0) + 0xa1)) {
uVar6 = (ulong)(uint)(byte)FVar2;
*(int8 *)(this + 0x90) = *(int8 *)(param_1 + uVar6);
*(int4 *)(this + 0xa0) = *(int4 *)(param_1 + uVar6 + 8);
GVar1 = *(Gtid_log_event *)(param_1 + uVar6 + 0xc);
this[0x270] = GVar1;
if (((byte)GVar1 & 2) == 0) {
lVar4 = uVar6 + 0xd;
}
else {
if (param_2 < (byte)FVar2 + 0x15) {
*(int8 *)(this + 0x90) = 0;
return;
}
*(int8 *)(this + 0x98) = *(int8 *)(param_1 + uVar6 + 0xd);
lVar4 = uVar6 + 0x15;
}
puVar7 = (uint *)(param_1 + lVar4);
if (0x3f < (byte)GVar1) {
*(ulong *)(this + 0xa8) = (ulong)*puVar7;
uVar5 = puVar7[1];
*(ulong *)(this + 0xb0) = (ulong)(byte)uVar5;
bVar3 = *(byte *)((long)puVar7 + 5);
*(ulong *)(this + 0xb8) = (ulong)bVar3;
__n = (ulong)bVar3 + (ulong)(byte)uVar5;
memcpy(this + 0xc0,(byte *)((long)puVar7 + 6),__n);
puVar7 = (uint *)((long)puVar7 + __n + 6);
}
if (((uint)((int)puVar7 - (int)param_1) < param_2) &&
(uVar5 = *puVar7, *(uint *)(this + 0x274) = (uint)(byte)uVar5, ((byte)uVar5 & 1) != 0)) {
this[0x278] = *(Gtid_log_event *)((long)puVar7 + 1);
}
}
return;
}
|
|
10,898 |
my_casedn_str_mb
|
eloqsql/strings/ctype-mb.c
|
size_t my_casedn_str_mb(CHARSET_INFO * cs, char *str)
{
register uint32 l;
register const uchar *map= cs->to_lower;
char *str_orig= str;
while (*str)
{
/* Pointing after the '\0' is safe here. */
if ((l= my_ismbchar(cs, str, str + cs->mbmaxlen)))
str+= l;
else
{
*str= (char) map[(uchar)*str];
str++;
}
}
return (size_t) (str - str_orig);
}
|
O3
|
c
|
my_casedn_str_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpb $0x0, (%rsi)
movq %rsi, %rax
je 0x6fcd8
movq %rdi, %r14
movq 0x48(%rdi), %r12
movq %rbx, %r15
movl 0x9c(%r14), %edx
addq %r15, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xc0(%rax)
cmpl $0x2, %eax
jge 0x6fcc8
movzbl (%r15), %eax
movb (%r12,%rax), %al
movb %al, (%r15)
movl $0x1, %ecx
jmp 0x6fcca
movl %eax, %ecx
leaq (%r15,%rcx), %rax
cmpb $0x0, (%r15,%rcx)
movq %rax, %r15
jne 0x6fc94
subq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
my_casedn_str_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rsi
cmp byte ptr [rsi], 0
mov rax, rsi
jz short loc_6FCD8
mov r14, rdi
mov r12, [rdi+48h]
mov r15, rbx
loc_6FC94:
mov edx, [r14+9Ch]
add rdx, r15
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, r15
call qword ptr [rax+0C0h]
cmp eax, 2
jge short loc_6FCC8
movzx eax, byte ptr [r15]
mov al, [r12+rax]
mov [r15], al
mov ecx, 1
jmp short loc_6FCCA
loc_6FCC8:
mov ecx, eax
loc_6FCCA:
lea rax, [r15+rcx]
cmp byte ptr [r15+rcx], 0
mov r15, rax
jnz short loc_6FC94
loc_6FCD8:
sub rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long my_casedn_str_mb(long long a1, _BYTE *a2)
{
_BYTE *v2; // rax
long long v3; // r12
_BYTE *v4; // r15
int v5; // eax
long long v6; // rcx
bool v7; // zf
v2 = a2;
if ( *a2 )
{
v3 = *(_QWORD *)(a1 + 72);
v4 = a2;
do
{
v5 = (*(long long ( **)(long long, _BYTE *, _BYTE *))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v4,
&v4[*(unsigned int *)(a1 + 156)]);
if ( v5 >= 2 )
{
v6 = (unsigned int)v5;
}
else
{
*v4 = *(_BYTE *)(v3 + (unsigned __int8)*v4);
v6 = 1LL;
}
v2 = &v4[v6];
v7 = v4[v6] == 0;
v4 += v6;
}
while ( !v7 );
}
return v2 - a2;
}
|
my_casedn_str_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RSI
CMP byte ptr [RSI],0x0
MOV RAX,RSI
JZ 0x0016fcd8
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x48]
MOV R15,RBX
LAB_0016fc94:
MOV EDX,dword ptr [R14 + 0x9c]
ADD RDX,R15
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,R15
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
JGE 0x0016fcc8
MOVZX EAX,byte ptr [R15]
MOV AL,byte ptr [R12 + RAX*0x1]
MOV byte ptr [R15],AL
MOV ECX,0x1
JMP 0x0016fcca
LAB_0016fcc8:
MOV ECX,EAX
LAB_0016fcca:
LEA RAX,[R15 + RCX*0x1]
CMP byte ptr [R15 + RCX*0x1],0x0
MOV R15,RAX
JNZ 0x0016fc94
LAB_0016fcd8:
SUB RAX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long my_casedn_str_mb(long param_1,byte *param_2)
{
byte *pbVar1;
long lVar2;
uint uVar3;
byte *pbVar4;
ulong uVar5;
byte *pbVar6;
pbVar4 = param_2;
if (*param_2 != 0) {
lVar2 = *(long *)(param_1 + 0x48);
pbVar6 = param_2;
do {
uVar3 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,pbVar6,pbVar6 + *(uint *)(param_1 + 0x9c));
if ((int)uVar3 < 2) {
*pbVar6 = *(byte *)(lVar2 + (ulong)*pbVar6);
uVar5 = 1;
}
else {
uVar5 = (ulong)uVar3;
}
pbVar4 = pbVar6 + uVar5;
pbVar1 = pbVar6 + uVar5;
pbVar6 = pbVar4;
} while (*pbVar1 != 0);
}
return (long)pbVar4 - (long)param_2;
}
|
|
10,899 |
ma_crypt_pre_read_hook
|
eloqsql/storage/maria/ma_crypt.c
|
static my_bool ma_crypt_pre_read_hook(PAGECACHE_IO_HOOK_ARGS *args)
{
MARIA_SHARE *share= (MARIA_SHARE*) args->data;
uchar *crypt_buf= my_malloc(PSI_INSTRUMENT_ME, share->block_size, MYF(0));
if (crypt_buf == NULL)
{
args->crypt_buf= NULL; /* for post-hook */
return 1;
}
/* swap pointers to read into crypt_buf */
args->crypt_buf= args->page;
args->page= crypt_buf;
return 0;
}
|
O3
|
c
|
ma_crypt_pre_read_hook:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movl 0x7bc(%rax), %esi
xorl %r14d, %r14d
xorl %edi, %edi
xorl %edx, %edx
callq 0x9fd89
testq %rax, %rax
je 0x50f82
movq (%rbx), %r14
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x50f84
movb $0x1, %al
movq %r14, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
|
ma_crypt_pre_read_hook:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov rax, [rdi+10h]
mov esi, [rax+7BCh]
xor r14d, r14d
xor edi, edi
xor edx, edx
call my_malloc
test rax, rax
jz short loc_50F82
mov r14, [rbx]
mov [rbx], rax
xor eax, eax
jmp short loc_50F84
loc_50F82:
mov al, 1
loc_50F84:
mov [rbx+18h], r14
pop rbx
pop r14
pop rbp
retn
|
long long ma_crypt_pre_read_hook(long long *a1)
{
long long v1; // r14
long long v2; // rax
long long result; // rax
v1 = 0LL;
v2 = my_malloc(0LL, *(unsigned int *)(a1[2] + 1980), 0LL);
if ( v2 )
{
v1 = *a1;
*a1 = v2;
result = 0LL;
}
else
{
result = 1LL;
}
a1[3] = v1;
return result;
}
|
ma_crypt_pre_read_hook:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x10]
MOV ESI,dword ptr [RAX + 0x7bc]
XOR R14D,R14D
XOR EDI,EDI
XOR EDX,EDX
CALL 0x0019fd89
TEST RAX,RAX
JZ 0x00150f82
MOV R14,qword ptr [RBX]
MOV qword ptr [RBX],RAX
XOR EAX,EAX
JMP 0x00150f84
LAB_00150f82:
MOV AL,0x1
LAB_00150f84:
MOV qword ptr [RBX + 0x18],R14
POP RBX
POP R14
POP RBP
RET
|
bool ma_crypt_pre_read_hook(long *param_1)
{
long lVar1;
long lVar2;
lVar2 = 0;
lVar1 = my_malloc(0,*(int4 *)(param_1[2] + 0x7bc),0);
if (lVar1 != 0) {
lVar2 = *param_1;
*param_1 = lVar1;
}
param_1[3] = lVar2;
return lVar1 == 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.